Struct Q 

#[repr(transparent)]
pub struct Q<T, A, const F: i8> {
    pub inner: T,
    /* private fields */
}

Fixed point integer

Generics:

• T: Base integer
• A: Accumulator for intermediate results
• F: Number of fractional bits right of the decimal point

F negative is supported analogously.

• Q32<31> is (-1..1).step_by(2^-31)
• Q<i16, _, 20> is (-1/32..1/32).step_by(2^-20)
• Q<u8, _, 4> is (0..16).step_by(1/16)
• Q<u8, _, -2> is (0..1024).step_by(4)

assert_eq!(Q8::<4>::from_int(3), Q8::new(3 << 4));
assert_eq!(7 * Q8::<4>::from_f32(1.5), 10);
assert_eq!(7 / Q8::<4>::from_f32(1.5), 4);

Fields

inner: T

The inner value representation

Implementations

impl<T, A, const F: i8> Q<T, A, F>

pub const DELTA: f32

Step between distinct numbers

assert_eq!(Q32::<31>::DELTA, 2f32.powi(-31));
assert_eq!(Q32::<-4>::DELTA, 2f32.powi(4));

pub const fn new(inner: T) -> Self

Create a new fixed point number from a given representation

assert_eq!(P8::<9>::new(3).inner, 3);

impl<T: Shift, A, const F: i8> Q<T, A, F>

pub fn scale<const F1: i8>(self) -> Q<T, A, F1>

Convert to a different number of fractional bits (truncating)

Use this liberally for Add/Sub/Rem with Q’s of different F.

assert_eq!(Q8::<4>::new(32).scale::<0>(), Q8::new(2));

pub fn trunc(self) -> T

Return the integer part

assert_eq!(Q8::<4>::new(0x35).trunc(), 0x3);

pub fn from_int(value: T) -> Self

Scale from integer base type

assert_eq!(Q8::<4>::from_int(7).inner, 7 << 4);

impl<A: Shift, T: Accu<A>, const F: i8> Q<A, T, F>

pub fn quantize(self) -> T

Scale from integer accu type

let q = Q8::<4>::from_f32(0.25);
assert_eq!((q * 7).quantize(), (7.0 * 0.25f32).floor() as _);

impl<T, A, const F: i8> Q<T, A, F>

where f32: AsPrimitive<Q<T, A, F>>, Self: Copy + 'static,

pub fn from_f32(value: f32) -> Self

Quantize a f32

impl<T, A, const F: i8> Q<T, A, F>

where f64: AsPrimitive<Q<T, A, F>>, Self: Copy + 'static,

pub fn from_f64(value: f64) -> Self

Quantize a f64

impl<T, A, const F: i8> Q<T, A, F>

where Self: 'static + Copy + AsPrimitive<f32>,

pub fn as_f32(self) -> f32

Convert lossy to f32

impl<T, A, const F: i8> Q<T, A, F>

where Self: 'static + Copy + AsPrimitive<f64>,

pub fn as_f64(self) -> f64

Convert lossy to f64

Trait Implementations

impl<T: Add<T, Output = T>, A, const F: i8> Add for Q<T, A, F>

type Output = Q<T, A, F>

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self::Output

Performs the + operation.

impl<T: AddAssign<T>, A, const F: i8> AddAssign for Q<T, A, F>

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl<T, A, const F: i8> AsPrimitive<Q<T, A, F>> for Q<T, A, F>

where Self: Copy + 'static,

fn as_(self) -> Self

Convert a value to another, using the as operator.

impl<T: 'static + Copy, A: 'static, const F: i8> AsPrimitive<Q<T, A, F>> for f32

where f32: AsPrimitive<T>,

fn as_(self) -> Q<T, A, F>

Convert a value to another, using the as operator.

impl<T: 'static + Copy, A: 'static, const F: i8> AsPrimitive<Q<T, A, F>> for f64

where f64: AsPrimitive<T>,

fn as_(self) -> Q<T, A, F>

Convert a value to another, using the as operator.

impl<const F: i8> AsPrimitive<Wrapping<i16>> for Q<Wrapping<i32>, Wrapping<i16>, F>

fn as_(self) -> Wrapping<i16>

Scale from integer accu type

impl<const F: i8> AsPrimitive<Wrapping<i32>> for Q<Wrapping<i64>, Wrapping<i32>, F>

fn as_(self) -> Wrapping<i32>

Scale from integer accu type

impl<const F: i8> AsPrimitive<Wrapping<i64>> for Q<Wrapping<i128>, Wrapping<i64>, F>

fn as_(self) -> Wrapping<i64>

Scale from integer accu type

impl<const F: i8> AsPrimitive<Wrapping<i8>> for Q<Wrapping<i16>, Wrapping<i8>, F>

fn as_(self) -> Wrapping<i8>

Scale from integer accu type

impl<const F: i8> AsPrimitive<Wrapping<u16>> for Q<Wrapping<u32>, Wrapping<u16>, F>

fn as_(self) -> Wrapping<u16>

Scale from integer accu type

impl<const F: i8> AsPrimitive<Wrapping<u32>> for Q<Wrapping<u64>, Wrapping<u32>, F>

fn as_(self) -> Wrapping<u32>

Scale from integer accu type

impl<const F: i8> AsPrimitive<Wrapping<u64>> for Q<Wrapping<u128>, Wrapping<u64>, F>

fn as_(self) -> Wrapping<u64>

Scale from integer accu type

impl<const F: i8> AsPrimitive<Wrapping<u8>> for Q<Wrapping<u16>, Wrapping<u8>, F>

fn as_(self) -> Wrapping<u8>

Scale from integer accu type

impl<T: AsPrimitive<f32>, A: 'static, const F: i8> AsPrimitive<f32> for Q<T, A, F>

fn as_(self) -> f32

Convert a value to another, using the as operator.

impl<T: AsPrimitive<f64>, A: 'static, const F: i8> AsPrimitive<f64> for Q<T, A, F>

fn as_(self) -> f64

Convert a value to another, using the as operator.

impl<const F: i8> AsPrimitive<i16> for Q<i32, i16, F>

fn as_(self) -> i16

Scale from integer accu type

impl<const F: i8> AsPrimitive<i32> for Q<i64, i32, F>

fn as_(self) -> i32

Scale from integer accu type

impl<const F: i8> AsPrimitive<i64> for Q<i128, i64, F>

fn as_(self) -> i64

Scale from integer accu type

impl<const F: i8> AsPrimitive<i8> for Q<i16, i8, F>

fn as_(self) -> i8

Scale from integer accu type

impl<const F: i8> AsPrimitive<u16> for Q<u32, u16, F>

fn as_(self) -> u16

Scale from integer accu type

impl<const F: i8> AsPrimitive<u32> for Q<u64, u32, F>

fn as_(self) -> u32

Scale from integer accu type

impl<const F: i8> AsPrimitive<u64> for Q<u128, u64, F>

fn as_(self) -> u64

Scale from integer accu type

impl<const F: i8> AsPrimitive<u8> for Q<u16, u8, F>

fn as_(self) -> u8

Scale from integer accu type

impl<T: Binary, A, const F: i8> Binary for Q<T, A, F>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: BitAnd<T, Output = T>, A, const F: i8> BitAnd for Q<T, A, F>

type Output = Q<T, A, F>

The resulting type after applying the & operator.

fn bitand(self, rhs: Self) -> Self::Output

Performs the & operation.

impl<T: BitAndAssign<T>, A, const F: i8> BitAndAssign for Q<T, A, F>

fn bitand_assign(&mut self, rhs: Self)

Performs the &= operation.

impl<T: BitOr<T, Output = T>, A, const F: i8> BitOr for Q<T, A, F>

type Output = Q<T, A, F>

The resulting type after applying the | operator.

fn bitor(self, rhs: Self) -> Self::Output

Performs the | operation.

impl<T: BitOrAssign<T>, A, const F: i8> BitOrAssign for Q<T, A, F>

fn bitor_assign(&mut self, rhs: Self)

Performs the |= operation.

impl<T: BitXor<T, Output = T>, A, const F: i8> BitXor for Q<T, A, F>

type Output = Q<T, A, F>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Self) -> Self::Output

Performs the ^ operation.

impl<T: BitXorAssign<T>, A, const F: i8> BitXorAssign for Q<T, A, F>

fn bitxor_assign(&mut self, rhs: Self)

Performs the ^= operation.

impl<T: Clone, A, const F: i8> Clone for Q<T, A, F>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<const F: i8> ConstOne for Q<Wrapping<i16>, Wrapping<i32>, F>

const ONE: Self

The multiplicative identity element of Self, 1.

impl<const F: i8> ConstOne for Q<Wrapping<i32>, Wrapping<i64>, F>

const ONE: Self

The multiplicative identity element of Self, 1.

impl<const F: i8> ConstOne for Q<Wrapping<i64>, Wrapping<i128>, F>

const ONE: Self

The multiplicative identity element of Self, 1.

impl<const F: i8> ConstOne for Q<Wrapping<i8>, Wrapping<i16>, F>

const ONE: Self

The multiplicative identity element of Self, 1.

impl<const F: i8> ConstOne for Q<Wrapping<u16>, Wrapping<u32>, F>

const ONE: Self

The multiplicative identity element of Self, 1.

impl<const F: i8> ConstOne for Q<Wrapping<u32>, Wrapping<u64>, F>

const ONE: Self

The multiplicative identity element of Self, 1.

impl<const F: i8> ConstOne for Q<Wrapping<u64>, Wrapping<u128>, F>

const ONE: Self

The multiplicative identity element of Self, 1.

impl<const F: i8> ConstOne for Q<Wrapping<u8>, Wrapping<u16>, F>

const ONE: Self

The multiplicative identity element of Self, 1.

impl<const F: i8> ConstOne for Q<i16, i32, F>

const ONE: Self

The multiplicative identity element of Self, 1.

impl<const F: i8> ConstOne for Q<i32, i64, F>

const ONE: Self

The multiplicative identity element of Self, 1.

impl<const F: i8> ConstOne for Q<i64, i128, F>

const ONE: Self

The multiplicative identity element of Self, 1.

impl<const F: i8> ConstOne for Q<i8, i16, F>

const ONE: Self

The multiplicative identity element of Self, 1.

impl<const F: i8> ConstOne for Q<u16, u32, F>

const ONE: Self

The multiplicative identity element of Self, 1.

impl<const F: i8> ConstOne for Q<u32, u64, F>

const ONE: Self

The multiplicative identity element of Self, 1.

impl<const F: i8> ConstOne for Q<u64, u128, F>

const ONE: Self

The multiplicative identity element of Self, 1.

impl<const F: i8> ConstOne for Q<u8, u16, F>

const ONE: Self

The multiplicative identity element of Self, 1.

impl<T: ConstZero, A, const F: i8> ConstZero for Q<T, A, F>

const ZERO: Self

The additive identity element of Self, 0.

impl<T: Debug, A, const F: i8> Debug for Q<T, A, F>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: Default, A: Default, const F: i8> Default for Q<T, A, F>

fn default() -> Q<T, A, F>

Returns the “default value” for a type.

impl<'de, T, A, const F: i8> Deserialize<'de> for Q<T, A, F>

where T: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T, A, const F: i8> Display for Q<T, A, F>

where Self: Copy + AsPrimitive<f64>,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<const F: i8> Div<Q<Wrapping<i16>, Wrapping<i32>, F>> for Wrapping<i16>

T/Q -> T

type Output = Wrapping<i16>

The resulting type after applying the / operator.

fn div(self, rhs: Q<Wrapping<i16>, Wrapping<i32>, F>) -> Self::Output

Performs the / operation.

impl<const F: i8> Div<Q<Wrapping<i32>, Wrapping<i64>, F>> for Wrapping<i32>

T/Q -> T

type Output = Wrapping<i32>

The resulting type after applying the / operator.

fn div(self, rhs: Q<Wrapping<i32>, Wrapping<i64>, F>) -> Self::Output

Performs the / operation.

impl<const F: i8> Div<Q<Wrapping<i64>, Wrapping<i128>, F>> for Wrapping<i64>

T/Q -> T

type Output = Wrapping<i64>

The resulting type after applying the / operator.

fn div(self, rhs: Q<Wrapping<i64>, Wrapping<i128>, F>) -> Self::Output

Performs the / operation.

impl<const F: i8> Div<Q<Wrapping<i8>, Wrapping<i16>, F>> for Wrapping<i8>

T/Q -> T

type Output = Wrapping<i8>

The resulting type after applying the / operator.

fn div(self, rhs: Q<Wrapping<i8>, Wrapping<i16>, F>) -> Self::Output

Performs the / operation.

impl<const F: i8> Div<Q<Wrapping<u16>, Wrapping<u32>, F>> for Wrapping<u16>

T/Q -> T

type Output = Wrapping<u16>

The resulting type after applying the / operator.

fn div(self, rhs: Q<Wrapping<u16>, Wrapping<u32>, F>) -> Self::Output

Performs the / operation.

impl<const F: i8> Div<Q<Wrapping<u32>, Wrapping<u64>, F>> for Wrapping<u32>

T/Q -> T

type Output = Wrapping<u32>

The resulting type after applying the / operator.

fn div(self, rhs: Q<Wrapping<u32>, Wrapping<u64>, F>) -> Self::Output

Performs the / operation.

impl<const F: i8> Div<Q<Wrapping<u64>, Wrapping<u128>, F>> for Wrapping<u64>

T/Q -> T

type Output = Wrapping<u64>

The resulting type after applying the / operator.

fn div(self, rhs: Q<Wrapping<u64>, Wrapping<u128>, F>) -> Self::Output

Performs the / operation.

impl<const F: i8> Div<Q<Wrapping<u8>, Wrapping<u16>, F>> for Wrapping<u8>

T/Q -> T

type Output = Wrapping<u8>

The resulting type after applying the / operator.

fn div(self, rhs: Q<Wrapping<u8>, Wrapping<u16>, F>) -> Self::Output

Performs the / operation.

impl<const F: i8> Div<Q<i16, i32, F>> for i16

T/Q -> T

type Output = i16

The resulting type after applying the / operator.

fn div(self, rhs: Q<i16, i32, F>) -> Self::Output

Performs the / operation.

impl<const F: i8> Div<Q<i32, i64, F>> for i32

T/Q -> T

type Output = i32

The resulting type after applying the / operator.

fn div(self, rhs: Q<i32, i64, F>) -> Self::Output

Performs the / operation.

impl<const F: i8> Div<Q<i64, i128, F>> for i64

T/Q -> T

type Output = i64

The resulting type after applying the / operator.

fn div(self, rhs: Q<i64, i128, F>) -> Self::Output

Performs the / operation.

impl<const F: i8> Div<Q<i8, i16, F>> for i8

T/Q -> T

type Output = i8

The resulting type after applying the / operator.

fn div(self, rhs: Q<i8, i16, F>) -> Self::Output

Performs the / operation.

impl<const F: i8> Div<Q<u16, u32, F>> for u16

T/Q -> T

type Output = u16

The resulting type after applying the / operator.

fn div(self, rhs: Q<u16, u32, F>) -> Self::Output

Performs the / operation.

impl<const F: i8> Div<Q<u32, u64, F>> for u32

T/Q -> T

type Output = u32

The resulting type after applying the / operator.

fn div(self, rhs: Q<u32, u64, F>) -> Self::Output

Performs the / operation.

impl<const F: i8> Div<Q<u64, u128, F>> for u64

T/Q -> T

type Output = u64

The resulting type after applying the / operator.

fn div(self, rhs: Q<u64, u128, F>) -> Self::Output

Performs the / operation.

impl<const F: i8> Div<Q<u8, u16, F>> for u8

T/Q -> T

type Output = u8

The resulting type after applying the / operator.

fn div(self, rhs: Q<u8, u16, F>) -> Self::Output

Performs the / operation.

impl<T: Div<Output = T>, A, const F: i8> Div<T> for Q<T, A, F>

type Output = Q<T, A, F>

The resulting type after applying the / operator.

fn div(self, rhs: T) -> Self

Performs the / operation.

impl<T, A, const F: i8> Div for Q<T, A, F>

where Self: DivAssign,

Q/Q -> Q

assert_eq!(Q8::<4>::from_int(3) / Q8::from_int(2), Q8::from_f32(1.5));

type Output = Q<T, A, F>

The resulting type after applying the / operator.

fn div(self, rhs: Self) -> Self::Output

Performs the / operation.

impl<T: Copy + Shift + Accu<A> + Div<T, Output = T>, A: Shift + Div<A, Output = A>, const F: i8, const F1: i8> DivAssign<Q<T, A, F1>> for Q<T, A, F>

Q /= Q’

let mut q = Q8::<4>::from_f32(0.75);
q /= Q8::<3>::from_int(3);
assert_eq!(q, Q8::from_f32(0.25));

fn div_assign(&mut self, rhs: Q<T, A, F1>)

Performs the /= operation.

impl<T: DivAssign<T>, A, const F: i8> DivAssign<T> for Q<T, A, F>

fn div_assign(&mut self, rhs: T)

Performs the /= operation.

impl<T: Accu<A> + Shift, A, const F: i8> From<(T, i8)> for Q<T, A, F>

Lossy conversion from a dynamically scaled integer

assert_eq!(Q8::<8>::from((1, 3)).inner, 1 << 5);

fn from(value: (T, i8)) -> Self

Converts to this type from the input type.

impl<T, A, const F: i8> From<Q<T, A, F>> for (T, i8)

Lossless conversion into a dynamically scaled integer

let q: (i8, i8) = Q8::<8>::new(9).into();
assert_eq!(q, (9, 8));

fn from(value: Q<T, A, F>) -> Self

Converts to this type from the input type.

impl<T, A, const F: i8> LowerExp for Q<T, A, F>

where Self: Copy + AsPrimitive<f64>,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: LowerHex, A, const F: i8> LowerHex for Q<T, A, F>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<const F: i8> Mul<Q<Wrapping<i16>, Wrapping<i32>, F>> for Wrapping<i16>

T*Q -> T

type Output = Wrapping<i16>

The resulting type after applying the * operator.

fn mul(self, rhs: Q<Wrapping<i16>, Wrapping<i32>, F>) -> Self::Output

Performs the * operation.

impl<const F: i8> Mul<Q<Wrapping<i32>, Wrapping<i64>, F>> for Wrapping<i32>

T*Q -> T

type Output = Wrapping<i32>

The resulting type after applying the * operator.

fn mul(self, rhs: Q<Wrapping<i32>, Wrapping<i64>, F>) -> Self::Output

Performs the * operation.

impl<const F: i8> Mul<Q<Wrapping<i64>, Wrapping<i128>, F>> for Wrapping<i64>

T*Q -> T

type Output = Wrapping<i64>

The resulting type after applying the * operator.

fn mul(self, rhs: Q<Wrapping<i64>, Wrapping<i128>, F>) -> Self::Output

Performs the * operation.

impl<const F: i8> Mul<Q<Wrapping<i8>, Wrapping<i16>, F>> for Wrapping<i8>

T*Q -> T

type Output = Wrapping<i8>

The resulting type after applying the * operator.

fn mul(self, rhs: Q<Wrapping<i8>, Wrapping<i16>, F>) -> Self::Output

Performs the * operation.

impl<const F: i8> Mul<Q<Wrapping<u16>, Wrapping<u32>, F>> for Wrapping<u16>

T*Q -> T

type Output = Wrapping<u16>

The resulting type after applying the * operator.

fn mul(self, rhs: Q<Wrapping<u16>, Wrapping<u32>, F>) -> Self::Output

Performs the * operation.

impl<const F: i8> Mul<Q<Wrapping<u32>, Wrapping<u64>, F>> for Wrapping<u32>

T*Q -> T

type Output = Wrapping<u32>

The resulting type after applying the * operator.

fn mul(self, rhs: Q<Wrapping<u32>, Wrapping<u64>, F>) -> Self::Output

Performs the * operation.

impl<const F: i8> Mul<Q<Wrapping<u64>, Wrapping<u128>, F>> for Wrapping<u64>

T*Q -> T

type Output = Wrapping<u64>

The resulting type after applying the * operator.

fn mul(self, rhs: Q<Wrapping<u64>, Wrapping<u128>, F>) -> Self::Output

Performs the * operation.

impl<const F: i8> Mul<Q<Wrapping<u8>, Wrapping<u16>, F>> for Wrapping<u8>

T*Q -> T

type Output = Wrapping<u8>

The resulting type after applying the * operator.

fn mul(self, rhs: Q<Wrapping<u8>, Wrapping<u16>, F>) -> Self::Output

Performs the * operation.

impl<const F: i8> Mul<Q<i16, i32, F>> for i16

T*Q -> T

type Output = i16

The resulting type after applying the * operator.

fn mul(self, rhs: Q<i16, i32, F>) -> Self::Output

Performs the * operation.

impl<const F: i8> Mul<Q<i32, i64, F>> for i32

T*Q -> T

type Output = i32

The resulting type after applying the * operator.

fn mul(self, rhs: Q<i32, i64, F>) -> Self::Output

Performs the * operation.

impl<const F: i8> Mul<Q<i64, i128, F>> for i64

T*Q -> T

type Output = i64

The resulting type after applying the * operator.

fn mul(self, rhs: Q<i64, i128, F>) -> Self::Output

Performs the * operation.

impl<const F: i8> Mul<Q<i8, i16, F>> for i8

T*Q -> T

type Output = i8

The resulting type after applying the * operator.

fn mul(self, rhs: Q<i8, i16, F>) -> Self::Output

Performs the * operation.

impl<const F: i8> Mul<Q<u16, u32, F>> for u16

T*Q -> T

type Output = u16

The resulting type after applying the * operator.

fn mul(self, rhs: Q<u16, u32, F>) -> Self::Output

Performs the * operation.

impl<const F: i8> Mul<Q<u32, u64, F>> for u32

T*Q -> T

type Output = u32

The resulting type after applying the * operator.

fn mul(self, rhs: Q<u32, u64, F>) -> Self::Output

Performs the * operation.

impl<const F: i8> Mul<Q<u64, u128, F>> for u64

T*Q -> T

type Output = u64

The resulting type after applying the * operator.

fn mul(self, rhs: Q<u64, u128, F>) -> Self::Output

Performs the * operation.

impl<const F: i8> Mul<Q<u8, u16, F>> for u8

T*Q -> T

type Output = u8

The resulting type after applying the * operator.

fn mul(self, rhs: Q<u8, u16, F>) -> Self::Output

Performs the * operation.

impl<T: Accu<A>, A: Mul<Output = A>, const F: i8> Mul<T> for Q<T, A, F>

Wide multiplication to accumulator

assert_eq!(Q8::<3>::new(4) * 2, Q::new(8));
assert_eq!(Q8::<3>::new(4) / 2, Q8::new(2));

type Output = Q<A, T, F>

The resulting type after applying the * operator.

fn mul(self, rhs: T) -> Q<A, T, F>

Performs the * operation.

impl<T, A, const F: i8> Mul for Q<T, A, F>

where Self: MulAssign,

Q*Q -> Q

assert_eq!(
    Q8::<4>::from_f32(0.75) * Q8::from_int(3),
    Q8::from_f32(2.25)
);

type Output = Q<T, A, F>

The resulting type after applying the * operator.

fn mul(self, rhs: Self) -> Self::Output

Performs the * operation.

impl<T: Copy + Accu<A>, A: Shift + Mul<A, Output = A>, const F: i8, const F1: i8> MulAssign<Q<T, A, F1>> for Q<T, A, F>

Q *= Q’

let mut q = Q8::<4>::from_f32(0.25);
q *= Q8::<3>::from_int(3);
assert_eq!(q, Q8::from_f32(0.75));

fn mul_assign(&mut self, rhs: Q<T, A, F1>)

Performs the *= operation.

impl<T: MulAssign<T>, A, const F: i8> MulAssign<T> for Q<T, A, F>

fn mul_assign(&mut self, rhs: T)

Performs the *= operation.

impl<T: Neg<Output = T>, A, const F: i8> Neg for Q<T, A, F>

type Output = Q<T, A, F>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<T: Not<Output = T>, A, const F: i8> Not for Q<T, A, F>

type Output = Q<T, A, F>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<T: Octal, A, const F: i8> Octal for Q<T, A, F>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: One + Shift, A, const F: i8> One for Q<T, A, F>

where Self: Mul<Output = Self>,

fn one() -> Self

Returns the multiplicative identity element of Self, 1.

fn set_one(&mut self)

Sets self to the multiplicative identity element of Self, 1.

fn is_one(&self) -> bool

where Self: PartialEq,

Returns true if self is equal to the multiplicative identity.

impl<T: Ord, A, const F: i8> Ord for Q<T, A, F>

where Self: PartialOrd,

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<T: PartialEq, A, const F: i8> PartialEq for Q<T, A, F>

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: PartialOrd, A, const F: i8> PartialOrd for Q<T, A, F>

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T: Rem<T, Output = T>, A, const F: i8> Rem for Q<T, A, F>

type Output = Q<T, A, F>

The resulting type after applying the % operator.

fn rem(self, rhs: Self) -> Self::Output

Performs the % operation.

impl<T: RemAssign<T>, A, const F: i8> RemAssign for Q<T, A, F>

fn rem_assign(&mut self, rhs: Self)

Performs the %= operation.

impl<T, A, const F: i8> Serialize for Q<T, A, F>

where T: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<U, T: Shl<U, Output = T>, A, const F: i8> Shl<U> for Q<T, A, F>

type Output = Q<T, A, F>

The resulting type after applying the << operator.

fn shl(self, rhs: U) -> Self::Output

Performs the << operation.

impl<T: ShlAssign<U>, U, A, const F: i8> ShlAssign<U> for Q<T, A, F>

fn shl_assign(&mut self, rhs: U)

Performs the <<= operation.

impl<U, T: Shr<U, Output = T>, A, const F: i8> Shr<U> for Q<T, A, F>

type Output = Q<T, A, F>

The resulting type after applying the >> operator.

fn shr(self, rhs: U) -> Self::Output

Performs the >> operation.

impl<T: ShrAssign<U>, U, A, const F: i8> ShrAssign<U> for Q<T, A, F>

fn shr_assign(&mut self, rhs: U)

Performs the >>= operation.

impl<T: Sub<T, Output = T>, A, const F: i8> Sub for Q<T, A, F>

type Output = Q<T, A, F>

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self::Output

Performs the - operation.

impl<T: SubAssign<T>, A, const F: i8> SubAssign for Q<T, A, F>

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl<T: Sum, A, const F: i8> Sum for Q<T, A, F>

fn sum<I: Iterator<Item = Self>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by “summing up” the items.

impl<T, A, const F: i8> UpperExp for Q<T, A, F>

where Self: Copy + AsPrimitive<f64>,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: UpperHex, A, const F: i8> UpperHex for Q<T, A, F>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: Zero, A, const F: i8> Zero for Q<T, A, F>

where Self: Add<Output = Self>,

fn zero() -> Self

Returns the additive identity element of Self, 0.

fn is_zero(&self) -> bool

Returns true if self is equal to the additive identity.

fn set_zero(&mut self)

Sets self to the additive identity element of Self, 0.

impl<T: Copy, A, const F: i8> Copy for Q<T, A, F>

impl<T: Eq, A, const F: i8> Eq for Q<T, A, F>

where Self: PartialEq,