Struct FastFixed 

#[repr(transparent)]
pub struct FastFixed<I, const FRAC: usize>(pub Fixed<I, FRAC>);

A wrapper around Fixed that forces intermediate calculations to be performed in 64-bit space for maximum execution efficiency on 64-bit targets.

Warning: Range Reduction at High Resolutions

Because intermediate calculations (such as multiplication and division) are performed within 64-bit integers (either signed i64 or unsigned u64 depending on the operands) before rescaling, FastFixed saturates significantly earlier than 128-bit Fixed.

For high-resolution formats (e.g., FRAC >= 32), even multiplying modest values like 1.0 * 1.0 can result in early saturation (or scaling down to smaller values) because the 64-bit intermediate product overflows. Use FastFixed primarily when fractional bit resolutions are small enough to accommodate your expected dynamic range within 64 bits.

Tuple Fields

0: Fixed<I, FRAC>

Implementations

impl<I: Copy, const FRAC: usize> FastFixed<I, FRAC>

pub const fn from_raw(value: I) -> Self

Creates a FastFixed value from a raw underlying integer value.

pub const fn raw_value(&self) -> I

Returns the raw fixed-point value as the underlying integer type.

pub const fn into_fixed(self) -> Fixed<I, FRAC>

Returns the underlying Fixed value.

impl<I: Bounded + NumCast + Copy, const FRAC: usize> FastFixed<I, FRAC>

pub fn min() -> Self

Returns the minimum value of this fixed point format.

pub fn max() -> Self

Returns the maximum value of this fixed point format.

impl<R, const FRAC_OUT: usize> FastFixed<R, FRAC_OUT>

where R: Bounded + NumCast + Copy,

pub fn from_fixed<OtherI: Copy, const OTHER_FRAC: usize>( other: FastFixed<OtherI, OTHER_FRAC>, ) -> Self

where Value<OtherI, OTHER_FRAC>: ConvertValue<R, FRAC_OUT>,

Converts other into this format, rounding half to even when precision is reduced and saturating when the value does not fit.

This is the equivalent of the C++ ffl idiom Target{other} and replaces the Fixed::from_fixed(other.into_fixed()).into() round trip.

Trait Implementations

impl<I, const FRAC: usize, E> Add<E> for FastFixed<I, FRAC>

where I: Bounded + NumCast + Copy, E: FastExpression, FastFixed<I, FRAC>: Add<FastFixed<I, FRAC>>,

type Output = <FastFixed<I, FRAC> as Add>::Output

The resulting type after applying the + operator.

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

Performs the + operation.

impl<I, const FRAC: usize, L, R> Add<FastFixed<I, FRAC>> for MulExpression<L, R>

where I: Bounded + NumCast + Copy, MulExpression<L, R>: FastExpression, FastFixed<I, FRAC>: Add<FastFixed<I, FRAC>>,

type Output = <FastFixed<I, FRAC> as Add>::Output

The resulting type after applying the + operator.

fn add(self, rhs: FastFixed<I, FRAC>) -> Self::Output

Performs the + operation.

impl<I, const FRAC: usize, L, R> Add<FastFixed<I, FRAC>> for SumExpression<L, R>

where I: Bounded + NumCast + Copy, SumExpression<L, R>: FastExpression, FastFixed<I, FRAC>: Add<FastFixed<I, FRAC>>,

type Output = <FastFixed<I, FRAC> as Add>::Output

The resulting type after applying the + operator.

fn add(self, rhs: FastFixed<I, FRAC>) -> Self::Output

Performs the + operation.

impl<T, const FRAC: usize, U, const FRAC_R: usize> Add<FastFixed<U, FRAC_R>> for FastFixed<T, FRAC>

where T: PromoteAddSub<U> + Zero + PartialOrd + NumCast + Copy, U: Zero + PartialOrd + NumCast + Copy, <T as PromoteAddSub<U>>::Output: FastInt,

type Output = FastFixed<<T as PromoteAddSub<U>>::Output, FRAC>

The resulting type after applying the + operator.

fn add(self, rhs: FastFixed<U, FRAC_R>) -> Self::Output

Performs the + operation.

impl<const FRAC: usize> Add<FastFixed<i8, FRAC>> for i8

where i8: PromoteAddSub<i8> + NumCast + Copy, <i8 as PromoteAddSub<i8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i8 as PromoteAddSub<i8>>::Output, FRAC>

The resulting type after applying the + operator.

fn add(self, rhs: FastFixed<i8, FRAC>) -> Self::Output

Performs the + operation.

impl<const FRAC: usize> Add<FastFixed<i8, FRAC>> for i16

where i8: PromoteAddSub<i16> + NumCast + Copy, i16: NumCast + Copy, <i8 as PromoteAddSub<i16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i8 as PromoteAddSub<i16>>::Output, FRAC>

The resulting type after applying the + operator.

fn add(self, rhs: FastFixed<i8, FRAC>) -> Self::Output

Performs the + operation.

impl<const FRAC: usize> Add<FastFixed<i8, FRAC>> for i32

where i8: PromoteAddSub<i32> + NumCast + Copy, i32: NumCast + Copy, <i8 as PromoteAddSub<i32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i8 as PromoteAddSub<i32>>::Output, FRAC>

The resulting type after applying the + operator.

fn add(self, rhs: FastFixed<i8, FRAC>) -> Self::Output

Performs the + operation.

impl<const FRAC: usize> Add<FastFixed<i8, FRAC>> for i64

where i8: PromoteAddSub<i64> + NumCast + Copy, i64: NumCast + Copy, <i8 as PromoteAddSub<i64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i8 as PromoteAddSub<i64>>::Output, FRAC>

The resulting type after applying the + operator.

fn add(self, rhs: FastFixed<i8, FRAC>) -> Self::Output

Performs the + operation.

impl<const FRAC: usize> Add<FastFixed<i8, FRAC>> for u8

where i8: PromoteAddSub<u8> + NumCast + Copy, u8: NumCast + Copy, <i8 as PromoteAddSub<u8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i8 as PromoteAddSub<u8>>::Output, FRAC>

The resulting type after applying the + operator.

fn add(self, rhs: FastFixed<i8, FRAC>) -> Self::Output

Performs the + operation.

impl<const FRAC: usize> Add<FastFixed<i8, FRAC>> for u16

where i8: PromoteAddSub<u16> + NumCast + Copy, u16: NumCast + Copy, <i8 as PromoteAddSub<u16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i8 as PromoteAddSub<u16>>::Output, FRAC>

The resulting type after applying the + operator.

fn add(self, rhs: FastFixed<i8, FRAC>) -> Self::Output

Performs the + operation.

impl<const FRAC: usize> Add<FastFixed<i8, FRAC>> for u32

where i8: PromoteAddSub<u32> + NumCast + Copy, u32: NumCast + Copy, <i8 as PromoteAddSub<u32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i8 as PromoteAddSub<u32>>::Output, FRAC>

The resulting type after applying the + operator.

fn add(self, rhs: FastFixed<i8, FRAC>) -> Self::Output

Performs the + operation.

impl<const FRAC: usize> Add<FastFixed<i8, FRAC>> for u64

where i8: PromoteAddSub<u64> + NumCast + Copy, u64: NumCast + Copy, <i8 as PromoteAddSub<u64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i8 as PromoteAddSub<u64>>::Output, FRAC>

The resulting type after applying the + operator.

fn add(self, rhs: FastFixed<i8, FRAC>) -> Self::Output

Performs the + operation.

impl<const FRAC: usize> Add<FastFixed<i16, FRAC>> for i8

where i16: PromoteAddSub<i8> + NumCast + Copy, i8: NumCast + Copy, <i16 as PromoteAddSub<i8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i16 as PromoteAddSub<i8>>::Output, FRAC>

The resulting type after applying the + operator.

fn add(self, rhs: FastFixed<i16, FRAC>) -> Self::Output

Performs the + operation.

impl<const FRAC: usize> Add<FastFixed<i16, FRAC>> for i16

where i16: PromoteAddSub<i16> + NumCast + Copy, <i16 as PromoteAddSub<i16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i16 as PromoteAddSub<i16>>::Output, FRAC>

The resulting type after applying the + operator.

fn add(self, rhs: FastFixed<i16, FRAC>) -> Self::Output

Performs the + operation.

impl<const FRAC: usize> Add<FastFixed<i16, FRAC>> for i32

where i16: PromoteAddSub<i32> + NumCast + Copy, i32: NumCast + Copy, <i16 as PromoteAddSub<i32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i16 as PromoteAddSub<i32>>::Output, FRAC>

The resulting type after applying the + operator.

fn add(self, rhs: FastFixed<i16, FRAC>) -> Self::Output

Performs the + operation.

impl<const FRAC: usize> Add<FastFixed<i16, FRAC>> for i64

where i16: PromoteAddSub<i64> + NumCast + Copy, i64: NumCast + Copy, <i16 as PromoteAddSub<i64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i16 as PromoteAddSub<i64>>::Output, FRAC>

The resulting type after applying the + operator.

fn add(self, rhs: FastFixed<i16, FRAC>) -> Self::Output

Performs the + operation.

impl<const FRAC: usize> Add<FastFixed<i16, FRAC>> for u8

where i16: PromoteAddSub<u8> + NumCast + Copy, u8: NumCast + Copy, <i16 as PromoteAddSub<u8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i16 as PromoteAddSub<u8>>::Output, FRAC>

The resulting type after applying the + operator.

fn add(self, rhs: FastFixed<i16, FRAC>) -> Self::Output

Performs the + operation.

impl<const FRAC: usize> Add<FastFixed<i16, FRAC>> for u16

where i16: PromoteAddSub<u16> + NumCast + Copy, u16: NumCast + Copy, <i16 as PromoteAddSub<u16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i16 as PromoteAddSub<u16>>::Output, FRAC>

The resulting type after applying the + operator.

fn add(self, rhs: FastFixed<i16, FRAC>) -> Self::Output

Performs the + operation.

impl<const FRAC: usize> Add<FastFixed<i16, FRAC>> for u32

where i16: PromoteAddSub<u32> + NumCast + Copy, u32: NumCast + Copy, <i16 as PromoteAddSub<u32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i16 as PromoteAddSub<u32>>::Output, FRAC>

The resulting type after applying the + operator.

fn add(self, rhs: FastFixed<i16, FRAC>) -> Self::Output

Performs the + operation.

impl<const FRAC: usize> Add<FastFixed<i16, FRAC>> for u64

where i16: PromoteAddSub<u64> + NumCast + Copy, u64: NumCast + Copy, <i16 as PromoteAddSub<u64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i16 as PromoteAddSub<u64>>::Output, FRAC>

The resulting type after applying the + operator.

fn add(self, rhs: FastFixed<i16, FRAC>) -> Self::Output

Performs the + operation.

impl<const FRAC: usize> Add<FastFixed<i32, FRAC>> for i8

where i32: PromoteAddSub<i8> + NumCast + Copy, i8: NumCast + Copy, <i32 as PromoteAddSub<i8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i32 as PromoteAddSub<i8>>::Output, FRAC>

The resulting type after applying the + operator.

fn add(self, rhs: FastFixed<i32, FRAC>) -> Self::Output

Performs the + operation.

impl<const FRAC: usize> Add<FastFixed<i32, FRAC>> for i16

where i32: PromoteAddSub<i16> + NumCast + Copy, i16: NumCast + Copy, <i32 as PromoteAddSub<i16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i32 as PromoteAddSub<i16>>::Output, FRAC>

The resulting type after applying the + operator.

fn add(self, rhs: FastFixed<i32, FRAC>) -> Self::Output

Performs the + operation.

impl<const FRAC: usize> Add<FastFixed<i32, FRAC>> for i32

where i32: PromoteAddSub<i32> + NumCast + Copy, <i32 as PromoteAddSub<i32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i32 as PromoteAddSub<i32>>::Output, FRAC>

The resulting type after applying the + operator.

fn add(self, rhs: FastFixed<i32, FRAC>) -> Self::Output

Performs the + operation.

impl<const FRAC: usize> Add<FastFixed<i32, FRAC>> for i64

where i32: PromoteAddSub<i64> + NumCast + Copy, i64: NumCast + Copy, <i32 as PromoteAddSub<i64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i32 as PromoteAddSub<i64>>::Output, FRAC>

The resulting type after applying the + operator.

fn add(self, rhs: FastFixed<i32, FRAC>) -> Self::Output

Performs the + operation.

impl<const FRAC: usize> Add<FastFixed<i32, FRAC>> for u8

where i32: PromoteAddSub<u8> + NumCast + Copy, u8: NumCast + Copy, <i32 as PromoteAddSub<u8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i32 as PromoteAddSub<u8>>::Output, FRAC>

The resulting type after applying the + operator.

fn add(self, rhs: FastFixed<i32, FRAC>) -> Self::Output

Performs the + operation.

impl<const FRAC: usize> Add<FastFixed<i32, FRAC>> for u16

where i32: PromoteAddSub<u16> + NumCast + Copy, u16: NumCast + Copy, <i32 as PromoteAddSub<u16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i32 as PromoteAddSub<u16>>::Output, FRAC>

The resulting type after applying the + operator.

fn add(self, rhs: FastFixed<i32, FRAC>) -> Self::Output

Performs the + operation.

impl<const FRAC: usize> Add<FastFixed<i32, FRAC>> for u32

where i32: PromoteAddSub<u32> + NumCast + Copy, u32: NumCast + Copy, <i32 as PromoteAddSub<u32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i32 as PromoteAddSub<u32>>::Output, FRAC>

The resulting type after applying the + operator.

fn add(self, rhs: FastFixed<i32, FRAC>) -> Self::Output

Performs the + operation.

impl<const FRAC: usize> Add<FastFixed<i32, FRAC>> for u64

where i32: PromoteAddSub<u64> + NumCast + Copy, u64: NumCast + Copy, <i32 as PromoteAddSub<u64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i32 as PromoteAddSub<u64>>::Output, FRAC>

The resulting type after applying the + operator.

fn add(self, rhs: FastFixed<i32, FRAC>) -> Self::Output

Performs the + operation.

impl<const FRAC: usize> Add<FastFixed<i64, FRAC>> for i8

where i64: PromoteAddSub<i8> + NumCast + Copy, i8: NumCast + Copy, <i64 as PromoteAddSub<i8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i64 as PromoteAddSub<i8>>::Output, FRAC>

The resulting type after applying the + operator.

fn add(self, rhs: FastFixed<i64, FRAC>) -> Self::Output

Performs the + operation.

impl<const FRAC: usize> Add<FastFixed<i64, FRAC>> for i16

where i64: PromoteAddSub<i16> + NumCast + Copy, i16: NumCast + Copy, <i64 as PromoteAddSub<i16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i64 as PromoteAddSub<i16>>::Output, FRAC>

The resulting type after applying the + operator.

fn add(self, rhs: FastFixed<i64, FRAC>) -> Self::Output

Performs the + operation.

impl<const FRAC: usize> Add<FastFixed<i64, FRAC>> for i32

where i64: PromoteAddSub<i32> + NumCast + Copy, i32: NumCast + Copy, <i64 as PromoteAddSub<i32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i64 as PromoteAddSub<i32>>::Output, FRAC>

The resulting type after applying the + operator.

fn add(self, rhs: FastFixed<i64, FRAC>) -> Self::Output

Performs the + operation.

impl<const FRAC: usize> Add<FastFixed<i64, FRAC>> for i64

where i64: PromoteAddSub<i64> + NumCast + Copy, <i64 as PromoteAddSub<i64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i64 as PromoteAddSub<i64>>::Output, FRAC>

The resulting type after applying the + operator.

fn add(self, rhs: FastFixed<i64, FRAC>) -> Self::Output

Performs the + operation.

impl<const FRAC: usize> Add<FastFixed<i64, FRAC>> for u8

where i64: PromoteAddSub<u8> + NumCast + Copy, u8: NumCast + Copy, <i64 as PromoteAddSub<u8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i64 as PromoteAddSub<u8>>::Output, FRAC>

The resulting type after applying the + operator.

fn add(self, rhs: FastFixed<i64, FRAC>) -> Self::Output

Performs the + operation.

impl<const FRAC: usize> Add<FastFixed<i64, FRAC>> for u16

where i64: PromoteAddSub<u16> + NumCast + Copy, u16: NumCast + Copy, <i64 as PromoteAddSub<u16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i64 as PromoteAddSub<u16>>::Output, FRAC>

The resulting type after applying the + operator.

fn add(self, rhs: FastFixed<i64, FRAC>) -> Self::Output

Performs the + operation.

impl<const FRAC: usize> Add<FastFixed<i64, FRAC>> for u32

where i64: PromoteAddSub<u32> + NumCast + Copy, u32: NumCast + Copy, <i64 as PromoteAddSub<u32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i64 as PromoteAddSub<u32>>::Output, FRAC>

The resulting type after applying the + operator.

fn add(self, rhs: FastFixed<i64, FRAC>) -> Self::Output

Performs the + operation.

impl<const FRAC: usize> Add<FastFixed<i64, FRAC>> for u64

where i64: PromoteAddSub<u64> + NumCast + Copy, u64: NumCast + Copy, <i64 as PromoteAddSub<u64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i64 as PromoteAddSub<u64>>::Output, FRAC>

The resulting type after applying the + operator.

fn add(self, rhs: FastFixed<i64, FRAC>) -> Self::Output

Performs the + operation.

impl<const FRAC: usize> Add<FastFixed<u8, FRAC>> for u8

where u8: PromoteAddSub<u8> + NumCast + Copy, <u8 as PromoteAddSub<u8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u8 as PromoteAddSub<u8>>::Output, FRAC>

The resulting type after applying the + operator.

fn add(self, rhs: FastFixed<u8, FRAC>) -> Self::Output

Performs the + operation.

impl<const FRAC: usize> Add<FastFixed<u8, FRAC>> for u16

where u8: PromoteAddSub<u16> + NumCast + Copy, u16: NumCast + Copy, <u8 as PromoteAddSub<u16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u8 as PromoteAddSub<u16>>::Output, FRAC>

The resulting type after applying the + operator.

fn add(self, rhs: FastFixed<u8, FRAC>) -> Self::Output

Performs the + operation.

impl<const FRAC: usize> Add<FastFixed<u8, FRAC>> for u32

where u8: PromoteAddSub<u32> + NumCast + Copy, u32: NumCast + Copy, <u8 as PromoteAddSub<u32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u8 as PromoteAddSub<u32>>::Output, FRAC>

The resulting type after applying the + operator.

fn add(self, rhs: FastFixed<u8, FRAC>) -> Self::Output

Performs the + operation.

impl<const FRAC: usize> Add<FastFixed<u8, FRAC>> for u64

where u8: PromoteAddSub<u64> + NumCast + Copy, u64: NumCast + Copy, <u8 as PromoteAddSub<u64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u8 as PromoteAddSub<u64>>::Output, FRAC>

The resulting type after applying the + operator.

fn add(self, rhs: FastFixed<u8, FRAC>) -> Self::Output

Performs the + operation.

impl<const FRAC: usize> Add<FastFixed<u8, FRAC>> for i8

where u8: PromoteAddSub<i8> + NumCast + Copy, i8: NumCast + Copy, <u8 as PromoteAddSub<i8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u8 as PromoteAddSub<i8>>::Output, FRAC>

The resulting type after applying the + operator.

fn add(self, rhs: FastFixed<u8, FRAC>) -> Self::Output

Performs the + operation.

impl<const FRAC: usize> Add<FastFixed<u8, FRAC>> for i16

where u8: PromoteAddSub<i16> + NumCast + Copy, i16: NumCast + Copy, <u8 as PromoteAddSub<i16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u8 as PromoteAddSub<i16>>::Output, FRAC>

The resulting type after applying the + operator.

fn add(self, rhs: FastFixed<u8, FRAC>) -> Self::Output

Performs the + operation.

impl<const FRAC: usize> Add<FastFixed<u8, FRAC>> for i32

where u8: PromoteAddSub<i32> + NumCast + Copy, i32: NumCast + Copy, <u8 as PromoteAddSub<i32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u8 as PromoteAddSub<i32>>::Output, FRAC>

The resulting type after applying the + operator.

fn add(self, rhs: FastFixed<u8, FRAC>) -> Self::Output

Performs the + operation.

impl<const FRAC: usize> Add<FastFixed<u8, FRAC>> for i64

where u8: PromoteAddSub<i64> + NumCast + Copy, i64: NumCast + Copy, <u8 as PromoteAddSub<i64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u8 as PromoteAddSub<i64>>::Output, FRAC>

The resulting type after applying the + operator.

fn add(self, rhs: FastFixed<u8, FRAC>) -> Self::Output

Performs the + operation.

impl<const FRAC: usize> Add<FastFixed<u16, FRAC>> for u8

where u16: PromoteAddSub<u8> + NumCast + Copy, u8: NumCast + Copy, <u16 as PromoteAddSub<u8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u16 as PromoteAddSub<u8>>::Output, FRAC>

The resulting type after applying the + operator.

fn add(self, rhs: FastFixed<u16, FRAC>) -> Self::Output

Performs the + operation.

impl<const FRAC: usize> Add<FastFixed<u16, FRAC>> for u16

where u16: PromoteAddSub<u16> + NumCast + Copy, <u16 as PromoteAddSub<u16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u16 as PromoteAddSub<u16>>::Output, FRAC>

The resulting type after applying the + operator.

fn add(self, rhs: FastFixed<u16, FRAC>) -> Self::Output

Performs the + operation.

impl<const FRAC: usize> Add<FastFixed<u16, FRAC>> for u32

where u16: PromoteAddSub<u32> + NumCast + Copy, u32: NumCast + Copy, <u16 as PromoteAddSub<u32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u16 as PromoteAddSub<u32>>::Output, FRAC>

The resulting type after applying the + operator.

fn add(self, rhs: FastFixed<u16, FRAC>) -> Self::Output

Performs the + operation.

impl<const FRAC: usize> Add<FastFixed<u16, FRAC>> for u64

where u16: PromoteAddSub<u64> + NumCast + Copy, u64: NumCast + Copy, <u16 as PromoteAddSub<u64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u16 as PromoteAddSub<u64>>::Output, FRAC>

The resulting type after applying the + operator.

fn add(self, rhs: FastFixed<u16, FRAC>) -> Self::Output

Performs the + operation.

impl<const FRAC: usize> Add<FastFixed<u16, FRAC>> for i8

where u16: PromoteAddSub<i8> + NumCast + Copy, i8: NumCast + Copy, <u16 as PromoteAddSub<i8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u16 as PromoteAddSub<i8>>::Output, FRAC>

The resulting type after applying the + operator.

fn add(self, rhs: FastFixed<u16, FRAC>) -> Self::Output

Performs the + operation.

impl<const FRAC: usize> Add<FastFixed<u16, FRAC>> for i16

where u16: PromoteAddSub<i16> + NumCast + Copy, i16: NumCast + Copy, <u16 as PromoteAddSub<i16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u16 as PromoteAddSub<i16>>::Output, FRAC>

The resulting type after applying the + operator.

fn add(self, rhs: FastFixed<u16, FRAC>) -> Self::Output

Performs the + operation.

impl<const FRAC: usize> Add<FastFixed<u16, FRAC>> for i32

where u16: PromoteAddSub<i32> + NumCast + Copy, i32: NumCast + Copy, <u16 as PromoteAddSub<i32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u16 as PromoteAddSub<i32>>::Output, FRAC>

The resulting type after applying the + operator.

fn add(self, rhs: FastFixed<u16, FRAC>) -> Self::Output

Performs the + operation.

impl<const FRAC: usize> Add<FastFixed<u16, FRAC>> for i64

where u16: PromoteAddSub<i64> + NumCast + Copy, i64: NumCast + Copy, <u16 as PromoteAddSub<i64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u16 as PromoteAddSub<i64>>::Output, FRAC>

The resulting type after applying the + operator.

fn add(self, rhs: FastFixed<u16, FRAC>) -> Self::Output

Performs the + operation.

impl<const FRAC: usize> Add<FastFixed<u32, FRAC>> for u8

where u32: PromoteAddSub<u8> + NumCast + Copy, u8: NumCast + Copy, <u32 as PromoteAddSub<u8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u32 as PromoteAddSub<u8>>::Output, FRAC>

The resulting type after applying the + operator.

fn add(self, rhs: FastFixed<u32, FRAC>) -> Self::Output

Performs the + operation.

impl<const FRAC: usize> Add<FastFixed<u32, FRAC>> for u16

where u32: PromoteAddSub<u16> + NumCast + Copy, u16: NumCast + Copy, <u32 as PromoteAddSub<u16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u32 as PromoteAddSub<u16>>::Output, FRAC>

The resulting type after applying the + operator.

fn add(self, rhs: FastFixed<u32, FRAC>) -> Self::Output

Performs the + operation.

impl<const FRAC: usize> Add<FastFixed<u32, FRAC>> for u32

where u32: PromoteAddSub<u32> + NumCast + Copy, <u32 as PromoteAddSub<u32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u32 as PromoteAddSub<u32>>::Output, FRAC>

The resulting type after applying the + operator.

fn add(self, rhs: FastFixed<u32, FRAC>) -> Self::Output

Performs the + operation.

impl<const FRAC: usize> Add<FastFixed<u32, FRAC>> for u64

where u32: PromoteAddSub<u64> + NumCast + Copy, u64: NumCast + Copy, <u32 as PromoteAddSub<u64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u32 as PromoteAddSub<u64>>::Output, FRAC>

The resulting type after applying the + operator.

fn add(self, rhs: FastFixed<u32, FRAC>) -> Self::Output

Performs the + operation.

impl<const FRAC: usize> Add<FastFixed<u32, FRAC>> for i8

where u32: PromoteAddSub<i8> + NumCast + Copy, i8: NumCast + Copy, <u32 as PromoteAddSub<i8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u32 as PromoteAddSub<i8>>::Output, FRAC>

The resulting type after applying the + operator.

fn add(self, rhs: FastFixed<u32, FRAC>) -> Self::Output

Performs the + operation.

impl<const FRAC: usize> Add<FastFixed<u32, FRAC>> for i16

where u32: PromoteAddSub<i16> + NumCast + Copy, i16: NumCast + Copy, <u32 as PromoteAddSub<i16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u32 as PromoteAddSub<i16>>::Output, FRAC>

The resulting type after applying the + operator.

fn add(self, rhs: FastFixed<u32, FRAC>) -> Self::Output

Performs the + operation.

impl<const FRAC: usize> Add<FastFixed<u32, FRAC>> for i32

where u32: PromoteAddSub<i32> + NumCast + Copy, i32: NumCast + Copy, <u32 as PromoteAddSub<i32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u32 as PromoteAddSub<i32>>::Output, FRAC>

The resulting type after applying the + operator.

fn add(self, rhs: FastFixed<u32, FRAC>) -> Self::Output

Performs the + operation.

impl<const FRAC: usize> Add<FastFixed<u32, FRAC>> for i64

where u32: PromoteAddSub<i64> + NumCast + Copy, i64: NumCast + Copy, <u32 as PromoteAddSub<i64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u32 as PromoteAddSub<i64>>::Output, FRAC>

The resulting type after applying the + operator.

fn add(self, rhs: FastFixed<u32, FRAC>) -> Self::Output

Performs the + operation.

impl<const FRAC: usize> Add<FastFixed<u64, FRAC>> for u8

where u64: PromoteAddSub<u8> + NumCast + Copy, u8: NumCast + Copy, <u64 as PromoteAddSub<u8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u64 as PromoteAddSub<u8>>::Output, FRAC>

The resulting type after applying the + operator.

fn add(self, rhs: FastFixed<u64, FRAC>) -> Self::Output

Performs the + operation.

impl<const FRAC: usize> Add<FastFixed<u64, FRAC>> for u16

where u64: PromoteAddSub<u16> + NumCast + Copy, u16: NumCast + Copy, <u64 as PromoteAddSub<u16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u64 as PromoteAddSub<u16>>::Output, FRAC>

The resulting type after applying the + operator.

fn add(self, rhs: FastFixed<u64, FRAC>) -> Self::Output

Performs the + operation.

impl<const FRAC: usize> Add<FastFixed<u64, FRAC>> for u32

where u64: PromoteAddSub<u32> + NumCast + Copy, u32: NumCast + Copy, <u64 as PromoteAddSub<u32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u64 as PromoteAddSub<u32>>::Output, FRAC>

The resulting type after applying the + operator.

fn add(self, rhs: FastFixed<u64, FRAC>) -> Self::Output

Performs the + operation.

impl<const FRAC: usize> Add<FastFixed<u64, FRAC>> for u64

where u64: PromoteAddSub<u64> + NumCast + Copy, <u64 as PromoteAddSub<u64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u64 as PromoteAddSub<u64>>::Output, FRAC>

The resulting type after applying the + operator.

fn add(self, rhs: FastFixed<u64, FRAC>) -> Self::Output

Performs the + operation.

impl<const FRAC: usize> Add<FastFixed<u64, FRAC>> for i8

where u64: PromoteAddSub<i8> + NumCast + Copy, i8: NumCast + Copy, <u64 as PromoteAddSub<i8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u64 as PromoteAddSub<i8>>::Output, FRAC>

The resulting type after applying the + operator.

fn add(self, rhs: FastFixed<u64, FRAC>) -> Self::Output

Performs the + operation.

impl<const FRAC: usize> Add<FastFixed<u64, FRAC>> for i16

where u64: PromoteAddSub<i16> + NumCast + Copy, i16: NumCast + Copy, <u64 as PromoteAddSub<i16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u64 as PromoteAddSub<i16>>::Output, FRAC>

The resulting type after applying the + operator.

fn add(self, rhs: FastFixed<u64, FRAC>) -> Self::Output

Performs the + operation.

impl<const FRAC: usize> Add<FastFixed<u64, FRAC>> for i32

where u64: PromoteAddSub<i32> + NumCast + Copy, i32: NumCast + Copy, <u64 as PromoteAddSub<i32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u64 as PromoteAddSub<i32>>::Output, FRAC>

The resulting type after applying the + operator.

fn add(self, rhs: FastFixed<u64, FRAC>) -> Self::Output

Performs the + operation.

impl<const FRAC: usize> Add<FastFixed<u64, FRAC>> for i64

where u64: PromoteAddSub<i64> + NumCast + Copy, i64: NumCast + Copy, <u64 as PromoteAddSub<i64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u64 as PromoteAddSub<i64>>::Output, FRAC>

The resulting type after applying the + operator.

fn add(self, rhs: FastFixed<u64, FRAC>) -> Self::Output

Performs the + operation.

impl<const FRAC: usize> Add<i8> for FastFixed<i8, FRAC>

where i8: PromoteAddSub<i8> + NumCast + Copy, <i8 as PromoteAddSub<i8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i8 as PromoteAddSub<i8>>::Output, FRAC>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const FRAC: usize> Add<i8> for FastFixed<i16, FRAC>

where i16: PromoteAddSub<i8> + NumCast + Copy, i8: NumCast + Copy, <i16 as PromoteAddSub<i8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i16 as PromoteAddSub<i8>>::Output, FRAC>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const FRAC: usize> Add<i8> for FastFixed<i32, FRAC>

where i32: PromoteAddSub<i8> + NumCast + Copy, i8: NumCast + Copy, <i32 as PromoteAddSub<i8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i32 as PromoteAddSub<i8>>::Output, FRAC>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const FRAC: usize> Add<i8> for FastFixed<i64, FRAC>

where i64: PromoteAddSub<i8> + NumCast + Copy, i8: NumCast + Copy, <i64 as PromoteAddSub<i8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i64 as PromoteAddSub<i8>>::Output, FRAC>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const FRAC: usize> Add<i8> for FastFixed<u8, FRAC>

where u8: PromoteAddSub<i8> + NumCast + Copy, i8: NumCast + Copy, <u8 as PromoteAddSub<i8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u8 as PromoteAddSub<i8>>::Output, FRAC>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const FRAC: usize> Add<i8> for FastFixed<u16, FRAC>

where u16: PromoteAddSub<i8> + NumCast + Copy, i8: NumCast + Copy, <u16 as PromoteAddSub<i8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u16 as PromoteAddSub<i8>>::Output, FRAC>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const FRAC: usize> Add<i8> for FastFixed<u32, FRAC>

where u32: PromoteAddSub<i8> + NumCast + Copy, i8: NumCast + Copy, <u32 as PromoteAddSub<i8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u32 as PromoteAddSub<i8>>::Output, FRAC>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const FRAC: usize> Add<i8> for FastFixed<u64, FRAC>

where u64: PromoteAddSub<i8> + NumCast + Copy, i8: NumCast + Copy, <u64 as PromoteAddSub<i8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u64 as PromoteAddSub<i8>>::Output, FRAC>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const FRAC: usize> Add<i16> for FastFixed<i8, FRAC>

where i8: PromoteAddSub<i16> + NumCast + Copy, i16: NumCast + Copy, <i8 as PromoteAddSub<i16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i8 as PromoteAddSub<i16>>::Output, FRAC>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const FRAC: usize> Add<i16> for FastFixed<i16, FRAC>

where i16: PromoteAddSub<i16> + NumCast + Copy, <i16 as PromoteAddSub<i16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i16 as PromoteAddSub<i16>>::Output, FRAC>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const FRAC: usize> Add<i16> for FastFixed<i32, FRAC>

where i32: PromoteAddSub<i16> + NumCast + Copy, i16: NumCast + Copy, <i32 as PromoteAddSub<i16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i32 as PromoteAddSub<i16>>::Output, FRAC>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const FRAC: usize> Add<i16> for FastFixed<i64, FRAC>

where i64: PromoteAddSub<i16> + NumCast + Copy, i16: NumCast + Copy, <i64 as PromoteAddSub<i16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i64 as PromoteAddSub<i16>>::Output, FRAC>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const FRAC: usize> Add<i16> for FastFixed<u8, FRAC>

where u8: PromoteAddSub<i16> + NumCast + Copy, i16: NumCast + Copy, <u8 as PromoteAddSub<i16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u8 as PromoteAddSub<i16>>::Output, FRAC>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const FRAC: usize> Add<i16> for FastFixed<u16, FRAC>

where u16: PromoteAddSub<i16> + NumCast + Copy, i16: NumCast + Copy, <u16 as PromoteAddSub<i16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u16 as PromoteAddSub<i16>>::Output, FRAC>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const FRAC: usize> Add<i16> for FastFixed<u32, FRAC>

where u32: PromoteAddSub<i16> + NumCast + Copy, i16: NumCast + Copy, <u32 as PromoteAddSub<i16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u32 as PromoteAddSub<i16>>::Output, FRAC>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const FRAC: usize> Add<i16> for FastFixed<u64, FRAC>

where u64: PromoteAddSub<i16> + NumCast + Copy, i16: NumCast + Copy, <u64 as PromoteAddSub<i16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u64 as PromoteAddSub<i16>>::Output, FRAC>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const FRAC: usize> Add<i32> for FastFixed<i8, FRAC>

where i8: PromoteAddSub<i32> + NumCast + Copy, i32: NumCast + Copy, <i8 as PromoteAddSub<i32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i8 as PromoteAddSub<i32>>::Output, FRAC>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const FRAC: usize> Add<i32> for FastFixed<i16, FRAC>

where i16: PromoteAddSub<i32> + NumCast + Copy, i32: NumCast + Copy, <i16 as PromoteAddSub<i32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i16 as PromoteAddSub<i32>>::Output, FRAC>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const FRAC: usize> Add<i32> for FastFixed<i32, FRAC>

where i32: PromoteAddSub<i32> + NumCast + Copy, <i32 as PromoteAddSub<i32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i32 as PromoteAddSub<i32>>::Output, FRAC>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const FRAC: usize> Add<i32> for FastFixed<i64, FRAC>

where i64: PromoteAddSub<i32> + NumCast + Copy, i32: NumCast + Copy, <i64 as PromoteAddSub<i32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i64 as PromoteAddSub<i32>>::Output, FRAC>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const FRAC: usize> Add<i32> for FastFixed<u8, FRAC>

where u8: PromoteAddSub<i32> + NumCast + Copy, i32: NumCast + Copy, <u8 as PromoteAddSub<i32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u8 as PromoteAddSub<i32>>::Output, FRAC>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const FRAC: usize> Add<i32> for FastFixed<u16, FRAC>

where u16: PromoteAddSub<i32> + NumCast + Copy, i32: NumCast + Copy, <u16 as PromoteAddSub<i32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u16 as PromoteAddSub<i32>>::Output, FRAC>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const FRAC: usize> Add<i32> for FastFixed<u32, FRAC>

where u32: PromoteAddSub<i32> + NumCast + Copy, i32: NumCast + Copy, <u32 as PromoteAddSub<i32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u32 as PromoteAddSub<i32>>::Output, FRAC>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const FRAC: usize> Add<i32> for FastFixed<u64, FRAC>

where u64: PromoteAddSub<i32> + NumCast + Copy, i32: NumCast + Copy, <u64 as PromoteAddSub<i32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u64 as PromoteAddSub<i32>>::Output, FRAC>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const FRAC: usize> Add<i64> for FastFixed<i8, FRAC>

where i8: PromoteAddSub<i64> + NumCast + Copy, i64: NumCast + Copy, <i8 as PromoteAddSub<i64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i8 as PromoteAddSub<i64>>::Output, FRAC>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const FRAC: usize> Add<i64> for FastFixed<i16, FRAC>

where i16: PromoteAddSub<i64> + NumCast + Copy, i64: NumCast + Copy, <i16 as PromoteAddSub<i64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i16 as PromoteAddSub<i64>>::Output, FRAC>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const FRAC: usize> Add<i64> for FastFixed<i32, FRAC>

where i32: PromoteAddSub<i64> + NumCast + Copy, i64: NumCast + Copy, <i32 as PromoteAddSub<i64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i32 as PromoteAddSub<i64>>::Output, FRAC>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const FRAC: usize> Add<i64> for FastFixed<i64, FRAC>

where i64: PromoteAddSub<i64> + NumCast + Copy, <i64 as PromoteAddSub<i64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i64 as PromoteAddSub<i64>>::Output, FRAC>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const FRAC: usize> Add<i64> for FastFixed<u8, FRAC>

where u8: PromoteAddSub<i64> + NumCast + Copy, i64: NumCast + Copy, <u8 as PromoteAddSub<i64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u8 as PromoteAddSub<i64>>::Output, FRAC>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const FRAC: usize> Add<i64> for FastFixed<u16, FRAC>

where u16: PromoteAddSub<i64> + NumCast + Copy, i64: NumCast + Copy, <u16 as PromoteAddSub<i64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u16 as PromoteAddSub<i64>>::Output, FRAC>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const FRAC: usize> Add<i64> for FastFixed<u32, FRAC>

where u32: PromoteAddSub<i64> + NumCast + Copy, i64: NumCast + Copy, <u32 as PromoteAddSub<i64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u32 as PromoteAddSub<i64>>::Output, FRAC>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const FRAC: usize> Add<i64> for FastFixed<u64, FRAC>

where u64: PromoteAddSub<i64> + NumCast + Copy, i64: NumCast + Copy, <u64 as PromoteAddSub<i64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u64 as PromoteAddSub<i64>>::Output, FRAC>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const FRAC: usize> Add<u8> for FastFixed<u8, FRAC>

where u8: PromoteAddSub<u8> + NumCast + Copy, <u8 as PromoteAddSub<u8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u8 as PromoteAddSub<u8>>::Output, FRAC>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const FRAC: usize> Add<u8> for FastFixed<u16, FRAC>

where u16: PromoteAddSub<u8> + NumCast + Copy, u8: NumCast + Copy, <u16 as PromoteAddSub<u8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u16 as PromoteAddSub<u8>>::Output, FRAC>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const FRAC: usize> Add<u8> for FastFixed<u32, FRAC>

where u32: PromoteAddSub<u8> + NumCast + Copy, u8: NumCast + Copy, <u32 as PromoteAddSub<u8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u32 as PromoteAddSub<u8>>::Output, FRAC>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const FRAC: usize> Add<u8> for FastFixed<u64, FRAC>

where u64: PromoteAddSub<u8> + NumCast + Copy, u8: NumCast + Copy, <u64 as PromoteAddSub<u8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u64 as PromoteAddSub<u8>>::Output, FRAC>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const FRAC: usize> Add<u8> for FastFixed<i8, FRAC>

where i8: PromoteAddSub<u8> + NumCast + Copy, u8: NumCast + Copy, <i8 as PromoteAddSub<u8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i8 as PromoteAddSub<u8>>::Output, FRAC>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const FRAC: usize> Add<u8> for FastFixed<i16, FRAC>

where i16: PromoteAddSub<u8> + NumCast + Copy, u8: NumCast + Copy, <i16 as PromoteAddSub<u8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i16 as PromoteAddSub<u8>>::Output, FRAC>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const FRAC: usize> Add<u8> for FastFixed<i32, FRAC>

where i32: PromoteAddSub<u8> + NumCast + Copy, u8: NumCast + Copy, <i32 as PromoteAddSub<u8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i32 as PromoteAddSub<u8>>::Output, FRAC>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const FRAC: usize> Add<u8> for FastFixed<i64, FRAC>

where i64: PromoteAddSub<u8> + NumCast + Copy, u8: NumCast + Copy, <i64 as PromoteAddSub<u8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i64 as PromoteAddSub<u8>>::Output, FRAC>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const FRAC: usize> Add<u16> for FastFixed<u8, FRAC>

where u8: PromoteAddSub<u16> + NumCast + Copy, u16: NumCast + Copy, <u8 as PromoteAddSub<u16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u8 as PromoteAddSub<u16>>::Output, FRAC>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const FRAC: usize> Add<u16> for FastFixed<u16, FRAC>

where u16: PromoteAddSub<u16> + NumCast + Copy, <u16 as PromoteAddSub<u16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u16 as PromoteAddSub<u16>>::Output, FRAC>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const FRAC: usize> Add<u16> for FastFixed<u32, FRAC>

where u32: PromoteAddSub<u16> + NumCast + Copy, u16: NumCast + Copy, <u32 as PromoteAddSub<u16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u32 as PromoteAddSub<u16>>::Output, FRAC>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const FRAC: usize> Add<u16> for FastFixed<u64, FRAC>

where u64: PromoteAddSub<u16> + NumCast + Copy, u16: NumCast + Copy, <u64 as PromoteAddSub<u16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u64 as PromoteAddSub<u16>>::Output, FRAC>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const FRAC: usize> Add<u16> for FastFixed<i8, FRAC>

where i8: PromoteAddSub<u16> + NumCast + Copy, u16: NumCast + Copy, <i8 as PromoteAddSub<u16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i8 as PromoteAddSub<u16>>::Output, FRAC>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const FRAC: usize> Add<u16> for FastFixed<i16, FRAC>

where i16: PromoteAddSub<u16> + NumCast + Copy, u16: NumCast + Copy, <i16 as PromoteAddSub<u16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i16 as PromoteAddSub<u16>>::Output, FRAC>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const FRAC: usize> Add<u16> for FastFixed<i32, FRAC>

where i32: PromoteAddSub<u16> + NumCast + Copy, u16: NumCast + Copy, <i32 as PromoteAddSub<u16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i32 as PromoteAddSub<u16>>::Output, FRAC>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const FRAC: usize> Add<u16> for FastFixed<i64, FRAC>

where i64: PromoteAddSub<u16> + NumCast + Copy, u16: NumCast + Copy, <i64 as PromoteAddSub<u16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i64 as PromoteAddSub<u16>>::Output, FRAC>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const FRAC: usize> Add<u32> for FastFixed<u8, FRAC>

where u8: PromoteAddSub<u32> + NumCast + Copy, u32: NumCast + Copy, <u8 as PromoteAddSub<u32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u8 as PromoteAddSub<u32>>::Output, FRAC>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const FRAC: usize> Add<u32> for FastFixed<u16, FRAC>

where u16: PromoteAddSub<u32> + NumCast + Copy, u32: NumCast + Copy, <u16 as PromoteAddSub<u32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u16 as PromoteAddSub<u32>>::Output, FRAC>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const FRAC: usize> Add<u32> for FastFixed<u32, FRAC>

where u32: PromoteAddSub<u32> + NumCast + Copy, <u32 as PromoteAddSub<u32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u32 as PromoteAddSub<u32>>::Output, FRAC>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const FRAC: usize> Add<u32> for FastFixed<u64, FRAC>

where u64: PromoteAddSub<u32> + NumCast + Copy, u32: NumCast + Copy, <u64 as PromoteAddSub<u32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u64 as PromoteAddSub<u32>>::Output, FRAC>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const FRAC: usize> Add<u32> for FastFixed<i8, FRAC>

where i8: PromoteAddSub<u32> + NumCast + Copy, u32: NumCast + Copy, <i8 as PromoteAddSub<u32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i8 as PromoteAddSub<u32>>::Output, FRAC>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const FRAC: usize> Add<u32> for FastFixed<i16, FRAC>

where i16: PromoteAddSub<u32> + NumCast + Copy, u32: NumCast + Copy, <i16 as PromoteAddSub<u32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i16 as PromoteAddSub<u32>>::Output, FRAC>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const FRAC: usize> Add<u32> for FastFixed<i32, FRAC>

where i32: PromoteAddSub<u32> + NumCast + Copy, u32: NumCast + Copy, <i32 as PromoteAddSub<u32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i32 as PromoteAddSub<u32>>::Output, FRAC>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const FRAC: usize> Add<u32> for FastFixed<i64, FRAC>

where i64: PromoteAddSub<u32> + NumCast + Copy, u32: NumCast + Copy, <i64 as PromoteAddSub<u32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i64 as PromoteAddSub<u32>>::Output, FRAC>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const FRAC: usize> Add<u64> for FastFixed<u8, FRAC>

where u8: PromoteAddSub<u64> + NumCast + Copy, u64: NumCast + Copy, <u8 as PromoteAddSub<u64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u8 as PromoteAddSub<u64>>::Output, FRAC>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const FRAC: usize> Add<u64> for FastFixed<u16, FRAC>

where u16: PromoteAddSub<u64> + NumCast + Copy, u64: NumCast + Copy, <u16 as PromoteAddSub<u64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u16 as PromoteAddSub<u64>>::Output, FRAC>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const FRAC: usize> Add<u64> for FastFixed<u32, FRAC>

where u32: PromoteAddSub<u64> + NumCast + Copy, u64: NumCast + Copy, <u32 as PromoteAddSub<u64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u32 as PromoteAddSub<u64>>::Output, FRAC>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const FRAC: usize> Add<u64> for FastFixed<u64, FRAC>

where u64: PromoteAddSub<u64> + NumCast + Copy, <u64 as PromoteAddSub<u64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u64 as PromoteAddSub<u64>>::Output, FRAC>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const FRAC: usize> Add<u64> for FastFixed<i8, FRAC>

where i8: PromoteAddSub<u64> + NumCast + Copy, u64: NumCast + Copy, <i8 as PromoteAddSub<u64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i8 as PromoteAddSub<u64>>::Output, FRAC>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const FRAC: usize> Add<u64> for FastFixed<i16, FRAC>

where i16: PromoteAddSub<u64> + NumCast + Copy, u64: NumCast + Copy, <i16 as PromoteAddSub<u64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i16 as PromoteAddSub<u64>>::Output, FRAC>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const FRAC: usize> Add<u64> for FastFixed<i32, FRAC>

where i32: PromoteAddSub<u64> + NumCast + Copy, u64: NumCast + Copy, <i32 as PromoteAddSub<u64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i32 as PromoteAddSub<u64>>::Output, FRAC>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const FRAC: usize> Add<u64> for FastFixed<i64, FRAC>

where i64: PromoteAddSub<u64> + NumCast + Copy, u64: NumCast + Copy, <i64 as PromoteAddSub<u64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i64 as PromoteAddSub<u64>>::Output, FRAC>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<I, const FRAC: usize, U, const FRAC_R: usize> AddAssign<FastFixed<U, FRAC_R>> for FastFixed<I, FRAC>

where I: PromoteAddSub<U> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt + TryFrom<<I as PromoteAddSub<U>>::Output>, <I as PromoteAddSub<U>>::Output: FastInt, U: Zero + PartialOrd + NumCast + Copy, FastFixed<I, FRAC>: Add<FastFixed<U, FRAC_R>, Output = FastFixed<<I as PromoteAddSub<U>>::Output, FRAC>>,

fn add_assign(&mut self, rhs: FastFixed<U, FRAC_R>)

Performs the += operation.

impl<const FRAC: usize> AddAssign<i8> for FastFixed<i8, FRAC>

where i8: PromoteAddSub<i8> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i8 as PromoteAddSub<i8>>::Output: FastInt, FastFixed<i8, FRAC>: Add<i8, Output = FastFixed<<i8 as PromoteAddSub<i8>>::Output, FRAC>>,

fn add_assign(&mut self, rhs: i8)

Performs the += operation.

impl<const FRAC: usize> AddAssign<i8> for FastFixed<i16, FRAC>

where i16: PromoteAddSub<i8> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i16 as PromoteAddSub<i8>>::Output: FastInt, i8: Zero + PartialOrd + NumCast + Copy, FastFixed<i16, FRAC>: Add<i8, Output = FastFixed<<i16 as PromoteAddSub<i8>>::Output, FRAC>>,

fn add_assign(&mut self, rhs: i8)

Performs the += operation.

impl<const FRAC: usize> AddAssign<i8> for FastFixed<i32, FRAC>

where i32: PromoteAddSub<i8> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i32 as PromoteAddSub<i8>>::Output: FastInt, i8: Zero + PartialOrd + NumCast + Copy, FastFixed<i32, FRAC>: Add<i8, Output = FastFixed<<i32 as PromoteAddSub<i8>>::Output, FRAC>>,

fn add_assign(&mut self, rhs: i8)

Performs the += operation.

impl<const FRAC: usize> AddAssign<i8> for FastFixed<i64, FRAC>

where i64: PromoteAddSub<i8> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i64 as PromoteAddSub<i8>>::Output: FastInt, i8: Zero + PartialOrd + NumCast + Copy, FastFixed<i64, FRAC>: Add<i8, Output = FastFixed<<i64 as PromoteAddSub<i8>>::Output, FRAC>>,

fn add_assign(&mut self, rhs: i8)

Performs the += operation.

impl<const FRAC: usize> AddAssign<i8> for FastFixed<u8, FRAC>

where u8: PromoteAddSub<i8> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u8 as PromoteAddSub<i8>>::Output: FastInt, i8: Zero + PartialOrd + NumCast + Copy, FastFixed<u8, FRAC>: Add<i8, Output = FastFixed<<u8 as PromoteAddSub<i8>>::Output, FRAC>>,

fn add_assign(&mut self, rhs: i8)

Performs the += operation.

impl<const FRAC: usize> AddAssign<i8> for FastFixed<u16, FRAC>

where u16: PromoteAddSub<i8> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u16 as PromoteAddSub<i8>>::Output: FastInt, i8: Zero + PartialOrd + NumCast + Copy, FastFixed<u16, FRAC>: Add<i8, Output = FastFixed<<u16 as PromoteAddSub<i8>>::Output, FRAC>>,

fn add_assign(&mut self, rhs: i8)

Performs the += operation.

impl<const FRAC: usize> AddAssign<i8> for FastFixed<u32, FRAC>

where u32: PromoteAddSub<i8> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u32 as PromoteAddSub<i8>>::Output: FastInt, i8: Zero + PartialOrd + NumCast + Copy, FastFixed<u32, FRAC>: Add<i8, Output = FastFixed<<u32 as PromoteAddSub<i8>>::Output, FRAC>>,

fn add_assign(&mut self, rhs: i8)

Performs the += operation.

impl<const FRAC: usize> AddAssign<i8> for FastFixed<u64, FRAC>

where u64: PromoteAddSub<i8> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u64 as PromoteAddSub<i8>>::Output: FastInt, i8: Zero + PartialOrd + NumCast + Copy, FastFixed<u64, FRAC>: Add<i8, Output = FastFixed<<u64 as PromoteAddSub<i8>>::Output, FRAC>>,

fn add_assign(&mut self, rhs: i8)

Performs the += operation.

impl<const FRAC: usize> AddAssign<i16> for FastFixed<i8, FRAC>

where i8: PromoteAddSub<i16> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i8 as PromoteAddSub<i16>>::Output: FastInt, i16: Zero + PartialOrd + NumCast + Copy, FastFixed<i8, FRAC>: Add<i16, Output = FastFixed<<i8 as PromoteAddSub<i16>>::Output, FRAC>>,

fn add_assign(&mut self, rhs: i16)

Performs the += operation.

impl<const FRAC: usize> AddAssign<i16> for FastFixed<i16, FRAC>

where i16: PromoteAddSub<i16> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i16 as PromoteAddSub<i16>>::Output: FastInt, FastFixed<i16, FRAC>: Add<i16, Output = FastFixed<<i16 as PromoteAddSub<i16>>::Output, FRAC>>,

fn add_assign(&mut self, rhs: i16)

Performs the += operation.

impl<const FRAC: usize> AddAssign<i16> for FastFixed<i32, FRAC>

where i32: PromoteAddSub<i16> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i32 as PromoteAddSub<i16>>::Output: FastInt, i16: Zero + PartialOrd + NumCast + Copy, FastFixed<i32, FRAC>: Add<i16, Output = FastFixed<<i32 as PromoteAddSub<i16>>::Output, FRAC>>,

fn add_assign(&mut self, rhs: i16)

Performs the += operation.

impl<const FRAC: usize> AddAssign<i16> for FastFixed<i64, FRAC>

where i64: PromoteAddSub<i16> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i64 as PromoteAddSub<i16>>::Output: FastInt, i16: Zero + PartialOrd + NumCast + Copy, FastFixed<i64, FRAC>: Add<i16, Output = FastFixed<<i64 as PromoteAddSub<i16>>::Output, FRAC>>,

fn add_assign(&mut self, rhs: i16)

Performs the += operation.

impl<const FRAC: usize> AddAssign<i16> for FastFixed<u8, FRAC>

where u8: PromoteAddSub<i16> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u8 as PromoteAddSub<i16>>::Output: FastInt, i16: Zero + PartialOrd + NumCast + Copy, FastFixed<u8, FRAC>: Add<i16, Output = FastFixed<<u8 as PromoteAddSub<i16>>::Output, FRAC>>,

fn add_assign(&mut self, rhs: i16)

Performs the += operation.

impl<const FRAC: usize> AddAssign<i16> for FastFixed<u16, FRAC>

where u16: PromoteAddSub<i16> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u16 as PromoteAddSub<i16>>::Output: FastInt, i16: Zero + PartialOrd + NumCast + Copy, FastFixed<u16, FRAC>: Add<i16, Output = FastFixed<<u16 as PromoteAddSub<i16>>::Output, FRAC>>,

fn add_assign(&mut self, rhs: i16)

Performs the += operation.

impl<const FRAC: usize> AddAssign<i16> for FastFixed<u32, FRAC>

where u32: PromoteAddSub<i16> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u32 as PromoteAddSub<i16>>::Output: FastInt, i16: Zero + PartialOrd + NumCast + Copy, FastFixed<u32, FRAC>: Add<i16, Output = FastFixed<<u32 as PromoteAddSub<i16>>::Output, FRAC>>,

fn add_assign(&mut self, rhs: i16)

Performs the += operation.

impl<const FRAC: usize> AddAssign<i16> for FastFixed<u64, FRAC>

where u64: PromoteAddSub<i16> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u64 as PromoteAddSub<i16>>::Output: FastInt, i16: Zero + PartialOrd + NumCast + Copy, FastFixed<u64, FRAC>: Add<i16, Output = FastFixed<<u64 as PromoteAddSub<i16>>::Output, FRAC>>,

fn add_assign(&mut self, rhs: i16)

Performs the += operation.

impl<const FRAC: usize> AddAssign<i32> for FastFixed<i8, FRAC>

where i8: PromoteAddSub<i32> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i8 as PromoteAddSub<i32>>::Output: FastInt, i32: Zero + PartialOrd + NumCast + Copy, FastFixed<i8, FRAC>: Add<i32, Output = FastFixed<<i8 as PromoteAddSub<i32>>::Output, FRAC>>,

fn add_assign(&mut self, rhs: i32)

Performs the += operation.

impl<const FRAC: usize> AddAssign<i32> for FastFixed<i16, FRAC>

where i16: PromoteAddSub<i32> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i16 as PromoteAddSub<i32>>::Output: FastInt, i32: Zero + PartialOrd + NumCast + Copy, FastFixed<i16, FRAC>: Add<i32, Output = FastFixed<<i16 as PromoteAddSub<i32>>::Output, FRAC>>,

fn add_assign(&mut self, rhs: i32)

Performs the += operation.

impl<const FRAC: usize> AddAssign<i32> for FastFixed<i32, FRAC>

where i32: PromoteAddSub<i32> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i32 as PromoteAddSub<i32>>::Output: FastInt, FastFixed<i32, FRAC>: Add<i32, Output = FastFixed<<i32 as PromoteAddSub<i32>>::Output, FRAC>>,

fn add_assign(&mut self, rhs: i32)

Performs the += operation.

impl<const FRAC: usize> AddAssign<i32> for FastFixed<i64, FRAC>

where i64: PromoteAddSub<i32> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i64 as PromoteAddSub<i32>>::Output: FastInt, i32: Zero + PartialOrd + NumCast + Copy, FastFixed<i64, FRAC>: Add<i32, Output = FastFixed<<i64 as PromoteAddSub<i32>>::Output, FRAC>>,

fn add_assign(&mut self, rhs: i32)

Performs the += operation.

impl<const FRAC: usize> AddAssign<i32> for FastFixed<u8, FRAC>

where u8: PromoteAddSub<i32> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u8 as PromoteAddSub<i32>>::Output: FastInt, i32: Zero + PartialOrd + NumCast + Copy, FastFixed<u8, FRAC>: Add<i32, Output = FastFixed<<u8 as PromoteAddSub<i32>>::Output, FRAC>>,

fn add_assign(&mut self, rhs: i32)

Performs the += operation.

impl<const FRAC: usize> AddAssign<i32> for FastFixed<u16, FRAC>

where u16: PromoteAddSub<i32> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u16 as PromoteAddSub<i32>>::Output: FastInt, i32: Zero + PartialOrd + NumCast + Copy, FastFixed<u16, FRAC>: Add<i32, Output = FastFixed<<u16 as PromoteAddSub<i32>>::Output, FRAC>>,

fn add_assign(&mut self, rhs: i32)

Performs the += operation.

impl<const FRAC: usize> AddAssign<i32> for FastFixed<u32, FRAC>

where u32: PromoteAddSub<i32> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u32 as PromoteAddSub<i32>>::Output: FastInt, i32: Zero + PartialOrd + NumCast + Copy, FastFixed<u32, FRAC>: Add<i32, Output = FastFixed<<u32 as PromoteAddSub<i32>>::Output, FRAC>>,

fn add_assign(&mut self, rhs: i32)

Performs the += operation.

impl<const FRAC: usize> AddAssign<i32> for FastFixed<u64, FRAC>

where u64: PromoteAddSub<i32> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u64 as PromoteAddSub<i32>>::Output: FastInt, i32: Zero + PartialOrd + NumCast + Copy, FastFixed<u64, FRAC>: Add<i32, Output = FastFixed<<u64 as PromoteAddSub<i32>>::Output, FRAC>>,

fn add_assign(&mut self, rhs: i32)

Performs the += operation.

impl<const FRAC: usize> AddAssign<i64> for FastFixed<i8, FRAC>

where i8: PromoteAddSub<i64> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i8 as PromoteAddSub<i64>>::Output: FastInt, i64: Zero + PartialOrd + NumCast + Copy, FastFixed<i8, FRAC>: Add<i64, Output = FastFixed<<i8 as PromoteAddSub<i64>>::Output, FRAC>>,

fn add_assign(&mut self, rhs: i64)

Performs the += operation.

impl<const FRAC: usize> AddAssign<i64> for FastFixed<i16, FRAC>

where i16: PromoteAddSub<i64> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i16 as PromoteAddSub<i64>>::Output: FastInt, i64: Zero + PartialOrd + NumCast + Copy, FastFixed<i16, FRAC>: Add<i64, Output = FastFixed<<i16 as PromoteAddSub<i64>>::Output, FRAC>>,

fn add_assign(&mut self, rhs: i64)

Performs the += operation.

impl<const FRAC: usize> AddAssign<i64> for FastFixed<i32, FRAC>

where i32: PromoteAddSub<i64> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i32 as PromoteAddSub<i64>>::Output: FastInt, i64: Zero + PartialOrd + NumCast + Copy, FastFixed<i32, FRAC>: Add<i64, Output = FastFixed<<i32 as PromoteAddSub<i64>>::Output, FRAC>>,

fn add_assign(&mut self, rhs: i64)

Performs the += operation.

impl<const FRAC: usize> AddAssign<i64> for FastFixed<i64, FRAC>

where i64: PromoteAddSub<i64> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i64 as PromoteAddSub<i64>>::Output: FastInt, FastFixed<i64, FRAC>: Add<i64, Output = FastFixed<<i64 as PromoteAddSub<i64>>::Output, FRAC>>,

fn add_assign(&mut self, rhs: i64)

Performs the += operation.

impl<const FRAC: usize> AddAssign<i64> for FastFixed<u8, FRAC>

where u8: PromoteAddSub<i64> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u8 as PromoteAddSub<i64>>::Output: FastInt, i64: Zero + PartialOrd + NumCast + Copy, FastFixed<u8, FRAC>: Add<i64, Output = FastFixed<<u8 as PromoteAddSub<i64>>::Output, FRAC>>,

fn add_assign(&mut self, rhs: i64)

Performs the += operation.

impl<const FRAC: usize> AddAssign<i64> for FastFixed<u16, FRAC>

where u16: PromoteAddSub<i64> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u16 as PromoteAddSub<i64>>::Output: FastInt, i64: Zero + PartialOrd + NumCast + Copy, FastFixed<u16, FRAC>: Add<i64, Output = FastFixed<<u16 as PromoteAddSub<i64>>::Output, FRAC>>,

fn add_assign(&mut self, rhs: i64)

Performs the += operation.

impl<const FRAC: usize> AddAssign<i64> for FastFixed<u32, FRAC>

where u32: PromoteAddSub<i64> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u32 as PromoteAddSub<i64>>::Output: FastInt, i64: Zero + PartialOrd + NumCast + Copy, FastFixed<u32, FRAC>: Add<i64, Output = FastFixed<<u32 as PromoteAddSub<i64>>::Output, FRAC>>,

fn add_assign(&mut self, rhs: i64)

Performs the += operation.

impl<const FRAC: usize> AddAssign<i64> for FastFixed<u64, FRAC>

where u64: PromoteAddSub<i64> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u64 as PromoteAddSub<i64>>::Output: FastInt, i64: Zero + PartialOrd + NumCast + Copy, FastFixed<u64, FRAC>: Add<i64, Output = FastFixed<<u64 as PromoteAddSub<i64>>::Output, FRAC>>,

fn add_assign(&mut self, rhs: i64)

Performs the += operation.

impl<const FRAC: usize> AddAssign<u8> for FastFixed<u8, FRAC>

where u8: PromoteAddSub<u8> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u8 as PromoteAddSub<u8>>::Output: FastInt, FastFixed<u8, FRAC>: Add<u8, Output = FastFixed<<u8 as PromoteAddSub<u8>>::Output, FRAC>>,

fn add_assign(&mut self, rhs: u8)

Performs the += operation.

impl<const FRAC: usize> AddAssign<u8> for FastFixed<u16, FRAC>

where u16: PromoteAddSub<u8> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u16 as PromoteAddSub<u8>>::Output: FastInt, u8: Zero + PartialOrd + NumCast + Copy, FastFixed<u16, FRAC>: Add<u8, Output = FastFixed<<u16 as PromoteAddSub<u8>>::Output, FRAC>>,

fn add_assign(&mut self, rhs: u8)

Performs the += operation.

impl<const FRAC: usize> AddAssign<u8> for FastFixed<u32, FRAC>

where u32: PromoteAddSub<u8> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u32 as PromoteAddSub<u8>>::Output: FastInt, u8: Zero + PartialOrd + NumCast + Copy, FastFixed<u32, FRAC>: Add<u8, Output = FastFixed<<u32 as PromoteAddSub<u8>>::Output, FRAC>>,

fn add_assign(&mut self, rhs: u8)

Performs the += operation.

impl<const FRAC: usize> AddAssign<u8> for FastFixed<u64, FRAC>

where u64: PromoteAddSub<u8> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u64 as PromoteAddSub<u8>>::Output: FastInt, u8: Zero + PartialOrd + NumCast + Copy, FastFixed<u64, FRAC>: Add<u8, Output = FastFixed<<u64 as PromoteAddSub<u8>>::Output, FRAC>>,

fn add_assign(&mut self, rhs: u8)

Performs the += operation.

impl<const FRAC: usize> AddAssign<u8> for FastFixed<i8, FRAC>

where i8: PromoteAddSub<u8> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i8 as PromoteAddSub<u8>>::Output: FastInt, u8: Zero + PartialOrd + NumCast + Copy, FastFixed<i8, FRAC>: Add<u8, Output = FastFixed<<i8 as PromoteAddSub<u8>>::Output, FRAC>>,

fn add_assign(&mut self, rhs: u8)

Performs the += operation.

impl<const FRAC: usize> AddAssign<u8> for FastFixed<i16, FRAC>

where i16: PromoteAddSub<u8> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i16 as PromoteAddSub<u8>>::Output: FastInt, u8: Zero + PartialOrd + NumCast + Copy, FastFixed<i16, FRAC>: Add<u8, Output = FastFixed<<i16 as PromoteAddSub<u8>>::Output, FRAC>>,

fn add_assign(&mut self, rhs: u8)

Performs the += operation.

impl<const FRAC: usize> AddAssign<u8> for FastFixed<i32, FRAC>

where i32: PromoteAddSub<u8> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i32 as PromoteAddSub<u8>>::Output: FastInt, u8: Zero + PartialOrd + NumCast + Copy, FastFixed<i32, FRAC>: Add<u8, Output = FastFixed<<i32 as PromoteAddSub<u8>>::Output, FRAC>>,

fn add_assign(&mut self, rhs: u8)

Performs the += operation.

impl<const FRAC: usize> AddAssign<u8> for FastFixed<i64, FRAC>

where i64: PromoteAddSub<u8> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i64 as PromoteAddSub<u8>>::Output: FastInt, u8: Zero + PartialOrd + NumCast + Copy, FastFixed<i64, FRAC>: Add<u8, Output = FastFixed<<i64 as PromoteAddSub<u8>>::Output, FRAC>>,

fn add_assign(&mut self, rhs: u8)

Performs the += operation.

impl<const FRAC: usize> AddAssign<u16> for FastFixed<u8, FRAC>

where u8: PromoteAddSub<u16> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u8 as PromoteAddSub<u16>>::Output: FastInt, u16: Zero + PartialOrd + NumCast + Copy, FastFixed<u8, FRAC>: Add<u16, Output = FastFixed<<u8 as PromoteAddSub<u16>>::Output, FRAC>>,

fn add_assign(&mut self, rhs: u16)

Performs the += operation.

impl<const FRAC: usize> AddAssign<u16> for FastFixed<u16, FRAC>

where u16: PromoteAddSub<u16> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u16 as PromoteAddSub<u16>>::Output: FastInt, FastFixed<u16, FRAC>: Add<u16, Output = FastFixed<<u16 as PromoteAddSub<u16>>::Output, FRAC>>,

fn add_assign(&mut self, rhs: u16)

Performs the += operation.

impl<const FRAC: usize> AddAssign<u16> for FastFixed<u32, FRAC>

where u32: PromoteAddSub<u16> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u32 as PromoteAddSub<u16>>::Output: FastInt, u16: Zero + PartialOrd + NumCast + Copy, FastFixed<u32, FRAC>: Add<u16, Output = FastFixed<<u32 as PromoteAddSub<u16>>::Output, FRAC>>,

fn add_assign(&mut self, rhs: u16)

Performs the += operation.

impl<const FRAC: usize> AddAssign<u16> for FastFixed<u64, FRAC>

where u64: PromoteAddSub<u16> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u64 as PromoteAddSub<u16>>::Output: FastInt, u16: Zero + PartialOrd + NumCast + Copy, FastFixed<u64, FRAC>: Add<u16, Output = FastFixed<<u64 as PromoteAddSub<u16>>::Output, FRAC>>,

fn add_assign(&mut self, rhs: u16)

Performs the += operation.

impl<const FRAC: usize> AddAssign<u16> for FastFixed<i8, FRAC>

where i8: PromoteAddSub<u16> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i8 as PromoteAddSub<u16>>::Output: FastInt, u16: Zero + PartialOrd + NumCast + Copy, FastFixed<i8, FRAC>: Add<u16, Output = FastFixed<<i8 as PromoteAddSub<u16>>::Output, FRAC>>,

fn add_assign(&mut self, rhs: u16)

Performs the += operation.

impl<const FRAC: usize> AddAssign<u16> for FastFixed<i16, FRAC>

where i16: PromoteAddSub<u16> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i16 as PromoteAddSub<u16>>::Output: FastInt, u16: Zero + PartialOrd + NumCast + Copy, FastFixed<i16, FRAC>: Add<u16, Output = FastFixed<<i16 as PromoteAddSub<u16>>::Output, FRAC>>,

fn add_assign(&mut self, rhs: u16)

Performs the += operation.

impl<const FRAC: usize> AddAssign<u16> for FastFixed<i32, FRAC>

where i32: PromoteAddSub<u16> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i32 as PromoteAddSub<u16>>::Output: FastInt, u16: Zero + PartialOrd + NumCast + Copy, FastFixed<i32, FRAC>: Add<u16, Output = FastFixed<<i32 as PromoteAddSub<u16>>::Output, FRAC>>,

fn add_assign(&mut self, rhs: u16)

Performs the += operation.

impl<const FRAC: usize> AddAssign<u16> for FastFixed<i64, FRAC>

where i64: PromoteAddSub<u16> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i64 as PromoteAddSub<u16>>::Output: FastInt, u16: Zero + PartialOrd + NumCast + Copy, FastFixed<i64, FRAC>: Add<u16, Output = FastFixed<<i64 as PromoteAddSub<u16>>::Output, FRAC>>,

fn add_assign(&mut self, rhs: u16)

Performs the += operation.

impl<const FRAC: usize> AddAssign<u32> for FastFixed<u8, FRAC>

where u8: PromoteAddSub<u32> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u8 as PromoteAddSub<u32>>::Output: FastInt, u32: Zero + PartialOrd + NumCast + Copy, FastFixed<u8, FRAC>: Add<u32, Output = FastFixed<<u8 as PromoteAddSub<u32>>::Output, FRAC>>,

fn add_assign(&mut self, rhs: u32)

Performs the += operation.

impl<const FRAC: usize> AddAssign<u32> for FastFixed<u16, FRAC>

where u16: PromoteAddSub<u32> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u16 as PromoteAddSub<u32>>::Output: FastInt, u32: Zero + PartialOrd + NumCast + Copy, FastFixed<u16, FRAC>: Add<u32, Output = FastFixed<<u16 as PromoteAddSub<u32>>::Output, FRAC>>,

fn add_assign(&mut self, rhs: u32)

Performs the += operation.

impl<const FRAC: usize> AddAssign<u32> for FastFixed<u32, FRAC>

where u32: PromoteAddSub<u32> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u32 as PromoteAddSub<u32>>::Output: FastInt, FastFixed<u32, FRAC>: Add<u32, Output = FastFixed<<u32 as PromoteAddSub<u32>>::Output, FRAC>>,

fn add_assign(&mut self, rhs: u32)

Performs the += operation.

impl<const FRAC: usize> AddAssign<u32> for FastFixed<u64, FRAC>

where u64: PromoteAddSub<u32> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u64 as PromoteAddSub<u32>>::Output: FastInt, u32: Zero + PartialOrd + NumCast + Copy, FastFixed<u64, FRAC>: Add<u32, Output = FastFixed<<u64 as PromoteAddSub<u32>>::Output, FRAC>>,

fn add_assign(&mut self, rhs: u32)

Performs the += operation.

impl<const FRAC: usize> AddAssign<u32> for FastFixed<i8, FRAC>

where i8: PromoteAddSub<u32> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i8 as PromoteAddSub<u32>>::Output: FastInt, u32: Zero + PartialOrd + NumCast + Copy, FastFixed<i8, FRAC>: Add<u32, Output = FastFixed<<i8 as PromoteAddSub<u32>>::Output, FRAC>>,

fn add_assign(&mut self, rhs: u32)

Performs the += operation.

impl<const FRAC: usize> AddAssign<u32> for FastFixed<i16, FRAC>

where i16: PromoteAddSub<u32> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i16 as PromoteAddSub<u32>>::Output: FastInt, u32: Zero + PartialOrd + NumCast + Copy, FastFixed<i16, FRAC>: Add<u32, Output = FastFixed<<i16 as PromoteAddSub<u32>>::Output, FRAC>>,

fn add_assign(&mut self, rhs: u32)

Performs the += operation.

impl<const FRAC: usize> AddAssign<u32> for FastFixed<i32, FRAC>

where i32: PromoteAddSub<u32> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i32 as PromoteAddSub<u32>>::Output: FastInt, u32: Zero + PartialOrd + NumCast + Copy, FastFixed<i32, FRAC>: Add<u32, Output = FastFixed<<i32 as PromoteAddSub<u32>>::Output, FRAC>>,

fn add_assign(&mut self, rhs: u32)

Performs the += operation.

impl<const FRAC: usize> AddAssign<u32> for FastFixed<i64, FRAC>

where i64: PromoteAddSub<u32> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i64 as PromoteAddSub<u32>>::Output: FastInt, u32: Zero + PartialOrd + NumCast + Copy, FastFixed<i64, FRAC>: Add<u32, Output = FastFixed<<i64 as PromoteAddSub<u32>>::Output, FRAC>>,

fn add_assign(&mut self, rhs: u32)

Performs the += operation.

impl<const FRAC: usize> AddAssign<u64> for FastFixed<u8, FRAC>

where u8: PromoteAddSub<u64> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u8 as PromoteAddSub<u64>>::Output: FastInt, u64: Zero + PartialOrd + NumCast + Copy, FastFixed<u8, FRAC>: Add<u64, Output = FastFixed<<u8 as PromoteAddSub<u64>>::Output, FRAC>>,

fn add_assign(&mut self, rhs: u64)

Performs the += operation.

impl<const FRAC: usize> AddAssign<u64> for FastFixed<u16, FRAC>

where u16: PromoteAddSub<u64> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u16 as PromoteAddSub<u64>>::Output: FastInt, u64: Zero + PartialOrd + NumCast + Copy, FastFixed<u16, FRAC>: Add<u64, Output = FastFixed<<u16 as PromoteAddSub<u64>>::Output, FRAC>>,

fn add_assign(&mut self, rhs: u64)

Performs the += operation.

impl<const FRAC: usize> AddAssign<u64> for FastFixed<u32, FRAC>

where u32: PromoteAddSub<u64> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u32 as PromoteAddSub<u64>>::Output: FastInt, u64: Zero + PartialOrd + NumCast + Copy, FastFixed<u32, FRAC>: Add<u64, Output = FastFixed<<u32 as PromoteAddSub<u64>>::Output, FRAC>>,

fn add_assign(&mut self, rhs: u64)

Performs the += operation.

impl<const FRAC: usize> AddAssign<u64> for FastFixed<u64, FRAC>

where u64: PromoteAddSub<u64> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u64 as PromoteAddSub<u64>>::Output: FastInt, FastFixed<u64, FRAC>: Add<u64, Output = FastFixed<<u64 as PromoteAddSub<u64>>::Output, FRAC>>,

fn add_assign(&mut self, rhs: u64)

Performs the += operation.

impl<const FRAC: usize> AddAssign<u64> for FastFixed<i8, FRAC>

where i8: PromoteAddSub<u64> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i8 as PromoteAddSub<u64>>::Output: FastInt, u64: Zero + PartialOrd + NumCast + Copy, FastFixed<i8, FRAC>: Add<u64, Output = FastFixed<<i8 as PromoteAddSub<u64>>::Output, FRAC>>,

fn add_assign(&mut self, rhs: u64)

Performs the += operation.

impl<const FRAC: usize> AddAssign<u64> for FastFixed<i16, FRAC>

where i16: PromoteAddSub<u64> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i16 as PromoteAddSub<u64>>::Output: FastInt, u64: Zero + PartialOrd + NumCast + Copy, FastFixed<i16, FRAC>: Add<u64, Output = FastFixed<<i16 as PromoteAddSub<u64>>::Output, FRAC>>,

fn add_assign(&mut self, rhs: u64)

Performs the += operation.

impl<const FRAC: usize> AddAssign<u64> for FastFixed<i32, FRAC>

where i32: PromoteAddSub<u64> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i32 as PromoteAddSub<u64>>::Output: FastInt, u64: Zero + PartialOrd + NumCast + Copy, FastFixed<i32, FRAC>: Add<u64, Output = FastFixed<<i32 as PromoteAddSub<u64>>::Output, FRAC>>,

fn add_assign(&mut self, rhs: u64)

Performs the += operation.

impl<const FRAC: usize> AddAssign<u64> for FastFixed<i64, FRAC>

where i64: PromoteAddSub<u64> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i64 as PromoteAddSub<u64>>::Output: FastInt, u64: Zero + PartialOrd + NumCast + Copy, FastFixed<i64, FRAC>: Add<u64, Output = FastFixed<<i64 as PromoteAddSub<u64>>::Output, FRAC>>,

fn add_assign(&mut self, rhs: u64)

Performs the += operation.

impl<I: Clone, const FRAC: usize> Clone for FastFixed<I, FRAC>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<I: Copy, const FRAC: usize> Copy for FastFixed<I, FRAC>

impl<I, const FRAC: usize> Debug for FastFixed<I, FRAC>

where I: Into<i128> + Copy + Debug,

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

Formats the value using the given formatter.

impl<I: Default, const FRAC: usize> Default for FastFixed<I, FRAC>

fn default() -> Self

Returns the “default value” for a type.

impl<I, const FRAC: usize> Display for FastFixed<I, FRAC>

where I: Into<i128> + Copy,

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

Formats the value using the given formatter.

impl<IL, const FL: usize, IR, const FR: usize> Div<FastFixed<IR, FR>> for FastFixed<IL, FL>

type Output = DivExpression<FastFixed<IL, FL>, FastFixed<IR, FR>>

The resulting type after applying the / operator.

fn div(self, rhs: FastFixed<IR, FR>) -> Self::Output

Performs the / operation.

impl<const FRAC: usize> Div<i8> for FastFixed<i8, FRAC>

type Output = DivExpression<FastFixed<i8, FRAC>, FastFixed<i8, 0>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const FRAC: usize> Div<i8> for FastFixed<i16, FRAC>

type Output = DivExpression<FastFixed<i16, FRAC>, FastFixed<i8, 0>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const FRAC: usize> Div<i8> for FastFixed<i32, FRAC>

type Output = DivExpression<FastFixed<i32, FRAC>, FastFixed<i8, 0>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const FRAC: usize> Div<i8> for FastFixed<i64, FRAC>

type Output = DivExpression<FastFixed<i64, FRAC>, FastFixed<i8, 0>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const FRAC: usize> Div<i8> for FastFixed<u8, FRAC>

type Output = DivExpression<FastFixed<u8, FRAC>, FastFixed<i8, 0>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const FRAC: usize> Div<i8> for FastFixed<u16, FRAC>

type Output = DivExpression<FastFixed<u16, FRAC>, FastFixed<i8, 0>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const FRAC: usize> Div<i8> for FastFixed<u32, FRAC>

type Output = DivExpression<FastFixed<u32, FRAC>, FastFixed<i8, 0>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const FRAC: usize> Div<i8> for FastFixed<u64, FRAC>

type Output = DivExpression<FastFixed<u64, FRAC>, FastFixed<i8, 0>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const FRAC: usize> Div<i16> for FastFixed<i8, FRAC>

type Output = DivExpression<FastFixed<i8, FRAC>, FastFixed<i16, 0>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const FRAC: usize> Div<i16> for FastFixed<i16, FRAC>

type Output = DivExpression<FastFixed<i16, FRAC>, FastFixed<i16, 0>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const FRAC: usize> Div<i16> for FastFixed<i32, FRAC>

type Output = DivExpression<FastFixed<i32, FRAC>, FastFixed<i16, 0>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const FRAC: usize> Div<i16> for FastFixed<i64, FRAC>

type Output = DivExpression<FastFixed<i64, FRAC>, FastFixed<i16, 0>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const FRAC: usize> Div<i16> for FastFixed<u8, FRAC>

type Output = DivExpression<FastFixed<u8, FRAC>, FastFixed<i16, 0>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const FRAC: usize> Div<i16> for FastFixed<u16, FRAC>

type Output = DivExpression<FastFixed<u16, FRAC>, FastFixed<i16, 0>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const FRAC: usize> Div<i16> for FastFixed<u32, FRAC>

type Output = DivExpression<FastFixed<u32, FRAC>, FastFixed<i16, 0>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const FRAC: usize> Div<i16> for FastFixed<u64, FRAC>

type Output = DivExpression<FastFixed<u64, FRAC>, FastFixed<i16, 0>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const FRAC: usize> Div<i32> for FastFixed<i8, FRAC>

type Output = DivExpression<FastFixed<i8, FRAC>, FastFixed<i32, 0>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const FRAC: usize> Div<i32> for FastFixed<i16, FRAC>

type Output = DivExpression<FastFixed<i16, FRAC>, FastFixed<i32, 0>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const FRAC: usize> Div<i32> for FastFixed<i32, FRAC>

type Output = DivExpression<FastFixed<i32, FRAC>, FastFixed<i32, 0>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const FRAC: usize> Div<i32> for FastFixed<i64, FRAC>

type Output = DivExpression<FastFixed<i64, FRAC>, FastFixed<i32, 0>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const FRAC: usize> Div<i32> for FastFixed<u8, FRAC>

type Output = DivExpression<FastFixed<u8, FRAC>, FastFixed<i32, 0>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const FRAC: usize> Div<i32> for FastFixed<u16, FRAC>

type Output = DivExpression<FastFixed<u16, FRAC>, FastFixed<i32, 0>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const FRAC: usize> Div<i32> for FastFixed<u32, FRAC>

type Output = DivExpression<FastFixed<u32, FRAC>, FastFixed<i32, 0>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const FRAC: usize> Div<i32> for FastFixed<u64, FRAC>

type Output = DivExpression<FastFixed<u64, FRAC>, FastFixed<i32, 0>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const FRAC: usize> Div<i64> for FastFixed<i8, FRAC>

type Output = DivExpression<FastFixed<i8, FRAC>, FastFixed<i64, 0>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const FRAC: usize> Div<i64> for FastFixed<i16, FRAC>

type Output = DivExpression<FastFixed<i16, FRAC>, FastFixed<i64, 0>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const FRAC: usize> Div<i64> for FastFixed<i32, FRAC>

type Output = DivExpression<FastFixed<i32, FRAC>, FastFixed<i64, 0>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const FRAC: usize> Div<i64> for FastFixed<i64, FRAC>

type Output = DivExpression<FastFixed<i64, FRAC>, FastFixed<i64, 0>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const FRAC: usize> Div<i64> for FastFixed<u8, FRAC>

type Output = DivExpression<FastFixed<u8, FRAC>, FastFixed<i64, 0>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const FRAC: usize> Div<i64> for FastFixed<u16, FRAC>

type Output = DivExpression<FastFixed<u16, FRAC>, FastFixed<i64, 0>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const FRAC: usize> Div<i64> for FastFixed<u32, FRAC>

type Output = DivExpression<FastFixed<u32, FRAC>, FastFixed<i64, 0>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const FRAC: usize> Div<i64> for FastFixed<u64, FRAC>

type Output = DivExpression<FastFixed<u64, FRAC>, FastFixed<i64, 0>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const FRAC: usize> Div<u8> for FastFixed<u8, FRAC>

type Output = DivExpression<FastFixed<u8, FRAC>, FastFixed<u8, 0>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const FRAC: usize> Div<u8> for FastFixed<u16, FRAC>

type Output = DivExpression<FastFixed<u16, FRAC>, FastFixed<u8, 0>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const FRAC: usize> Div<u8> for FastFixed<u32, FRAC>

type Output = DivExpression<FastFixed<u32, FRAC>, FastFixed<u8, 0>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const FRAC: usize> Div<u8> for FastFixed<u64, FRAC>

type Output = DivExpression<FastFixed<u64, FRAC>, FastFixed<u8, 0>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const FRAC: usize> Div<u8> for FastFixed<i8, FRAC>

type Output = DivExpression<FastFixed<i8, FRAC>, FastFixed<u8, 0>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const FRAC: usize> Div<u8> for FastFixed<i16, FRAC>

type Output = DivExpression<FastFixed<i16, FRAC>, FastFixed<u8, 0>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const FRAC: usize> Div<u8> for FastFixed<i32, FRAC>

type Output = DivExpression<FastFixed<i32, FRAC>, FastFixed<u8, 0>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const FRAC: usize> Div<u8> for FastFixed<i64, FRAC>

type Output = DivExpression<FastFixed<i64, FRAC>, FastFixed<u8, 0>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const FRAC: usize> Div<u16> for FastFixed<u8, FRAC>

type Output = DivExpression<FastFixed<u8, FRAC>, FastFixed<u16, 0>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const FRAC: usize> Div<u16> for FastFixed<u16, FRAC>

type Output = DivExpression<FastFixed<u16, FRAC>, FastFixed<u16, 0>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const FRAC: usize> Div<u16> for FastFixed<u32, FRAC>

type Output = DivExpression<FastFixed<u32, FRAC>, FastFixed<u16, 0>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const FRAC: usize> Div<u16> for FastFixed<u64, FRAC>

type Output = DivExpression<FastFixed<u64, FRAC>, FastFixed<u16, 0>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const FRAC: usize> Div<u16> for FastFixed<i8, FRAC>

type Output = DivExpression<FastFixed<i8, FRAC>, FastFixed<u16, 0>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const FRAC: usize> Div<u16> for FastFixed<i16, FRAC>

type Output = DivExpression<FastFixed<i16, FRAC>, FastFixed<u16, 0>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const FRAC: usize> Div<u16> for FastFixed<i32, FRAC>

type Output = DivExpression<FastFixed<i32, FRAC>, FastFixed<u16, 0>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const FRAC: usize> Div<u16> for FastFixed<i64, FRAC>

type Output = DivExpression<FastFixed<i64, FRAC>, FastFixed<u16, 0>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const FRAC: usize> Div<u32> for FastFixed<u8, FRAC>

type Output = DivExpression<FastFixed<u8, FRAC>, FastFixed<u32, 0>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const FRAC: usize> Div<u32> for FastFixed<u16, FRAC>

type Output = DivExpression<FastFixed<u16, FRAC>, FastFixed<u32, 0>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const FRAC: usize> Div<u32> for FastFixed<u32, FRAC>

type Output = DivExpression<FastFixed<u32, FRAC>, FastFixed<u32, 0>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const FRAC: usize> Div<u32> for FastFixed<u64, FRAC>

type Output = DivExpression<FastFixed<u64, FRAC>, FastFixed<u32, 0>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const FRAC: usize> Div<u32> for FastFixed<i8, FRAC>

type Output = DivExpression<FastFixed<i8, FRAC>, FastFixed<u32, 0>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const FRAC: usize> Div<u32> for FastFixed<i16, FRAC>

type Output = DivExpression<FastFixed<i16, FRAC>, FastFixed<u32, 0>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const FRAC: usize> Div<u32> for FastFixed<i32, FRAC>

type Output = DivExpression<FastFixed<i32, FRAC>, FastFixed<u32, 0>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const FRAC: usize> Div<u32> for FastFixed<i64, FRAC>

type Output = DivExpression<FastFixed<i64, FRAC>, FastFixed<u32, 0>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const FRAC: usize> Div<u64> for FastFixed<u8, FRAC>

type Output = DivExpression<FastFixed<u8, FRAC>, FastFixed<u64, 0>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const FRAC: usize> Div<u64> for FastFixed<u16, FRAC>

type Output = DivExpression<FastFixed<u16, FRAC>, FastFixed<u64, 0>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const FRAC: usize> Div<u64> for FastFixed<u32, FRAC>

type Output = DivExpression<FastFixed<u32, FRAC>, FastFixed<u64, 0>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const FRAC: usize> Div<u64> for FastFixed<u64, FRAC>

type Output = DivExpression<FastFixed<u64, FRAC>, FastFixed<u64, 0>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const FRAC: usize> Div<u64> for FastFixed<i8, FRAC>

type Output = DivExpression<FastFixed<i8, FRAC>, FastFixed<u64, 0>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const FRAC: usize> Div<u64> for FastFixed<i16, FRAC>

type Output = DivExpression<FastFixed<i16, FRAC>, FastFixed<u64, 0>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const FRAC: usize> Div<u64> for FastFixed<i32, FRAC>

type Output = DivExpression<FastFixed<i32, FRAC>, FastFixed<u64, 0>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const FRAC: usize> Div<u64> for FastFixed<i64, FRAC>

type Output = DivExpression<FastFixed<i64, FRAC>, FastFixed<u64, 0>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<I, const FRAC: usize> DivAssign for FastFixed<I, FRAC>

where Self: Copy, I: Zero + PartialOrd, FastFixed<I, FRAC>: From<DivExpression<Self, Self>>,

fn div_assign(&mut self, rhs: Self)

Performs the /= operation.

impl<const FRAC: usize> DivAssign<i8> for FastFixed<i8, FRAC>

where Self: Copy, FastFixed<i8, FRAC>: From<DivExpression<FastFixed<i8, FRAC>, FastFixed<i8, 0>>>,

fn div_assign(&mut self, rhs: i8)

Performs the /= operation.

impl<const FRAC: usize> DivAssign<i8> for FastFixed<i16, FRAC>

where Self: Copy, FastFixed<i16, FRAC>: From<DivExpression<FastFixed<i16, FRAC>, FastFixed<i8, 0>>>,

fn div_assign(&mut self, rhs: i8)

Performs the /= operation.

impl<const FRAC: usize> DivAssign<i8> for FastFixed<i32, FRAC>

where Self: Copy, FastFixed<i32, FRAC>: From<DivExpression<FastFixed<i32, FRAC>, FastFixed<i8, 0>>>,

fn div_assign(&mut self, rhs: i8)

Performs the /= operation.

impl<const FRAC: usize> DivAssign<i8> for FastFixed<i64, FRAC>

where Self: Copy, FastFixed<i64, FRAC>: From<DivExpression<FastFixed<i64, FRAC>, FastFixed<i8, 0>>>,

fn div_assign(&mut self, rhs: i8)

Performs the /= operation.

impl<const FRAC: usize> DivAssign<i8> for FastFixed<u8, FRAC>

where Self: Copy, FastFixed<u8, FRAC>: From<DivExpression<FastFixed<u8, FRAC>, FastFixed<i8, 0>>>,

fn div_assign(&mut self, rhs: i8)

Performs the /= operation.

impl<const FRAC: usize> DivAssign<i8> for FastFixed<u16, FRAC>

where Self: Copy, FastFixed<u16, FRAC>: From<DivExpression<FastFixed<u16, FRAC>, FastFixed<i8, 0>>>,

fn div_assign(&mut self, rhs: i8)

Performs the /= operation.

impl<const FRAC: usize> DivAssign<i8> for FastFixed<u32, FRAC>

where Self: Copy, FastFixed<u32, FRAC>: From<DivExpression<FastFixed<u32, FRAC>, FastFixed<i8, 0>>>,

fn div_assign(&mut self, rhs: i8)

Performs the /= operation.

impl<const FRAC: usize> DivAssign<i8> for FastFixed<u64, FRAC>

where Self: Copy, FastFixed<u64, FRAC>: From<DivExpression<FastFixed<u64, FRAC>, FastFixed<i8, 0>>>,

fn div_assign(&mut self, rhs: i8)

Performs the /= operation.

impl<const FRAC: usize> DivAssign<i16> for FastFixed<i8, FRAC>

where Self: Copy, FastFixed<i8, FRAC>: From<DivExpression<FastFixed<i8, FRAC>, FastFixed<i16, 0>>>,

fn div_assign(&mut self, rhs: i16)

Performs the /= operation.

impl<const FRAC: usize> DivAssign<i16> for FastFixed<i16, FRAC>

where Self: Copy, FastFixed<i16, FRAC>: From<DivExpression<FastFixed<i16, FRAC>, FastFixed<i16, 0>>>,

fn div_assign(&mut self, rhs: i16)

Performs the /= operation.

impl<const FRAC: usize> DivAssign<i16> for FastFixed<i32, FRAC>

where Self: Copy, FastFixed<i32, FRAC>: From<DivExpression<FastFixed<i32, FRAC>, FastFixed<i16, 0>>>,

fn div_assign(&mut self, rhs: i16)

Performs the /= operation.

impl<const FRAC: usize> DivAssign<i16> for FastFixed<i64, FRAC>

where Self: Copy, FastFixed<i64, FRAC>: From<DivExpression<FastFixed<i64, FRAC>, FastFixed<i16, 0>>>,

fn div_assign(&mut self, rhs: i16)

Performs the /= operation.

impl<const FRAC: usize> DivAssign<i16> for FastFixed<u8, FRAC>

where Self: Copy, FastFixed<u8, FRAC>: From<DivExpression<FastFixed<u8, FRAC>, FastFixed<i16, 0>>>,

fn div_assign(&mut self, rhs: i16)

Performs the /= operation.

impl<const FRAC: usize> DivAssign<i16> for FastFixed<u16, FRAC>

where Self: Copy, FastFixed<u16, FRAC>: From<DivExpression<FastFixed<u16, FRAC>, FastFixed<i16, 0>>>,

fn div_assign(&mut self, rhs: i16)

Performs the /= operation.

impl<const FRAC: usize> DivAssign<i16> for FastFixed<u32, FRAC>

where Self: Copy, FastFixed<u32, FRAC>: From<DivExpression<FastFixed<u32, FRAC>, FastFixed<i16, 0>>>,

fn div_assign(&mut self, rhs: i16)

Performs the /= operation.

impl<const FRAC: usize> DivAssign<i16> for FastFixed<u64, FRAC>

where Self: Copy, FastFixed<u64, FRAC>: From<DivExpression<FastFixed<u64, FRAC>, FastFixed<i16, 0>>>,

fn div_assign(&mut self, rhs: i16)

Performs the /= operation.

impl<const FRAC: usize> DivAssign<i32> for FastFixed<i8, FRAC>

where Self: Copy, FastFixed<i8, FRAC>: From<DivExpression<FastFixed<i8, FRAC>, FastFixed<i32, 0>>>,

fn div_assign(&mut self, rhs: i32)

Performs the /= operation.

impl<const FRAC: usize> DivAssign<i32> for FastFixed<i16, FRAC>

where Self: Copy, FastFixed<i16, FRAC>: From<DivExpression<FastFixed<i16, FRAC>, FastFixed<i32, 0>>>,

fn div_assign(&mut self, rhs: i32)

Performs the /= operation.

impl<const FRAC: usize> DivAssign<i32> for FastFixed<i32, FRAC>

where Self: Copy, FastFixed<i32, FRAC>: From<DivExpression<FastFixed<i32, FRAC>, FastFixed<i32, 0>>>,

fn div_assign(&mut self, rhs: i32)

Performs the /= operation.

impl<const FRAC: usize> DivAssign<i32> for FastFixed<i64, FRAC>

where Self: Copy, FastFixed<i64, FRAC>: From<DivExpression<FastFixed<i64, FRAC>, FastFixed<i32, 0>>>,

fn div_assign(&mut self, rhs: i32)

Performs the /= operation.

impl<const FRAC: usize> DivAssign<i32> for FastFixed<u8, FRAC>

where Self: Copy, FastFixed<u8, FRAC>: From<DivExpression<FastFixed<u8, FRAC>, FastFixed<i32, 0>>>,

fn div_assign(&mut self, rhs: i32)

Performs the /= operation.

impl<const FRAC: usize> DivAssign<i32> for FastFixed<u16, FRAC>

where Self: Copy, FastFixed<u16, FRAC>: From<DivExpression<FastFixed<u16, FRAC>, FastFixed<i32, 0>>>,

fn div_assign(&mut self, rhs: i32)

Performs the /= operation.

impl<const FRAC: usize> DivAssign<i32> for FastFixed<u32, FRAC>

where Self: Copy, FastFixed<u32, FRAC>: From<DivExpression<FastFixed<u32, FRAC>, FastFixed<i32, 0>>>,

fn div_assign(&mut self, rhs: i32)

Performs the /= operation.

impl<const FRAC: usize> DivAssign<i32> for FastFixed<u64, FRAC>

where Self: Copy, FastFixed<u64, FRAC>: From<DivExpression<FastFixed<u64, FRAC>, FastFixed<i32, 0>>>,

fn div_assign(&mut self, rhs: i32)

Performs the /= operation.

impl<const FRAC: usize> DivAssign<i64> for FastFixed<i8, FRAC>

where Self: Copy, FastFixed<i8, FRAC>: From<DivExpression<FastFixed<i8, FRAC>, FastFixed<i64, 0>>>,

fn div_assign(&mut self, rhs: i64)

Performs the /= operation.

impl<const FRAC: usize> DivAssign<i64> for FastFixed<i16, FRAC>

where Self: Copy, FastFixed<i16, FRAC>: From<DivExpression<FastFixed<i16, FRAC>, FastFixed<i64, 0>>>,

fn div_assign(&mut self, rhs: i64)

Performs the /= operation.

impl<const FRAC: usize> DivAssign<i64> for FastFixed<i32, FRAC>

where Self: Copy, FastFixed<i32, FRAC>: From<DivExpression<FastFixed<i32, FRAC>, FastFixed<i64, 0>>>,

fn div_assign(&mut self, rhs: i64)

Performs the /= operation.

impl<const FRAC: usize> DivAssign<i64> for FastFixed<i64, FRAC>

where Self: Copy, FastFixed<i64, FRAC>: From<DivExpression<FastFixed<i64, FRAC>, FastFixed<i64, 0>>>,

fn div_assign(&mut self, rhs: i64)

Performs the /= operation.

impl<const FRAC: usize> DivAssign<i64> for FastFixed<u8, FRAC>

where Self: Copy, FastFixed<u8, FRAC>: From<DivExpression<FastFixed<u8, FRAC>, FastFixed<i64, 0>>>,

fn div_assign(&mut self, rhs: i64)

Performs the /= operation.

impl<const FRAC: usize> DivAssign<i64> for FastFixed<u16, FRAC>

where Self: Copy, FastFixed<u16, FRAC>: From<DivExpression<FastFixed<u16, FRAC>, FastFixed<i64, 0>>>,

fn div_assign(&mut self, rhs: i64)

Performs the /= operation.

impl<const FRAC: usize> DivAssign<i64> for FastFixed<u32, FRAC>

where Self: Copy, FastFixed<u32, FRAC>: From<DivExpression<FastFixed<u32, FRAC>, FastFixed<i64, 0>>>,

fn div_assign(&mut self, rhs: i64)

Performs the /= operation.

impl<const FRAC: usize> DivAssign<i64> for FastFixed<u64, FRAC>

where Self: Copy, FastFixed<u64, FRAC>: From<DivExpression<FastFixed<u64, FRAC>, FastFixed<i64, 0>>>,

fn div_assign(&mut self, rhs: i64)

Performs the /= operation.

impl<const FRAC: usize> DivAssign<u8> for FastFixed<u8, FRAC>

where Self: Copy, FastFixed<u8, FRAC>: From<DivExpression<FastFixed<u8, FRAC>, FastFixed<u8, 0>>>,

fn div_assign(&mut self, rhs: u8)

Performs the /= operation.

impl<const FRAC: usize> DivAssign<u8> for FastFixed<u16, FRAC>

where Self: Copy, FastFixed<u16, FRAC>: From<DivExpression<FastFixed<u16, FRAC>, FastFixed<u8, 0>>>,

fn div_assign(&mut self, rhs: u8)

Performs the /= operation.

impl<const FRAC: usize> DivAssign<u8> for FastFixed<u32, FRAC>

where Self: Copy, FastFixed<u32, FRAC>: From<DivExpression<FastFixed<u32, FRAC>, FastFixed<u8, 0>>>,

fn div_assign(&mut self, rhs: u8)

Performs the /= operation.

impl<const FRAC: usize> DivAssign<u8> for FastFixed<u64, FRAC>

where Self: Copy, FastFixed<u64, FRAC>: From<DivExpression<FastFixed<u64, FRAC>, FastFixed<u8, 0>>>,

fn div_assign(&mut self, rhs: u8)

Performs the /= operation.

impl<const FRAC: usize> DivAssign<u8> for FastFixed<i8, FRAC>

where Self: Copy, FastFixed<i8, FRAC>: From<DivExpression<FastFixed<i8, FRAC>, FastFixed<u8, 0>>>,

fn div_assign(&mut self, rhs: u8)

Performs the /= operation.

impl<const FRAC: usize> DivAssign<u8> for FastFixed<i16, FRAC>

where Self: Copy, FastFixed<i16, FRAC>: From<DivExpression<FastFixed<i16, FRAC>, FastFixed<u8, 0>>>,

fn div_assign(&mut self, rhs: u8)

Performs the /= operation.

impl<const FRAC: usize> DivAssign<u8> for FastFixed<i32, FRAC>

where Self: Copy, FastFixed<i32, FRAC>: From<DivExpression<FastFixed<i32, FRAC>, FastFixed<u8, 0>>>,

fn div_assign(&mut self, rhs: u8)

Performs the /= operation.

impl<const FRAC: usize> DivAssign<u8> for FastFixed<i64, FRAC>

where Self: Copy, FastFixed<i64, FRAC>: From<DivExpression<FastFixed<i64, FRAC>, FastFixed<u8, 0>>>,

fn div_assign(&mut self, rhs: u8)

Performs the /= operation.

impl<const FRAC: usize> DivAssign<u16> for FastFixed<u8, FRAC>

where Self: Copy, FastFixed<u8, FRAC>: From<DivExpression<FastFixed<u8, FRAC>, FastFixed<u16, 0>>>,

fn div_assign(&mut self, rhs: u16)

Performs the /= operation.

impl<const FRAC: usize> DivAssign<u16> for FastFixed<u16, FRAC>

where Self: Copy, FastFixed<u16, FRAC>: From<DivExpression<FastFixed<u16, FRAC>, FastFixed<u16, 0>>>,

fn div_assign(&mut self, rhs: u16)

Performs the /= operation.

impl<const FRAC: usize> DivAssign<u16> for FastFixed<u32, FRAC>

where Self: Copy, FastFixed<u32, FRAC>: From<DivExpression<FastFixed<u32, FRAC>, FastFixed<u16, 0>>>,

fn div_assign(&mut self, rhs: u16)

Performs the /= operation.

impl<const FRAC: usize> DivAssign<u16> for FastFixed<u64, FRAC>

where Self: Copy, FastFixed<u64, FRAC>: From<DivExpression<FastFixed<u64, FRAC>, FastFixed<u16, 0>>>,

fn div_assign(&mut self, rhs: u16)

Performs the /= operation.

impl<const FRAC: usize> DivAssign<u16> for FastFixed<i8, FRAC>

where Self: Copy, FastFixed<i8, FRAC>: From<DivExpression<FastFixed<i8, FRAC>, FastFixed<u16, 0>>>,

fn div_assign(&mut self, rhs: u16)

Performs the /= operation.

impl<const FRAC: usize> DivAssign<u16> for FastFixed<i16, FRAC>

where Self: Copy, FastFixed<i16, FRAC>: From<DivExpression<FastFixed<i16, FRAC>, FastFixed<u16, 0>>>,

fn div_assign(&mut self, rhs: u16)

Performs the /= operation.

impl<const FRAC: usize> DivAssign<u16> for FastFixed<i32, FRAC>

where Self: Copy, FastFixed<i32, FRAC>: From<DivExpression<FastFixed<i32, FRAC>, FastFixed<u16, 0>>>,

fn div_assign(&mut self, rhs: u16)

Performs the /= operation.

impl<const FRAC: usize> DivAssign<u16> for FastFixed<i64, FRAC>

where Self: Copy, FastFixed<i64, FRAC>: From<DivExpression<FastFixed<i64, FRAC>, FastFixed<u16, 0>>>,

fn div_assign(&mut self, rhs: u16)

Performs the /= operation.

impl<const FRAC: usize> DivAssign<u32> for FastFixed<u8, FRAC>

where Self: Copy, FastFixed<u8, FRAC>: From<DivExpression<FastFixed<u8, FRAC>, FastFixed<u32, 0>>>,

fn div_assign(&mut self, rhs: u32)

Performs the /= operation.

impl<const FRAC: usize> DivAssign<u32> for FastFixed<u16, FRAC>

where Self: Copy, FastFixed<u16, FRAC>: From<DivExpression<FastFixed<u16, FRAC>, FastFixed<u32, 0>>>,

fn div_assign(&mut self, rhs: u32)

Performs the /= operation.

impl<const FRAC: usize> DivAssign<u32> for FastFixed<u32, FRAC>

where Self: Copy, FastFixed<u32, FRAC>: From<DivExpression<FastFixed<u32, FRAC>, FastFixed<u32, 0>>>,

fn div_assign(&mut self, rhs: u32)

Performs the /= operation.

impl<const FRAC: usize> DivAssign<u32> for FastFixed<u64, FRAC>

where Self: Copy, FastFixed<u64, FRAC>: From<DivExpression<FastFixed<u64, FRAC>, FastFixed<u32, 0>>>,

fn div_assign(&mut self, rhs: u32)

Performs the /= operation.

impl<const FRAC: usize> DivAssign<u32> for FastFixed<i8, FRAC>

where Self: Copy, FastFixed<i8, FRAC>: From<DivExpression<FastFixed<i8, FRAC>, FastFixed<u32, 0>>>,

fn div_assign(&mut self, rhs: u32)

Performs the /= operation.

impl<const FRAC: usize> DivAssign<u32> for FastFixed<i16, FRAC>

where Self: Copy, FastFixed<i16, FRAC>: From<DivExpression<FastFixed<i16, FRAC>, FastFixed<u32, 0>>>,

fn div_assign(&mut self, rhs: u32)

Performs the /= operation.

impl<const FRAC: usize> DivAssign<u32> for FastFixed<i32, FRAC>

where Self: Copy, FastFixed<i32, FRAC>: From<DivExpression<FastFixed<i32, FRAC>, FastFixed<u32, 0>>>,

fn div_assign(&mut self, rhs: u32)

Performs the /= operation.

impl<const FRAC: usize> DivAssign<u32> for FastFixed<i64, FRAC>

where Self: Copy, FastFixed<i64, FRAC>: From<DivExpression<FastFixed<i64, FRAC>, FastFixed<u32, 0>>>,

fn div_assign(&mut self, rhs: u32)

Performs the /= operation.

impl<const FRAC: usize> DivAssign<u64> for FastFixed<u8, FRAC>

where Self: Copy, FastFixed<u8, FRAC>: From<DivExpression<FastFixed<u8, FRAC>, FastFixed<u64, 0>>>,

fn div_assign(&mut self, rhs: u64)

Performs the /= operation.

impl<const FRAC: usize> DivAssign<u64> for FastFixed<u16, FRAC>

where Self: Copy, FastFixed<u16, FRAC>: From<DivExpression<FastFixed<u16, FRAC>, FastFixed<u64, 0>>>,

fn div_assign(&mut self, rhs: u64)

Performs the /= operation.

impl<const FRAC: usize> DivAssign<u64> for FastFixed<u32, FRAC>

where Self: Copy, FastFixed<u32, FRAC>: From<DivExpression<FastFixed<u32, FRAC>, FastFixed<u64, 0>>>,

fn div_assign(&mut self, rhs: u64)

Performs the /= operation.

impl<const FRAC: usize> DivAssign<u64> for FastFixed<u64, FRAC>

where Self: Copy, FastFixed<u64, FRAC>: From<DivExpression<FastFixed<u64, FRAC>, FastFixed<u64, 0>>>,

fn div_assign(&mut self, rhs: u64)

Performs the /= operation.

impl<const FRAC: usize> DivAssign<u64> for FastFixed<i8, FRAC>

where Self: Copy, FastFixed<i8, FRAC>: From<DivExpression<FastFixed<i8, FRAC>, FastFixed<u64, 0>>>,

fn div_assign(&mut self, rhs: u64)

Performs the /= operation.

impl<const FRAC: usize> DivAssign<u64> for FastFixed<i16, FRAC>

where Self: Copy, FastFixed<i16, FRAC>: From<DivExpression<FastFixed<i16, FRAC>, FastFixed<u64, 0>>>,

fn div_assign(&mut self, rhs: u64)

Performs the /= operation.

impl<const FRAC: usize> DivAssign<u64> for FastFixed<i32, FRAC>

where Self: Copy, FastFixed<i32, FRAC>: From<DivExpression<FastFixed<i32, FRAC>, FastFixed<u64, 0>>>,

fn div_assign(&mut self, rhs: u64)

Performs the /= operation.

impl<const FRAC: usize> DivAssign<u64> for FastFixed<i64, FRAC>

where Self: Copy, FastFixed<i64, FRAC>: From<DivExpression<FastFixed<i64, FRAC>, FastFixed<u64, 0>>>,

fn div_assign(&mut self, rhs: u64)

Performs the /= operation.

impl<I: Eq + Copy, const FRAC: usize> Eq for FastFixed<I, FRAC>

impl<I, const TARGET_FRAC: usize, IL, const FL: usize, IR, const FR: usize> From<DivExpression<FastFixed<IL, FL>, FastFixed<IR, FR>>> for FastFixed<I, TARGET_FRAC>

where I: Bounded + NumCast + Copy + FastInt, IL: Zero + PartialOrd + NumCast + Copy, IR: Zero + PartialOrd + NumCast + Copy,

fn from(expr: DivExpression<FastFixed<IL, FL>, FastFixed<IR, FR>>) -> Self

Converts to this type from the input type.

impl<I: Copy, const FRAC: usize> From<FastFixed<I, FRAC>> for Fixed<I, FRAC>

fn from(val: FastFixed<I, FRAC>) -> Self

Converts to this type from the input type.

impl<I: Copy, const FRAC: usize> From<Fixed<I, FRAC>> for FastFixed<I, FRAC>

fn from(val: Fixed<I, FRAC>) -> Self

Converts to this type from the input type.

impl<I, const FRAC_OUT: usize, L, R> From<MulExpression<L, R>> for FastFixed<I, FRAC_OUT>

where I: Bounded + NumCast + Copy, MulExpression<L, R>: FastExpression,

fn from(expr: MulExpression<L, R>) -> Self

Converts to this type from the input type.

impl<I, const FRAC_OUT: usize, L, R> From<SumExpression<L, R>> for FastFixed<I, FRAC_OUT>

where I: Bounded + NumCast + Copy, SumExpression<L, R>: FastExpression,

fn from(expr: SumExpression<L, R>) -> Self

Converts to this type from the input type.

impl<I: Hash, const FRAC: usize> Hash for FastFixed<I, FRAC>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given [Hasher].

impl<I, const FRAC: usize> LowerHex for FastFixed<I, FRAC>

where I: Into<i128> + Copy,

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

Formats the value using the given formatter.

impl<T, const FL: usize, U, const FR: usize> Mul<FastFixed<U, FR>> for FastFixed<T, FL>

type Output = MulExpression<FastFixed<T, FL>, FastFixed<U, FR>>

The resulting type after applying the * operator.

fn mul(self, rhs: FastFixed<U, FR>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<FastFixed<i8, FRAC>> for i8

where i8: PromoteMul<i8> + Zero + PartialOrd + NumCast + Copy, <i8 as PromoteMul<i8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i8 as PromoteMul<i8>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: FastFixed<i8, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<FastFixed<i8, FRAC>> for i16

where i8: PromoteMul<i16> + Zero + PartialOrd + NumCast + Copy, i16: Zero + PartialOrd + NumCast + Copy, <i8 as PromoteMul<i16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i8 as PromoteMul<i16>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: FastFixed<i8, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<FastFixed<i8, FRAC>> for i32

where i8: PromoteMul<i32> + Zero + PartialOrd + NumCast + Copy, i32: Zero + PartialOrd + NumCast + Copy, <i8 as PromoteMul<i32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i8 as PromoteMul<i32>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: FastFixed<i8, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<FastFixed<i8, FRAC>> for i64

where i8: PromoteMul<i64> + Zero + PartialOrd + NumCast + Copy, i64: Zero + PartialOrd + NumCast + Copy, <i8 as PromoteMul<i64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i8 as PromoteMul<i64>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: FastFixed<i8, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<FastFixed<i8, FRAC>> for u8

where i8: PromoteMul<u8> + Zero + PartialOrd + NumCast + Copy, u8: Zero + PartialOrd + NumCast + Copy, <i8 as PromoteMul<u8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i8 as PromoteMul<u8>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: FastFixed<i8, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<FastFixed<i8, FRAC>> for u16

where i8: PromoteMul<u16> + Zero + PartialOrd + NumCast + Copy, u16: Zero + PartialOrd + NumCast + Copy, <i8 as PromoteMul<u16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i8 as PromoteMul<u16>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: FastFixed<i8, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<FastFixed<i8, FRAC>> for u32

where i8: PromoteMul<u32> + Zero + PartialOrd + NumCast + Copy, u32: Zero + PartialOrd + NumCast + Copy, <i8 as PromoteMul<u32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i8 as PromoteMul<u32>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: FastFixed<i8, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<FastFixed<i8, FRAC>> for u64

where i8: PromoteMul<u64> + Zero + PartialOrd + NumCast + Copy, u64: Zero + PartialOrd + NumCast + Copy, <i8 as PromoteMul<u64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i8 as PromoteMul<u64>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: FastFixed<i8, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<FastFixed<i16, FRAC>> for i8

where i16: PromoteMul<i8> + Zero + PartialOrd + NumCast + Copy, i8: Zero + PartialOrd + NumCast + Copy, <i16 as PromoteMul<i8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i16 as PromoteMul<i8>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: FastFixed<i16, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<FastFixed<i16, FRAC>> for i16

where i16: PromoteMul<i16> + Zero + PartialOrd + NumCast + Copy, <i16 as PromoteMul<i16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i16 as PromoteMul<i16>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: FastFixed<i16, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<FastFixed<i16, FRAC>> for i32

where i16: PromoteMul<i32> + Zero + PartialOrd + NumCast + Copy, i32: Zero + PartialOrd + NumCast + Copy, <i16 as PromoteMul<i32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i16 as PromoteMul<i32>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: FastFixed<i16, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<FastFixed<i16, FRAC>> for i64

where i16: PromoteMul<i64> + Zero + PartialOrd + NumCast + Copy, i64: Zero + PartialOrd + NumCast + Copy, <i16 as PromoteMul<i64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i16 as PromoteMul<i64>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: FastFixed<i16, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<FastFixed<i16, FRAC>> for u8

where i16: PromoteMul<u8> + Zero + PartialOrd + NumCast + Copy, u8: Zero + PartialOrd + NumCast + Copy, <i16 as PromoteMul<u8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i16 as PromoteMul<u8>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: FastFixed<i16, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<FastFixed<i16, FRAC>> for u16

where i16: PromoteMul<u16> + Zero + PartialOrd + NumCast + Copy, u16: Zero + PartialOrd + NumCast + Copy, <i16 as PromoteMul<u16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i16 as PromoteMul<u16>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: FastFixed<i16, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<FastFixed<i16, FRAC>> for u32

where i16: PromoteMul<u32> + Zero + PartialOrd + NumCast + Copy, u32: Zero + PartialOrd + NumCast + Copy, <i16 as PromoteMul<u32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i16 as PromoteMul<u32>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: FastFixed<i16, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<FastFixed<i16, FRAC>> for u64

where i16: PromoteMul<u64> + Zero + PartialOrd + NumCast + Copy, u64: Zero + PartialOrd + NumCast + Copy, <i16 as PromoteMul<u64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i16 as PromoteMul<u64>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: FastFixed<i16, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<FastFixed<i32, FRAC>> for i8

where i32: PromoteMul<i8> + Zero + PartialOrd + NumCast + Copy, i8: Zero + PartialOrd + NumCast + Copy, <i32 as PromoteMul<i8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i32 as PromoteMul<i8>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: FastFixed<i32, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<FastFixed<i32, FRAC>> for i16

where i32: PromoteMul<i16> + Zero + PartialOrd + NumCast + Copy, i16: Zero + PartialOrd + NumCast + Copy, <i32 as PromoteMul<i16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i32 as PromoteMul<i16>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: FastFixed<i32, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<FastFixed<i32, FRAC>> for i32

where i32: PromoteMul<i32> + Zero + PartialOrd + NumCast + Copy, <i32 as PromoteMul<i32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i32 as PromoteMul<i32>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: FastFixed<i32, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<FastFixed<i32, FRAC>> for i64

where i32: PromoteMul<i64> + Zero + PartialOrd + NumCast + Copy, i64: Zero + PartialOrd + NumCast + Copy, <i32 as PromoteMul<i64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i32 as PromoteMul<i64>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: FastFixed<i32, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<FastFixed<i32, FRAC>> for u8

where i32: PromoteMul<u8> + Zero + PartialOrd + NumCast + Copy, u8: Zero + PartialOrd + NumCast + Copy, <i32 as PromoteMul<u8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i32 as PromoteMul<u8>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: FastFixed<i32, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<FastFixed<i32, FRAC>> for u16

where i32: PromoteMul<u16> + Zero + PartialOrd + NumCast + Copy, u16: Zero + PartialOrd + NumCast + Copy, <i32 as PromoteMul<u16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i32 as PromoteMul<u16>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: FastFixed<i32, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<FastFixed<i32, FRAC>> for u32

where i32: PromoteMul<u32> + Zero + PartialOrd + NumCast + Copy, u32: Zero + PartialOrd + NumCast + Copy, <i32 as PromoteMul<u32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i32 as PromoteMul<u32>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: FastFixed<i32, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<FastFixed<i32, FRAC>> for u64

where i32: PromoteMul<u64> + Zero + PartialOrd + NumCast + Copy, u64: Zero + PartialOrd + NumCast + Copy, <i32 as PromoteMul<u64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i32 as PromoteMul<u64>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: FastFixed<i32, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<FastFixed<i64, FRAC>> for i8

where i64: PromoteMul<i8> + Zero + PartialOrd + NumCast + Copy, i8: Zero + PartialOrd + NumCast + Copy, <i64 as PromoteMul<i8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i64 as PromoteMul<i8>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: FastFixed<i64, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<FastFixed<i64, FRAC>> for i16

where i64: PromoteMul<i16> + Zero + PartialOrd + NumCast + Copy, i16: Zero + PartialOrd + NumCast + Copy, <i64 as PromoteMul<i16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i64 as PromoteMul<i16>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: FastFixed<i64, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<FastFixed<i64, FRAC>> for i32

where i64: PromoteMul<i32> + Zero + PartialOrd + NumCast + Copy, i32: Zero + PartialOrd + NumCast + Copy, <i64 as PromoteMul<i32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i64 as PromoteMul<i32>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: FastFixed<i64, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<FastFixed<i64, FRAC>> for i64

where i64: PromoteMul<i64> + Zero + PartialOrd + NumCast + Copy, <i64 as PromoteMul<i64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i64 as PromoteMul<i64>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: FastFixed<i64, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<FastFixed<i64, FRAC>> for u8

where i64: PromoteMul<u8> + Zero + PartialOrd + NumCast + Copy, u8: Zero + PartialOrd + NumCast + Copy, <i64 as PromoteMul<u8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i64 as PromoteMul<u8>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: FastFixed<i64, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<FastFixed<i64, FRAC>> for u16

where i64: PromoteMul<u16> + Zero + PartialOrd + NumCast + Copy, u16: Zero + PartialOrd + NumCast + Copy, <i64 as PromoteMul<u16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i64 as PromoteMul<u16>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: FastFixed<i64, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<FastFixed<i64, FRAC>> for u32

where i64: PromoteMul<u32> + Zero + PartialOrd + NumCast + Copy, u32: Zero + PartialOrd + NumCast + Copy, <i64 as PromoteMul<u32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i64 as PromoteMul<u32>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: FastFixed<i64, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<FastFixed<i64, FRAC>> for u64

where i64: PromoteMul<u64> + Zero + PartialOrd + NumCast + Copy, u64: Zero + PartialOrd + NumCast + Copy, <i64 as PromoteMul<u64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i64 as PromoteMul<u64>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: FastFixed<i64, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<FastFixed<u8, FRAC>> for u8

where u8: PromoteMul<u8> + Zero + PartialOrd + NumCast + Copy, <u8 as PromoteMul<u8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u8 as PromoteMul<u8>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: FastFixed<u8, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<FastFixed<u8, FRAC>> for u16

where u8: PromoteMul<u16> + Zero + PartialOrd + NumCast + Copy, u16: Zero + PartialOrd + NumCast + Copy, <u8 as PromoteMul<u16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u8 as PromoteMul<u16>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: FastFixed<u8, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<FastFixed<u8, FRAC>> for u32

where u8: PromoteMul<u32> + Zero + PartialOrd + NumCast + Copy, u32: Zero + PartialOrd + NumCast + Copy, <u8 as PromoteMul<u32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u8 as PromoteMul<u32>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: FastFixed<u8, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<FastFixed<u8, FRAC>> for u64

where u8: PromoteMul<u64> + Zero + PartialOrd + NumCast + Copy, u64: Zero + PartialOrd + NumCast + Copy, <u8 as PromoteMul<u64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u8 as PromoteMul<u64>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: FastFixed<u8, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<FastFixed<u8, FRAC>> for i8

where u8: PromoteMul<i8> + Zero + PartialOrd + NumCast + Copy, i8: Zero + PartialOrd + NumCast + Copy, <u8 as PromoteMul<i8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u8 as PromoteMul<i8>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: FastFixed<u8, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<FastFixed<u8, FRAC>> for i16

where u8: PromoteMul<i16> + Zero + PartialOrd + NumCast + Copy, i16: Zero + PartialOrd + NumCast + Copy, <u8 as PromoteMul<i16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u8 as PromoteMul<i16>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: FastFixed<u8, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<FastFixed<u8, FRAC>> for i32

where u8: PromoteMul<i32> + Zero + PartialOrd + NumCast + Copy, i32: Zero + PartialOrd + NumCast + Copy, <u8 as PromoteMul<i32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u8 as PromoteMul<i32>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: FastFixed<u8, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<FastFixed<u8, FRAC>> for i64

where u8: PromoteMul<i64> + Zero + PartialOrd + NumCast + Copy, i64: Zero + PartialOrd + NumCast + Copy, <u8 as PromoteMul<i64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u8 as PromoteMul<i64>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: FastFixed<u8, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<FastFixed<u16, FRAC>> for u8

where u16: PromoteMul<u8> + Zero + PartialOrd + NumCast + Copy, u8: Zero + PartialOrd + NumCast + Copy, <u16 as PromoteMul<u8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u16 as PromoteMul<u8>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: FastFixed<u16, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<FastFixed<u16, FRAC>> for u16

where u16: PromoteMul<u16> + Zero + PartialOrd + NumCast + Copy, <u16 as PromoteMul<u16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u16 as PromoteMul<u16>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: FastFixed<u16, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<FastFixed<u16, FRAC>> for u32

where u16: PromoteMul<u32> + Zero + PartialOrd + NumCast + Copy, u32: Zero + PartialOrd + NumCast + Copy, <u16 as PromoteMul<u32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u16 as PromoteMul<u32>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: FastFixed<u16, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<FastFixed<u16, FRAC>> for u64

where u16: PromoteMul<u64> + Zero + PartialOrd + NumCast + Copy, u64: Zero + PartialOrd + NumCast + Copy, <u16 as PromoteMul<u64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u16 as PromoteMul<u64>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: FastFixed<u16, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<FastFixed<u16, FRAC>> for i8

where u16: PromoteMul<i8> + Zero + PartialOrd + NumCast + Copy, i8: Zero + PartialOrd + NumCast + Copy, <u16 as PromoteMul<i8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u16 as PromoteMul<i8>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: FastFixed<u16, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<FastFixed<u16, FRAC>> for i16

where u16: PromoteMul<i16> + Zero + PartialOrd + NumCast + Copy, i16: Zero + PartialOrd + NumCast + Copy, <u16 as PromoteMul<i16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u16 as PromoteMul<i16>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: FastFixed<u16, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<FastFixed<u16, FRAC>> for i32

where u16: PromoteMul<i32> + Zero + PartialOrd + NumCast + Copy, i32: Zero + PartialOrd + NumCast + Copy, <u16 as PromoteMul<i32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u16 as PromoteMul<i32>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: FastFixed<u16, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<FastFixed<u16, FRAC>> for i64

where u16: PromoteMul<i64> + Zero + PartialOrd + NumCast + Copy, i64: Zero + PartialOrd + NumCast + Copy, <u16 as PromoteMul<i64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u16 as PromoteMul<i64>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: FastFixed<u16, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<FastFixed<u32, FRAC>> for u8

where u32: PromoteMul<u8> + Zero + PartialOrd + NumCast + Copy, u8: Zero + PartialOrd + NumCast + Copy, <u32 as PromoteMul<u8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u32 as PromoteMul<u8>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: FastFixed<u32, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<FastFixed<u32, FRAC>> for u16

where u32: PromoteMul<u16> + Zero + PartialOrd + NumCast + Copy, u16: Zero + PartialOrd + NumCast + Copy, <u32 as PromoteMul<u16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u32 as PromoteMul<u16>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: FastFixed<u32, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<FastFixed<u32, FRAC>> for u32

where u32: PromoteMul<u32> + Zero + PartialOrd + NumCast + Copy, <u32 as PromoteMul<u32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u32 as PromoteMul<u32>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: FastFixed<u32, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<FastFixed<u32, FRAC>> for u64

where u32: PromoteMul<u64> + Zero + PartialOrd + NumCast + Copy, u64: Zero + PartialOrd + NumCast + Copy, <u32 as PromoteMul<u64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u32 as PromoteMul<u64>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: FastFixed<u32, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<FastFixed<u32, FRAC>> for i8

where u32: PromoteMul<i8> + Zero + PartialOrd + NumCast + Copy, i8: Zero + PartialOrd + NumCast + Copy, <u32 as PromoteMul<i8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u32 as PromoteMul<i8>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: FastFixed<u32, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<FastFixed<u32, FRAC>> for i16

where u32: PromoteMul<i16> + Zero + PartialOrd + NumCast + Copy, i16: Zero + PartialOrd + NumCast + Copy, <u32 as PromoteMul<i16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u32 as PromoteMul<i16>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: FastFixed<u32, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<FastFixed<u32, FRAC>> for i32

where u32: PromoteMul<i32> + Zero + PartialOrd + NumCast + Copy, i32: Zero + PartialOrd + NumCast + Copy, <u32 as PromoteMul<i32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u32 as PromoteMul<i32>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: FastFixed<u32, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<FastFixed<u32, FRAC>> for i64

where u32: PromoteMul<i64> + Zero + PartialOrd + NumCast + Copy, i64: Zero + PartialOrd + NumCast + Copy, <u32 as PromoteMul<i64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u32 as PromoteMul<i64>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: FastFixed<u32, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<FastFixed<u64, FRAC>> for u8

where u64: PromoteMul<u8> + Zero + PartialOrd + NumCast + Copy, u8: Zero + PartialOrd + NumCast + Copy, <u64 as PromoteMul<u8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u64 as PromoteMul<u8>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: FastFixed<u64, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<FastFixed<u64, FRAC>> for u16

where u64: PromoteMul<u16> + Zero + PartialOrd + NumCast + Copy, u16: Zero + PartialOrd + NumCast + Copy, <u64 as PromoteMul<u16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u64 as PromoteMul<u16>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: FastFixed<u64, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<FastFixed<u64, FRAC>> for u32

where u64: PromoteMul<u32> + Zero + PartialOrd + NumCast + Copy, u32: Zero + PartialOrd + NumCast + Copy, <u64 as PromoteMul<u32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u64 as PromoteMul<u32>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: FastFixed<u64, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<FastFixed<u64, FRAC>> for u64

where u64: PromoteMul<u64> + Zero + PartialOrd + NumCast + Copy, <u64 as PromoteMul<u64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u64 as PromoteMul<u64>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: FastFixed<u64, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<FastFixed<u64, FRAC>> for i8

where u64: PromoteMul<i8> + Zero + PartialOrd + NumCast + Copy, i8: Zero + PartialOrd + NumCast + Copy, <u64 as PromoteMul<i8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u64 as PromoteMul<i8>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: FastFixed<u64, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<FastFixed<u64, FRAC>> for i16

where u64: PromoteMul<i16> + Zero + PartialOrd + NumCast + Copy, i16: Zero + PartialOrd + NumCast + Copy, <u64 as PromoteMul<i16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u64 as PromoteMul<i16>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: FastFixed<u64, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<FastFixed<u64, FRAC>> for i32

where u64: PromoteMul<i32> + Zero + PartialOrd + NumCast + Copy, i32: Zero + PartialOrd + NumCast + Copy, <u64 as PromoteMul<i32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u64 as PromoteMul<i32>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: FastFixed<u64, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<FastFixed<u64, FRAC>> for i64

where u64: PromoteMul<i64> + Zero + PartialOrd + NumCast + Copy, i64: Zero + PartialOrd + NumCast + Copy, <u64 as PromoteMul<i64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u64 as PromoteMul<i64>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: FastFixed<u64, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<i8> for FastFixed<i8, FRAC>

where i8: PromoteMul<i8> + Zero + PartialOrd + NumCast + Copy, <i8 as PromoteMul<i8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i8 as PromoteMul<i8>>::Output, FRAC>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const FRAC: usize> Mul<i8> for FastFixed<i16, FRAC>

where i16: PromoteMul<i8> + Zero + PartialOrd + NumCast + Copy, i8: Zero + PartialOrd + NumCast + Copy, <i16 as PromoteMul<i8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i16 as PromoteMul<i8>>::Output, FRAC>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const FRAC: usize> Mul<i8> for FastFixed<i32, FRAC>

where i32: PromoteMul<i8> + Zero + PartialOrd + NumCast + Copy, i8: Zero + PartialOrd + NumCast + Copy, <i32 as PromoteMul<i8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i32 as PromoteMul<i8>>::Output, FRAC>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const FRAC: usize> Mul<i8> for FastFixed<i64, FRAC>

where i64: PromoteMul<i8> + Zero + PartialOrd + NumCast + Copy, i8: Zero + PartialOrd + NumCast + Copy, <i64 as PromoteMul<i8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i64 as PromoteMul<i8>>::Output, FRAC>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const FRAC: usize> Mul<i8> for FastFixed<u8, FRAC>

where u8: PromoteMul<i8> + Zero + PartialOrd + NumCast + Copy, i8: Zero + PartialOrd + NumCast + Copy, <u8 as PromoteMul<i8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u8 as PromoteMul<i8>>::Output, FRAC>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const FRAC: usize> Mul<i8> for FastFixed<u16, FRAC>

where u16: PromoteMul<i8> + Zero + PartialOrd + NumCast + Copy, i8: Zero + PartialOrd + NumCast + Copy, <u16 as PromoteMul<i8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u16 as PromoteMul<i8>>::Output, FRAC>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const FRAC: usize> Mul<i8> for FastFixed<u32, FRAC>

where u32: PromoteMul<i8> + Zero + PartialOrd + NumCast + Copy, i8: Zero + PartialOrd + NumCast + Copy, <u32 as PromoteMul<i8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u32 as PromoteMul<i8>>::Output, FRAC>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const FRAC: usize> Mul<i8> for FastFixed<u64, FRAC>

where u64: PromoteMul<i8> + Zero + PartialOrd + NumCast + Copy, i8: Zero + PartialOrd + NumCast + Copy, <u64 as PromoteMul<i8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u64 as PromoteMul<i8>>::Output, FRAC>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const FRAC: usize> Mul<i16> for FastFixed<i8, FRAC>

where i8: PromoteMul<i16> + Zero + PartialOrd + NumCast + Copy, i16: Zero + PartialOrd + NumCast + Copy, <i8 as PromoteMul<i16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i8 as PromoteMul<i16>>::Output, FRAC>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const FRAC: usize> Mul<i16> for FastFixed<i16, FRAC>

where i16: PromoteMul<i16> + Zero + PartialOrd + NumCast + Copy, <i16 as PromoteMul<i16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i16 as PromoteMul<i16>>::Output, FRAC>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const FRAC: usize> Mul<i16> for FastFixed<i32, FRAC>

where i32: PromoteMul<i16> + Zero + PartialOrd + NumCast + Copy, i16: Zero + PartialOrd + NumCast + Copy, <i32 as PromoteMul<i16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i32 as PromoteMul<i16>>::Output, FRAC>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const FRAC: usize> Mul<i16> for FastFixed<i64, FRAC>

where i64: PromoteMul<i16> + Zero + PartialOrd + NumCast + Copy, i16: Zero + PartialOrd + NumCast + Copy, <i64 as PromoteMul<i16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i64 as PromoteMul<i16>>::Output, FRAC>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const FRAC: usize> Mul<i16> for FastFixed<u8, FRAC>

where u8: PromoteMul<i16> + Zero + PartialOrd + NumCast + Copy, i16: Zero + PartialOrd + NumCast + Copy, <u8 as PromoteMul<i16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u8 as PromoteMul<i16>>::Output, FRAC>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const FRAC: usize> Mul<i16> for FastFixed<u16, FRAC>

where u16: PromoteMul<i16> + Zero + PartialOrd + NumCast + Copy, i16: Zero + PartialOrd + NumCast + Copy, <u16 as PromoteMul<i16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u16 as PromoteMul<i16>>::Output, FRAC>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const FRAC: usize> Mul<i16> for FastFixed<u32, FRAC>

where u32: PromoteMul<i16> + Zero + PartialOrd + NumCast + Copy, i16: Zero + PartialOrd + NumCast + Copy, <u32 as PromoteMul<i16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u32 as PromoteMul<i16>>::Output, FRAC>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const FRAC: usize> Mul<i16> for FastFixed<u64, FRAC>

where u64: PromoteMul<i16> + Zero + PartialOrd + NumCast + Copy, i16: Zero + PartialOrd + NumCast + Copy, <u64 as PromoteMul<i16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u64 as PromoteMul<i16>>::Output, FRAC>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const FRAC: usize> Mul<i32> for FastFixed<i8, FRAC>

where i8: PromoteMul<i32> + Zero + PartialOrd + NumCast + Copy, i32: Zero + PartialOrd + NumCast + Copy, <i8 as PromoteMul<i32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i8 as PromoteMul<i32>>::Output, FRAC>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const FRAC: usize> Mul<i32> for FastFixed<i16, FRAC>

where i16: PromoteMul<i32> + Zero + PartialOrd + NumCast + Copy, i32: Zero + PartialOrd + NumCast + Copy, <i16 as PromoteMul<i32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i16 as PromoteMul<i32>>::Output, FRAC>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const FRAC: usize> Mul<i32> for FastFixed<i32, FRAC>

where i32: PromoteMul<i32> + Zero + PartialOrd + NumCast + Copy, <i32 as PromoteMul<i32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i32 as PromoteMul<i32>>::Output, FRAC>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const FRAC: usize> Mul<i32> for FastFixed<i64, FRAC>

where i64: PromoteMul<i32> + Zero + PartialOrd + NumCast + Copy, i32: Zero + PartialOrd + NumCast + Copy, <i64 as PromoteMul<i32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i64 as PromoteMul<i32>>::Output, FRAC>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const FRAC: usize> Mul<i32> for FastFixed<u8, FRAC>

where u8: PromoteMul<i32> + Zero + PartialOrd + NumCast + Copy, i32: Zero + PartialOrd + NumCast + Copy, <u8 as PromoteMul<i32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u8 as PromoteMul<i32>>::Output, FRAC>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const FRAC: usize> Mul<i32> for FastFixed<u16, FRAC>

where u16: PromoteMul<i32> + Zero + PartialOrd + NumCast + Copy, i32: Zero + PartialOrd + NumCast + Copy, <u16 as PromoteMul<i32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u16 as PromoteMul<i32>>::Output, FRAC>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const FRAC: usize> Mul<i32> for FastFixed<u32, FRAC>

where u32: PromoteMul<i32> + Zero + PartialOrd + NumCast + Copy, i32: Zero + PartialOrd + NumCast + Copy, <u32 as PromoteMul<i32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u32 as PromoteMul<i32>>::Output, FRAC>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const FRAC: usize> Mul<i32> for FastFixed<u64, FRAC>

where u64: PromoteMul<i32> + Zero + PartialOrd + NumCast + Copy, i32: Zero + PartialOrd + NumCast + Copy, <u64 as PromoteMul<i32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u64 as PromoteMul<i32>>::Output, FRAC>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const FRAC: usize> Mul<i64> for FastFixed<i8, FRAC>

where i8: PromoteMul<i64> + Zero + PartialOrd + NumCast + Copy, i64: Zero + PartialOrd + NumCast + Copy, <i8 as PromoteMul<i64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i8 as PromoteMul<i64>>::Output, FRAC>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const FRAC: usize> Mul<i64> for FastFixed<i16, FRAC>

where i16: PromoteMul<i64> + Zero + PartialOrd + NumCast + Copy, i64: Zero + PartialOrd + NumCast + Copy, <i16 as PromoteMul<i64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i16 as PromoteMul<i64>>::Output, FRAC>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const FRAC: usize> Mul<i64> for FastFixed<i32, FRAC>

where i32: PromoteMul<i64> + Zero + PartialOrd + NumCast + Copy, i64: Zero + PartialOrd + NumCast + Copy, <i32 as PromoteMul<i64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i32 as PromoteMul<i64>>::Output, FRAC>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const FRAC: usize> Mul<i64> for FastFixed<i64, FRAC>

where i64: PromoteMul<i64> + Zero + PartialOrd + NumCast + Copy, <i64 as PromoteMul<i64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i64 as PromoteMul<i64>>::Output, FRAC>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const FRAC: usize> Mul<i64> for FastFixed<u8, FRAC>

where u8: PromoteMul<i64> + Zero + PartialOrd + NumCast + Copy, i64: Zero + PartialOrd + NumCast + Copy, <u8 as PromoteMul<i64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u8 as PromoteMul<i64>>::Output, FRAC>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const FRAC: usize> Mul<i64> for FastFixed<u16, FRAC>

where u16: PromoteMul<i64> + Zero + PartialOrd + NumCast + Copy, i64: Zero + PartialOrd + NumCast + Copy, <u16 as PromoteMul<i64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u16 as PromoteMul<i64>>::Output, FRAC>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const FRAC: usize> Mul<i64> for FastFixed<u32, FRAC>

where u32: PromoteMul<i64> + Zero + PartialOrd + NumCast + Copy, i64: Zero + PartialOrd + NumCast + Copy, <u32 as PromoteMul<i64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u32 as PromoteMul<i64>>::Output, FRAC>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const FRAC: usize> Mul<i64> for FastFixed<u64, FRAC>

where u64: PromoteMul<i64> + Zero + PartialOrd + NumCast + Copy, i64: Zero + PartialOrd + NumCast + Copy, <u64 as PromoteMul<i64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u64 as PromoteMul<i64>>::Output, FRAC>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const FRAC: usize> Mul<u8> for FastFixed<u8, FRAC>

where u8: PromoteMul<u8> + Zero + PartialOrd + NumCast + Copy, <u8 as PromoteMul<u8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u8 as PromoteMul<u8>>::Output, FRAC>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const FRAC: usize> Mul<u8> for FastFixed<u16, FRAC>

where u16: PromoteMul<u8> + Zero + PartialOrd + NumCast + Copy, u8: Zero + PartialOrd + NumCast + Copy, <u16 as PromoteMul<u8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u16 as PromoteMul<u8>>::Output, FRAC>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const FRAC: usize> Mul<u8> for FastFixed<u32, FRAC>

where u32: PromoteMul<u8> + Zero + PartialOrd + NumCast + Copy, u8: Zero + PartialOrd + NumCast + Copy, <u32 as PromoteMul<u8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u32 as PromoteMul<u8>>::Output, FRAC>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const FRAC: usize> Mul<u8> for FastFixed<u64, FRAC>

where u64: PromoteMul<u8> + Zero + PartialOrd + NumCast + Copy, u8: Zero + PartialOrd + NumCast + Copy, <u64 as PromoteMul<u8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u64 as PromoteMul<u8>>::Output, FRAC>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const FRAC: usize> Mul<u8> for FastFixed<i8, FRAC>

where i8: PromoteMul<u8> + Zero + PartialOrd + NumCast + Copy, u8: Zero + PartialOrd + NumCast + Copy, <i8 as PromoteMul<u8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i8 as PromoteMul<u8>>::Output, FRAC>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const FRAC: usize> Mul<u8> for FastFixed<i16, FRAC>

where i16: PromoteMul<u8> + Zero + PartialOrd + NumCast + Copy, u8: Zero + PartialOrd + NumCast + Copy, <i16 as PromoteMul<u8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i16 as PromoteMul<u8>>::Output, FRAC>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const FRAC: usize> Mul<u8> for FastFixed<i32, FRAC>

where i32: PromoteMul<u8> + Zero + PartialOrd + NumCast + Copy, u8: Zero + PartialOrd + NumCast + Copy, <i32 as PromoteMul<u8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i32 as PromoteMul<u8>>::Output, FRAC>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const FRAC: usize> Mul<u8> for FastFixed<i64, FRAC>

where i64: PromoteMul<u8> + Zero + PartialOrd + NumCast + Copy, u8: Zero + PartialOrd + NumCast + Copy, <i64 as PromoteMul<u8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i64 as PromoteMul<u8>>::Output, FRAC>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const FRAC: usize> Mul<u16> for FastFixed<u8, FRAC>

where u8: PromoteMul<u16> + Zero + PartialOrd + NumCast + Copy, u16: Zero + PartialOrd + NumCast + Copy, <u8 as PromoteMul<u16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u8 as PromoteMul<u16>>::Output, FRAC>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const FRAC: usize> Mul<u16> for FastFixed<u16, FRAC>

where u16: PromoteMul<u16> + Zero + PartialOrd + NumCast + Copy, <u16 as PromoteMul<u16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u16 as PromoteMul<u16>>::Output, FRAC>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const FRAC: usize> Mul<u16> for FastFixed<u32, FRAC>

where u32: PromoteMul<u16> + Zero + PartialOrd + NumCast + Copy, u16: Zero + PartialOrd + NumCast + Copy, <u32 as PromoteMul<u16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u32 as PromoteMul<u16>>::Output, FRAC>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const FRAC: usize> Mul<u16> for FastFixed<u64, FRAC>

where u64: PromoteMul<u16> + Zero + PartialOrd + NumCast + Copy, u16: Zero + PartialOrd + NumCast + Copy, <u64 as PromoteMul<u16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u64 as PromoteMul<u16>>::Output, FRAC>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const FRAC: usize> Mul<u16> for FastFixed<i8, FRAC>

where i8: PromoteMul<u16> + Zero + PartialOrd + NumCast + Copy, u16: Zero + PartialOrd + NumCast + Copy, <i8 as PromoteMul<u16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i8 as PromoteMul<u16>>::Output, FRAC>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const FRAC: usize> Mul<u16> for FastFixed<i16, FRAC>

where i16: PromoteMul<u16> + Zero + PartialOrd + NumCast + Copy, u16: Zero + PartialOrd + NumCast + Copy, <i16 as PromoteMul<u16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i16 as PromoteMul<u16>>::Output, FRAC>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const FRAC: usize> Mul<u16> for FastFixed<i32, FRAC>

where i32: PromoteMul<u16> + Zero + PartialOrd + NumCast + Copy, u16: Zero + PartialOrd + NumCast + Copy, <i32 as PromoteMul<u16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i32 as PromoteMul<u16>>::Output, FRAC>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const FRAC: usize> Mul<u16> for FastFixed<i64, FRAC>

where i64: PromoteMul<u16> + Zero + PartialOrd + NumCast + Copy, u16: Zero + PartialOrd + NumCast + Copy, <i64 as PromoteMul<u16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i64 as PromoteMul<u16>>::Output, FRAC>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const FRAC: usize> Mul<u32> for FastFixed<u8, FRAC>

where u8: PromoteMul<u32> + Zero + PartialOrd + NumCast + Copy, u32: Zero + PartialOrd + NumCast + Copy, <u8 as PromoteMul<u32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u8 as PromoteMul<u32>>::Output, FRAC>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const FRAC: usize> Mul<u32> for FastFixed<u16, FRAC>

where u16: PromoteMul<u32> + Zero + PartialOrd + NumCast + Copy, u32: Zero + PartialOrd + NumCast + Copy, <u16 as PromoteMul<u32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u16 as PromoteMul<u32>>::Output, FRAC>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const FRAC: usize> Mul<u32> for FastFixed<u32, FRAC>

where u32: PromoteMul<u32> + Zero + PartialOrd + NumCast + Copy, <u32 as PromoteMul<u32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u32 as PromoteMul<u32>>::Output, FRAC>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const FRAC: usize> Mul<u32> for FastFixed<u64, FRAC>

where u64: PromoteMul<u32> + Zero + PartialOrd + NumCast + Copy, u32: Zero + PartialOrd + NumCast + Copy, <u64 as PromoteMul<u32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u64 as PromoteMul<u32>>::Output, FRAC>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const FRAC: usize> Mul<u32> for FastFixed<i8, FRAC>

where i8: PromoteMul<u32> + Zero + PartialOrd + NumCast + Copy, u32: Zero + PartialOrd + NumCast + Copy, <i8 as PromoteMul<u32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i8 as PromoteMul<u32>>::Output, FRAC>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const FRAC: usize> Mul<u32> for FastFixed<i16, FRAC>

where i16: PromoteMul<u32> + Zero + PartialOrd + NumCast + Copy, u32: Zero + PartialOrd + NumCast + Copy, <i16 as PromoteMul<u32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i16 as PromoteMul<u32>>::Output, FRAC>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const FRAC: usize> Mul<u32> for FastFixed<i32, FRAC>

where i32: PromoteMul<u32> + Zero + PartialOrd + NumCast + Copy, u32: Zero + PartialOrd + NumCast + Copy, <i32 as PromoteMul<u32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i32 as PromoteMul<u32>>::Output, FRAC>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const FRAC: usize> Mul<u32> for FastFixed<i64, FRAC>

where i64: PromoteMul<u32> + Zero + PartialOrd + NumCast + Copy, u32: Zero + PartialOrd + NumCast + Copy, <i64 as PromoteMul<u32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i64 as PromoteMul<u32>>::Output, FRAC>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const FRAC: usize> Mul<u64> for FastFixed<u8, FRAC>

where u8: PromoteMul<u64> + Zero + PartialOrd + NumCast + Copy, u64: Zero + PartialOrd + NumCast + Copy, <u8 as PromoteMul<u64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u8 as PromoteMul<u64>>::Output, FRAC>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const FRAC: usize> Mul<u64> for FastFixed<u16, FRAC>

where u16: PromoteMul<u64> + Zero + PartialOrd + NumCast + Copy, u64: Zero + PartialOrd + NumCast + Copy, <u16 as PromoteMul<u64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u16 as PromoteMul<u64>>::Output, FRAC>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const FRAC: usize> Mul<u64> for FastFixed<u32, FRAC>

where u32: PromoteMul<u64> + Zero + PartialOrd + NumCast + Copy, u64: Zero + PartialOrd + NumCast + Copy, <u32 as PromoteMul<u64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u32 as PromoteMul<u64>>::Output, FRAC>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const FRAC: usize> Mul<u64> for FastFixed<u64, FRAC>

where u64: PromoteMul<u64> + Zero + PartialOrd + NumCast + Copy, <u64 as PromoteMul<u64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u64 as PromoteMul<u64>>::Output, FRAC>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const FRAC: usize> Mul<u64> for FastFixed<i8, FRAC>

where i8: PromoteMul<u64> + Zero + PartialOrd + NumCast + Copy, u64: Zero + PartialOrd + NumCast + Copy, <i8 as PromoteMul<u64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i8 as PromoteMul<u64>>::Output, FRAC>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const FRAC: usize> Mul<u64> for FastFixed<i16, FRAC>

where i16: PromoteMul<u64> + Zero + PartialOrd + NumCast + Copy, u64: Zero + PartialOrd + NumCast + Copy, <i16 as PromoteMul<u64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i16 as PromoteMul<u64>>::Output, FRAC>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const FRAC: usize> Mul<u64> for FastFixed<i32, FRAC>

where i32: PromoteMul<u64> + Zero + PartialOrd + NumCast + Copy, u64: Zero + PartialOrd + NumCast + Copy, <i32 as PromoteMul<u64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i32 as PromoteMul<u64>>::Output, FRAC>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const FRAC: usize> Mul<u64> for FastFixed<i64, FRAC>

where i64: PromoteMul<u64> + Zero + PartialOrd + NumCast + Copy, u64: Zero + PartialOrd + NumCast + Copy, <i64 as PromoteMul<u64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i64 as PromoteMul<u64>>::Output, FRAC>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<I, const FRAC: usize> MulAssign for FastFixed<I, FRAC>

where I: PromoteMul<I> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt + TryFrom<<I as PromoteMul<I>>::Output>, <I as PromoteMul<I>>::Output: FastInt, FastFixed<I, FRAC>: Mul<FastFixed<I, FRAC>, Output = FastFixed<<I as PromoteMul<I>>::Output, FRAC>>,

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<i8> for FastFixed<i8, FRAC>

where i8: PromoteMul<i8> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i8 as PromoteMul<i8>>::Output: FastInt, FastFixed<i8, FRAC>: Mul<i8, Output = FastFixed<<i8 as PromoteMul<i8>>::Output, FRAC>>,

fn mul_assign(&mut self, rhs: i8)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<i8> for FastFixed<i16, FRAC>

where i16: PromoteMul<i8> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i16 as PromoteMul<i8>>::Output: FastInt, i8: Zero + PartialOrd + NumCast + Copy, FastFixed<i16, FRAC>: Mul<i8, Output = FastFixed<<i16 as PromoteMul<i8>>::Output, FRAC>>,

fn mul_assign(&mut self, rhs: i8)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<i8> for FastFixed<i32, FRAC>

where i32: PromoteMul<i8> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i32 as PromoteMul<i8>>::Output: FastInt, i8: Zero + PartialOrd + NumCast + Copy, FastFixed<i32, FRAC>: Mul<i8, Output = FastFixed<<i32 as PromoteMul<i8>>::Output, FRAC>>,

fn mul_assign(&mut self, rhs: i8)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<i8> for FastFixed<i64, FRAC>

where i64: PromoteMul<i8> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i64 as PromoteMul<i8>>::Output: FastInt, i8: Zero + PartialOrd + NumCast + Copy, FastFixed<i64, FRAC>: Mul<i8, Output = FastFixed<<i64 as PromoteMul<i8>>::Output, FRAC>>,

fn mul_assign(&mut self, rhs: i8)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<i8> for FastFixed<u8, FRAC>

where u8: PromoteMul<i8> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u8 as PromoteMul<i8>>::Output: FastInt, i8: Zero + PartialOrd + NumCast + Copy, FastFixed<u8, FRAC>: Mul<i8, Output = FastFixed<<u8 as PromoteMul<i8>>::Output, FRAC>>,

fn mul_assign(&mut self, rhs: i8)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<i8> for FastFixed<u16, FRAC>

where u16: PromoteMul<i8> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u16 as PromoteMul<i8>>::Output: FastInt, i8: Zero + PartialOrd + NumCast + Copy, FastFixed<u16, FRAC>: Mul<i8, Output = FastFixed<<u16 as PromoteMul<i8>>::Output, FRAC>>,

fn mul_assign(&mut self, rhs: i8)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<i8> for FastFixed<u32, FRAC>

where u32: PromoteMul<i8> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u32 as PromoteMul<i8>>::Output: FastInt, i8: Zero + PartialOrd + NumCast + Copy, FastFixed<u32, FRAC>: Mul<i8, Output = FastFixed<<u32 as PromoteMul<i8>>::Output, FRAC>>,

fn mul_assign(&mut self, rhs: i8)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<i8> for FastFixed<u64, FRAC>

where u64: PromoteMul<i8> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u64 as PromoteMul<i8>>::Output: FastInt, i8: Zero + PartialOrd + NumCast + Copy, FastFixed<u64, FRAC>: Mul<i8, Output = FastFixed<<u64 as PromoteMul<i8>>::Output, FRAC>>,

fn mul_assign(&mut self, rhs: i8)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<i16> for FastFixed<i8, FRAC>

where i8: PromoteMul<i16> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i8 as PromoteMul<i16>>::Output: FastInt, i16: Zero + PartialOrd + NumCast + Copy, FastFixed<i8, FRAC>: Mul<i16, Output = FastFixed<<i8 as PromoteMul<i16>>::Output, FRAC>>,

fn mul_assign(&mut self, rhs: i16)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<i16> for FastFixed<i16, FRAC>

where i16: PromoteMul<i16> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i16 as PromoteMul<i16>>::Output: FastInt, FastFixed<i16, FRAC>: Mul<i16, Output = FastFixed<<i16 as PromoteMul<i16>>::Output, FRAC>>,

fn mul_assign(&mut self, rhs: i16)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<i16> for FastFixed<i32, FRAC>

where i32: PromoteMul<i16> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i32 as PromoteMul<i16>>::Output: FastInt, i16: Zero + PartialOrd + NumCast + Copy, FastFixed<i32, FRAC>: Mul<i16, Output = FastFixed<<i32 as PromoteMul<i16>>::Output, FRAC>>,

fn mul_assign(&mut self, rhs: i16)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<i16> for FastFixed<i64, FRAC>

where i64: PromoteMul<i16> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i64 as PromoteMul<i16>>::Output: FastInt, i16: Zero + PartialOrd + NumCast + Copy, FastFixed<i64, FRAC>: Mul<i16, Output = FastFixed<<i64 as PromoteMul<i16>>::Output, FRAC>>,

fn mul_assign(&mut self, rhs: i16)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<i16> for FastFixed<u8, FRAC>

where u8: PromoteMul<i16> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u8 as PromoteMul<i16>>::Output: FastInt, i16: Zero + PartialOrd + NumCast + Copy, FastFixed<u8, FRAC>: Mul<i16, Output = FastFixed<<u8 as PromoteMul<i16>>::Output, FRAC>>,

fn mul_assign(&mut self, rhs: i16)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<i16> for FastFixed<u16, FRAC>

where u16: PromoteMul<i16> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u16 as PromoteMul<i16>>::Output: FastInt, i16: Zero + PartialOrd + NumCast + Copy, FastFixed<u16, FRAC>: Mul<i16, Output = FastFixed<<u16 as PromoteMul<i16>>::Output, FRAC>>,

fn mul_assign(&mut self, rhs: i16)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<i16> for FastFixed<u32, FRAC>

where u32: PromoteMul<i16> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u32 as PromoteMul<i16>>::Output: FastInt, i16: Zero + PartialOrd + NumCast + Copy, FastFixed<u32, FRAC>: Mul<i16, Output = FastFixed<<u32 as PromoteMul<i16>>::Output, FRAC>>,

fn mul_assign(&mut self, rhs: i16)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<i16> for FastFixed<u64, FRAC>

where u64: PromoteMul<i16> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u64 as PromoteMul<i16>>::Output: FastInt, i16: Zero + PartialOrd + NumCast + Copy, FastFixed<u64, FRAC>: Mul<i16, Output = FastFixed<<u64 as PromoteMul<i16>>::Output, FRAC>>,

fn mul_assign(&mut self, rhs: i16)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<i32> for FastFixed<i8, FRAC>

where i8: PromoteMul<i32> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i8 as PromoteMul<i32>>::Output: FastInt, i32: Zero + PartialOrd + NumCast + Copy, FastFixed<i8, FRAC>: Mul<i32, Output = FastFixed<<i8 as PromoteMul<i32>>::Output, FRAC>>,

fn mul_assign(&mut self, rhs: i32)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<i32> for FastFixed<i16, FRAC>

where i16: PromoteMul<i32> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i16 as PromoteMul<i32>>::Output: FastInt, i32: Zero + PartialOrd + NumCast + Copy, FastFixed<i16, FRAC>: Mul<i32, Output = FastFixed<<i16 as PromoteMul<i32>>::Output, FRAC>>,

fn mul_assign(&mut self, rhs: i32)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<i32> for FastFixed<i32, FRAC>

where i32: PromoteMul<i32> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i32 as PromoteMul<i32>>::Output: FastInt, FastFixed<i32, FRAC>: Mul<i32, Output = FastFixed<<i32 as PromoteMul<i32>>::Output, FRAC>>,

fn mul_assign(&mut self, rhs: i32)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<i32> for FastFixed<i64, FRAC>

where i64: PromoteMul<i32> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i64 as PromoteMul<i32>>::Output: FastInt, i32: Zero + PartialOrd + NumCast + Copy, FastFixed<i64, FRAC>: Mul<i32, Output = FastFixed<<i64 as PromoteMul<i32>>::Output, FRAC>>,

fn mul_assign(&mut self, rhs: i32)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<i32> for FastFixed<u8, FRAC>

where u8: PromoteMul<i32> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u8 as PromoteMul<i32>>::Output: FastInt, i32: Zero + PartialOrd + NumCast + Copy, FastFixed<u8, FRAC>: Mul<i32, Output = FastFixed<<u8 as PromoteMul<i32>>::Output, FRAC>>,

fn mul_assign(&mut self, rhs: i32)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<i32> for FastFixed<u16, FRAC>

where u16: PromoteMul<i32> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u16 as PromoteMul<i32>>::Output: FastInt, i32: Zero + PartialOrd + NumCast + Copy, FastFixed<u16, FRAC>: Mul<i32, Output = FastFixed<<u16 as PromoteMul<i32>>::Output, FRAC>>,

fn mul_assign(&mut self, rhs: i32)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<i32> for FastFixed<u32, FRAC>

where u32: PromoteMul<i32> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u32 as PromoteMul<i32>>::Output: FastInt, i32: Zero + PartialOrd + NumCast + Copy, FastFixed<u32, FRAC>: Mul<i32, Output = FastFixed<<u32 as PromoteMul<i32>>::Output, FRAC>>,

fn mul_assign(&mut self, rhs: i32)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<i32> for FastFixed<u64, FRAC>

where u64: PromoteMul<i32> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u64 as PromoteMul<i32>>::Output: FastInt, i32: Zero + PartialOrd + NumCast + Copy, FastFixed<u64, FRAC>: Mul<i32, Output = FastFixed<<u64 as PromoteMul<i32>>::Output, FRAC>>,

fn mul_assign(&mut self, rhs: i32)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<i64> for FastFixed<i8, FRAC>

where i8: PromoteMul<i64> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i8 as PromoteMul<i64>>::Output: FastInt, i64: Zero + PartialOrd + NumCast + Copy, FastFixed<i8, FRAC>: Mul<i64, Output = FastFixed<<i8 as PromoteMul<i64>>::Output, FRAC>>,

fn mul_assign(&mut self, rhs: i64)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<i64> for FastFixed<i16, FRAC>

where i16: PromoteMul<i64> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i16 as PromoteMul<i64>>::Output: FastInt, i64: Zero + PartialOrd + NumCast + Copy, FastFixed<i16, FRAC>: Mul<i64, Output = FastFixed<<i16 as PromoteMul<i64>>::Output, FRAC>>,

fn mul_assign(&mut self, rhs: i64)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<i64> for FastFixed<i32, FRAC>

where i32: PromoteMul<i64> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i32 as PromoteMul<i64>>::Output: FastInt, i64: Zero + PartialOrd + NumCast + Copy, FastFixed<i32, FRAC>: Mul<i64, Output = FastFixed<<i32 as PromoteMul<i64>>::Output, FRAC>>,

fn mul_assign(&mut self, rhs: i64)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<i64> for FastFixed<i64, FRAC>

where i64: PromoteMul<i64> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i64 as PromoteMul<i64>>::Output: FastInt, FastFixed<i64, FRAC>: Mul<i64, Output = FastFixed<<i64 as PromoteMul<i64>>::Output, FRAC>>,

fn mul_assign(&mut self, rhs: i64)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<i64> for FastFixed<u8, FRAC>

where u8: PromoteMul<i64> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u8 as PromoteMul<i64>>::Output: FastInt, i64: Zero + PartialOrd + NumCast + Copy, FastFixed<u8, FRAC>: Mul<i64, Output = FastFixed<<u8 as PromoteMul<i64>>::Output, FRAC>>,

fn mul_assign(&mut self, rhs: i64)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<i64> for FastFixed<u16, FRAC>

where u16: PromoteMul<i64> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u16 as PromoteMul<i64>>::Output: FastInt, i64: Zero + PartialOrd + NumCast + Copy, FastFixed<u16, FRAC>: Mul<i64, Output = FastFixed<<u16 as PromoteMul<i64>>::Output, FRAC>>,

fn mul_assign(&mut self, rhs: i64)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<i64> for FastFixed<u32, FRAC>

where u32: PromoteMul<i64> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u32 as PromoteMul<i64>>::Output: FastInt, i64: Zero + PartialOrd + NumCast + Copy, FastFixed<u32, FRAC>: Mul<i64, Output = FastFixed<<u32 as PromoteMul<i64>>::Output, FRAC>>,

fn mul_assign(&mut self, rhs: i64)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<i64> for FastFixed<u64, FRAC>

where u64: PromoteMul<i64> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u64 as PromoteMul<i64>>::Output: FastInt, i64: Zero + PartialOrd + NumCast + Copy, FastFixed<u64, FRAC>: Mul<i64, Output = FastFixed<<u64 as PromoteMul<i64>>::Output, FRAC>>,

fn mul_assign(&mut self, rhs: i64)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<u8> for FastFixed<u8, FRAC>

where u8: PromoteMul<u8> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u8 as PromoteMul<u8>>::Output: FastInt, FastFixed<u8, FRAC>: Mul<u8, Output = FastFixed<<u8 as PromoteMul<u8>>::Output, FRAC>>,

fn mul_assign(&mut self, rhs: u8)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<u8> for FastFixed<u16, FRAC>

where u16: PromoteMul<u8> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u16 as PromoteMul<u8>>::Output: FastInt, u8: Zero + PartialOrd + NumCast + Copy, FastFixed<u16, FRAC>: Mul<u8, Output = FastFixed<<u16 as PromoteMul<u8>>::Output, FRAC>>,

fn mul_assign(&mut self, rhs: u8)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<u8> for FastFixed<u32, FRAC>

where u32: PromoteMul<u8> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u32 as PromoteMul<u8>>::Output: FastInt, u8: Zero + PartialOrd + NumCast + Copy, FastFixed<u32, FRAC>: Mul<u8, Output = FastFixed<<u32 as PromoteMul<u8>>::Output, FRAC>>,

fn mul_assign(&mut self, rhs: u8)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<u8> for FastFixed<u64, FRAC>

where u64: PromoteMul<u8> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u64 as PromoteMul<u8>>::Output: FastInt, u8: Zero + PartialOrd + NumCast + Copy, FastFixed<u64, FRAC>: Mul<u8, Output = FastFixed<<u64 as PromoteMul<u8>>::Output, FRAC>>,

fn mul_assign(&mut self, rhs: u8)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<u8> for FastFixed<i8, FRAC>

where i8: PromoteMul<u8> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i8 as PromoteMul<u8>>::Output: FastInt, u8: Zero + PartialOrd + NumCast + Copy, FastFixed<i8, FRAC>: Mul<u8, Output = FastFixed<<i8 as PromoteMul<u8>>::Output, FRAC>>,

fn mul_assign(&mut self, rhs: u8)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<u8> for FastFixed<i16, FRAC>

where i16: PromoteMul<u8> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i16 as PromoteMul<u8>>::Output: FastInt, u8: Zero + PartialOrd + NumCast + Copy, FastFixed<i16, FRAC>: Mul<u8, Output = FastFixed<<i16 as PromoteMul<u8>>::Output, FRAC>>,

fn mul_assign(&mut self, rhs: u8)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<u8> for FastFixed<i32, FRAC>

where i32: PromoteMul<u8> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i32 as PromoteMul<u8>>::Output: FastInt, u8: Zero + PartialOrd + NumCast + Copy, FastFixed<i32, FRAC>: Mul<u8, Output = FastFixed<<i32 as PromoteMul<u8>>::Output, FRAC>>,

fn mul_assign(&mut self, rhs: u8)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<u8> for FastFixed<i64, FRAC>

where i64: PromoteMul<u8> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i64 as PromoteMul<u8>>::Output: FastInt, u8: Zero + PartialOrd + NumCast + Copy, FastFixed<i64, FRAC>: Mul<u8, Output = FastFixed<<i64 as PromoteMul<u8>>::Output, FRAC>>,

fn mul_assign(&mut self, rhs: u8)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<u16> for FastFixed<u8, FRAC>

where u8: PromoteMul<u16> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u8 as PromoteMul<u16>>::Output: FastInt, u16: Zero + PartialOrd + NumCast + Copy, FastFixed<u8, FRAC>: Mul<u16, Output = FastFixed<<u8 as PromoteMul<u16>>::Output, FRAC>>,

fn mul_assign(&mut self, rhs: u16)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<u16> for FastFixed<u16, FRAC>

where u16: PromoteMul<u16> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u16 as PromoteMul<u16>>::Output: FastInt, FastFixed<u16, FRAC>: Mul<u16, Output = FastFixed<<u16 as PromoteMul<u16>>::Output, FRAC>>,

fn mul_assign(&mut self, rhs: u16)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<u16> for FastFixed<u32, FRAC>

where u32: PromoteMul<u16> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u32 as PromoteMul<u16>>::Output: FastInt, u16: Zero + PartialOrd + NumCast + Copy, FastFixed<u32, FRAC>: Mul<u16, Output = FastFixed<<u32 as PromoteMul<u16>>::Output, FRAC>>,

fn mul_assign(&mut self, rhs: u16)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<u16> for FastFixed<u64, FRAC>

where u64: PromoteMul<u16> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u64 as PromoteMul<u16>>::Output: FastInt, u16: Zero + PartialOrd + NumCast + Copy, FastFixed<u64, FRAC>: Mul<u16, Output = FastFixed<<u64 as PromoteMul<u16>>::Output, FRAC>>,

fn mul_assign(&mut self, rhs: u16)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<u16> for FastFixed<i8, FRAC>

where i8: PromoteMul<u16> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i8 as PromoteMul<u16>>::Output: FastInt, u16: Zero + PartialOrd + NumCast + Copy, FastFixed<i8, FRAC>: Mul<u16, Output = FastFixed<<i8 as PromoteMul<u16>>::Output, FRAC>>,

fn mul_assign(&mut self, rhs: u16)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<u16> for FastFixed<i16, FRAC>

where i16: PromoteMul<u16> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i16 as PromoteMul<u16>>::Output: FastInt, u16: Zero + PartialOrd + NumCast + Copy, FastFixed<i16, FRAC>: Mul<u16, Output = FastFixed<<i16 as PromoteMul<u16>>::Output, FRAC>>,

fn mul_assign(&mut self, rhs: u16)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<u16> for FastFixed<i32, FRAC>

where i32: PromoteMul<u16> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i32 as PromoteMul<u16>>::Output: FastInt, u16: Zero + PartialOrd + NumCast + Copy, FastFixed<i32, FRAC>: Mul<u16, Output = FastFixed<<i32 as PromoteMul<u16>>::Output, FRAC>>,

fn mul_assign(&mut self, rhs: u16)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<u16> for FastFixed<i64, FRAC>

where i64: PromoteMul<u16> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i64 as PromoteMul<u16>>::Output: FastInt, u16: Zero + PartialOrd + NumCast + Copy, FastFixed<i64, FRAC>: Mul<u16, Output = FastFixed<<i64 as PromoteMul<u16>>::Output, FRAC>>,

fn mul_assign(&mut self, rhs: u16)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<u32> for FastFixed<u8, FRAC>

where u8: PromoteMul<u32> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u8 as PromoteMul<u32>>::Output: FastInt, u32: Zero + PartialOrd + NumCast + Copy, FastFixed<u8, FRAC>: Mul<u32, Output = FastFixed<<u8 as PromoteMul<u32>>::Output, FRAC>>,

fn mul_assign(&mut self, rhs: u32)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<u32> for FastFixed<u16, FRAC>

where u16: PromoteMul<u32> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u16 as PromoteMul<u32>>::Output: FastInt, u32: Zero + PartialOrd + NumCast + Copy, FastFixed<u16, FRAC>: Mul<u32, Output = FastFixed<<u16 as PromoteMul<u32>>::Output, FRAC>>,

fn mul_assign(&mut self, rhs: u32)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<u32> for FastFixed<u32, FRAC>

where u32: PromoteMul<u32> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u32 as PromoteMul<u32>>::Output: FastInt, FastFixed<u32, FRAC>: Mul<u32, Output = FastFixed<<u32 as PromoteMul<u32>>::Output, FRAC>>,

fn mul_assign(&mut self, rhs: u32)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<u32> for FastFixed<u64, FRAC>

where u64: PromoteMul<u32> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u64 as PromoteMul<u32>>::Output: FastInt, u32: Zero + PartialOrd + NumCast + Copy, FastFixed<u64, FRAC>: Mul<u32, Output = FastFixed<<u64 as PromoteMul<u32>>::Output, FRAC>>,

fn mul_assign(&mut self, rhs: u32)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<u32> for FastFixed<i8, FRAC>

where i8: PromoteMul<u32> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i8 as PromoteMul<u32>>::Output: FastInt, u32: Zero + PartialOrd + NumCast + Copy, FastFixed<i8, FRAC>: Mul<u32, Output = FastFixed<<i8 as PromoteMul<u32>>::Output, FRAC>>,

fn mul_assign(&mut self, rhs: u32)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<u32> for FastFixed<i16, FRAC>

where i16: PromoteMul<u32> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i16 as PromoteMul<u32>>::Output: FastInt, u32: Zero + PartialOrd + NumCast + Copy, FastFixed<i16, FRAC>: Mul<u32, Output = FastFixed<<i16 as PromoteMul<u32>>::Output, FRAC>>,

fn mul_assign(&mut self, rhs: u32)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<u32> for FastFixed<i32, FRAC>

where i32: PromoteMul<u32> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i32 as PromoteMul<u32>>::Output: FastInt, u32: Zero + PartialOrd + NumCast + Copy, FastFixed<i32, FRAC>: Mul<u32, Output = FastFixed<<i32 as PromoteMul<u32>>::Output, FRAC>>,

fn mul_assign(&mut self, rhs: u32)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<u32> for FastFixed<i64, FRAC>

where i64: PromoteMul<u32> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i64 as PromoteMul<u32>>::Output: FastInt, u32: Zero + PartialOrd + NumCast + Copy, FastFixed<i64, FRAC>: Mul<u32, Output = FastFixed<<i64 as PromoteMul<u32>>::Output, FRAC>>,

fn mul_assign(&mut self, rhs: u32)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<u64> for FastFixed<u8, FRAC>

where u8: PromoteMul<u64> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u8 as PromoteMul<u64>>::Output: FastInt, u64: Zero + PartialOrd + NumCast + Copy, FastFixed<u8, FRAC>: Mul<u64, Output = FastFixed<<u8 as PromoteMul<u64>>::Output, FRAC>>,

fn mul_assign(&mut self, rhs: u64)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<u64> for FastFixed<u16, FRAC>

where u16: PromoteMul<u64> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u16 as PromoteMul<u64>>::Output: FastInt, u64: Zero + PartialOrd + NumCast + Copy, FastFixed<u16, FRAC>: Mul<u64, Output = FastFixed<<u16 as PromoteMul<u64>>::Output, FRAC>>,

fn mul_assign(&mut self, rhs: u64)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<u64> for FastFixed<u32, FRAC>

where u32: PromoteMul<u64> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u32 as PromoteMul<u64>>::Output: FastInt, u64: Zero + PartialOrd + NumCast + Copy, FastFixed<u32, FRAC>: Mul<u64, Output = FastFixed<<u32 as PromoteMul<u64>>::Output, FRAC>>,

fn mul_assign(&mut self, rhs: u64)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<u64> for FastFixed<u64, FRAC>

where u64: PromoteMul<u64> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u64 as PromoteMul<u64>>::Output: FastInt, FastFixed<u64, FRAC>: Mul<u64, Output = FastFixed<<u64 as PromoteMul<u64>>::Output, FRAC>>,

fn mul_assign(&mut self, rhs: u64)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<u64> for FastFixed<i8, FRAC>

where i8: PromoteMul<u64> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i8 as PromoteMul<u64>>::Output: FastInt, u64: Zero + PartialOrd + NumCast + Copy, FastFixed<i8, FRAC>: Mul<u64, Output = FastFixed<<i8 as PromoteMul<u64>>::Output, FRAC>>,

fn mul_assign(&mut self, rhs: u64)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<u64> for FastFixed<i16, FRAC>

where i16: PromoteMul<u64> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i16 as PromoteMul<u64>>::Output: FastInt, u64: Zero + PartialOrd + NumCast + Copy, FastFixed<i16, FRAC>: Mul<u64, Output = FastFixed<<i16 as PromoteMul<u64>>::Output, FRAC>>,

fn mul_assign(&mut self, rhs: u64)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<u64> for FastFixed<i32, FRAC>

where i32: PromoteMul<u64> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i32 as PromoteMul<u64>>::Output: FastInt, u64: Zero + PartialOrd + NumCast + Copy, FastFixed<i32, FRAC>: Mul<u64, Output = FastFixed<<i32 as PromoteMul<u64>>::Output, FRAC>>,

fn mul_assign(&mut self, rhs: u64)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<u64> for FastFixed<i64, FRAC>

where i64: PromoteMul<u64> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i64 as PromoteMul<u64>>::Output: FastInt, u64: Zero + PartialOrd + NumCast + Copy, FastFixed<i64, FRAC>: Mul<u64, Output = FastFixed<<i64 as PromoteMul<u64>>::Output, FRAC>>,

fn mul_assign(&mut self, rhs: u64)

Performs the *= operation.

impl<I, const FRAC: usize> Neg for FastFixed<I, FRAC>

where I: Signed + Bounded + Zero + PartialOrd + NumCast + Copy + FastInt,

type Output = FastFixed<I, FRAC>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<I: Ord + Copy, const FRAC: usize> Ord for FastFixed<I, FRAC>

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.

fn clamp_to<R>(self, range: R) -> Self

where Self: Sized, R: ClampBounds<Self>,

🔬This is a nightly-only experimental API. (clamp_to)

Restrict a value to a certain range.

impl<I: PartialEq + Copy, const FRAC: usize> PartialEq for FastFixed<I, FRAC>

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

Equality operator ==.

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

Inequality operator !=.

impl<I, const FRAC: usize, E> PartialEq<E> for FastFixed<I, FRAC>

where I: Bounded + NumCast + PartialEq + Copy, E: FastExpression,

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

Equality operator ==.

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

Inequality operator !=.

impl<I, const FRAC: usize, L, R> PartialEq<FastFixed<I, FRAC>> for MulExpression<L, R>

where I: Bounded + NumCast + PartialEq + Copy, MulExpression<L, R>: FastExpression,

fn eq(&self, other: &FastFixed<I, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<I, const FRAC: usize, L, R> PartialEq<FastFixed<I, FRAC>> for SumExpression<L, R>

where I: Bounded + NumCast + PartialEq + Copy, SumExpression<L, R>: FastExpression,

fn eq(&self, other: &FastFixed<I, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<FastFixed<i8, FRAC>> for i8

where Fixed<i8, FRAC>: PartialEq<i8>,

fn eq(&self, other: &FastFixed<i8, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<FastFixed<i8, FRAC>> for i16

where Fixed<i8, FRAC>: PartialEq<i16>,

fn eq(&self, other: &FastFixed<i8, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<FastFixed<i8, FRAC>> for i32

where Fixed<i8, FRAC>: PartialEq<i32>,

fn eq(&self, other: &FastFixed<i8, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<FastFixed<i8, FRAC>> for i64

where Fixed<i8, FRAC>: PartialEq<i64>,

fn eq(&self, other: &FastFixed<i8, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<FastFixed<i8, FRAC>> for u8

where Fixed<i8, FRAC>: PartialEq<u8>,

fn eq(&self, other: &FastFixed<i8, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<FastFixed<i8, FRAC>> for u16

where Fixed<i8, FRAC>: PartialEq<u16>,

fn eq(&self, other: &FastFixed<i8, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<FastFixed<i8, FRAC>> for u32

where Fixed<i8, FRAC>: PartialEq<u32>,

fn eq(&self, other: &FastFixed<i8, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<FastFixed<i8, FRAC>> for u64

where Fixed<i8, FRAC>: PartialEq<u64>,

fn eq(&self, other: &FastFixed<i8, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<FastFixed<i16, FRAC>> for i8

where Fixed<i16, FRAC>: PartialEq<i8>,

fn eq(&self, other: &FastFixed<i16, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<FastFixed<i16, FRAC>> for i16

where Fixed<i16, FRAC>: PartialEq<i16>,

fn eq(&self, other: &FastFixed<i16, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<FastFixed<i16, FRAC>> for i32

where Fixed<i16, FRAC>: PartialEq<i32>,

fn eq(&self, other: &FastFixed<i16, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<FastFixed<i16, FRAC>> for i64

where Fixed<i16, FRAC>: PartialEq<i64>,

fn eq(&self, other: &FastFixed<i16, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<FastFixed<i16, FRAC>> for u8

where Fixed<i16, FRAC>: PartialEq<u8>,

fn eq(&self, other: &FastFixed<i16, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<FastFixed<i16, FRAC>> for u16

where Fixed<i16, FRAC>: PartialEq<u16>,

fn eq(&self, other: &FastFixed<i16, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<FastFixed<i16, FRAC>> for u32

where Fixed<i16, FRAC>: PartialEq<u32>,

fn eq(&self, other: &FastFixed<i16, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<FastFixed<i16, FRAC>> for u64

where Fixed<i16, FRAC>: PartialEq<u64>,

fn eq(&self, other: &FastFixed<i16, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<FastFixed<i32, FRAC>> for i8

where Fixed<i32, FRAC>: PartialEq<i8>,

fn eq(&self, other: &FastFixed<i32, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<FastFixed<i32, FRAC>> for i16

where Fixed<i32, FRAC>: PartialEq<i16>,

fn eq(&self, other: &FastFixed<i32, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<FastFixed<i32, FRAC>> for i32

where Fixed<i32, FRAC>: PartialEq<i32>,

fn eq(&self, other: &FastFixed<i32, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<FastFixed<i32, FRAC>> for i64

where Fixed<i32, FRAC>: PartialEq<i64>,

fn eq(&self, other: &FastFixed<i32, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<FastFixed<i32, FRAC>> for u8

where Fixed<i32, FRAC>: PartialEq<u8>,

fn eq(&self, other: &FastFixed<i32, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<FastFixed<i32, FRAC>> for u16

where Fixed<i32, FRAC>: PartialEq<u16>,

fn eq(&self, other: &FastFixed<i32, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<FastFixed<i32, FRAC>> for u32

where Fixed<i32, FRAC>: PartialEq<u32>,

fn eq(&self, other: &FastFixed<i32, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<FastFixed<i32, FRAC>> for u64

where Fixed<i32, FRAC>: PartialEq<u64>,

fn eq(&self, other: &FastFixed<i32, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<FastFixed<i64, FRAC>> for i8

where Fixed<i64, FRAC>: PartialEq<i8>,

fn eq(&self, other: &FastFixed<i64, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<FastFixed<i64, FRAC>> for i16

where Fixed<i64, FRAC>: PartialEq<i16>,

fn eq(&self, other: &FastFixed<i64, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<FastFixed<i64, FRAC>> for i32

where Fixed<i64, FRAC>: PartialEq<i32>,

fn eq(&self, other: &FastFixed<i64, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<FastFixed<i64, FRAC>> for i64

where Fixed<i64, FRAC>: PartialEq<i64>,

fn eq(&self, other: &FastFixed<i64, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<FastFixed<i64, FRAC>> for u8

where Fixed<i64, FRAC>: PartialEq<u8>,

fn eq(&self, other: &FastFixed<i64, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<FastFixed<i64, FRAC>> for u16

where Fixed<i64, FRAC>: PartialEq<u16>,

fn eq(&self, other: &FastFixed<i64, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<FastFixed<i64, FRAC>> for u32

where Fixed<i64, FRAC>: PartialEq<u32>,

fn eq(&self, other: &FastFixed<i64, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<FastFixed<i64, FRAC>> for u64

where Fixed<i64, FRAC>: PartialEq<u64>,

fn eq(&self, other: &FastFixed<i64, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<FastFixed<u8, FRAC>> for u8

where Fixed<u8, FRAC>: PartialEq<u8>,

fn eq(&self, other: &FastFixed<u8, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<FastFixed<u8, FRAC>> for u16

where Fixed<u8, FRAC>: PartialEq<u16>,

fn eq(&self, other: &FastFixed<u8, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<FastFixed<u8, FRAC>> for u32

where Fixed<u8, FRAC>: PartialEq<u32>,

fn eq(&self, other: &FastFixed<u8, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<FastFixed<u8, FRAC>> for u64

where Fixed<u8, FRAC>: PartialEq<u64>,

fn eq(&self, other: &FastFixed<u8, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<FastFixed<u8, FRAC>> for i8

where Fixed<u8, FRAC>: PartialEq<i8>,

fn eq(&self, other: &FastFixed<u8, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<FastFixed<u8, FRAC>> for i16

where Fixed<u8, FRAC>: PartialEq<i16>,

fn eq(&self, other: &FastFixed<u8, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<FastFixed<u8, FRAC>> for i32

where Fixed<u8, FRAC>: PartialEq<i32>,

fn eq(&self, other: &FastFixed<u8, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<FastFixed<u8, FRAC>> for i64

where Fixed<u8, FRAC>: PartialEq<i64>,

fn eq(&self, other: &FastFixed<u8, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<FastFixed<u16, FRAC>> for u8

where Fixed<u16, FRAC>: PartialEq<u8>,

fn eq(&self, other: &FastFixed<u16, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<FastFixed<u16, FRAC>> for u16

where Fixed<u16, FRAC>: PartialEq<u16>,

fn eq(&self, other: &FastFixed<u16, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<FastFixed<u16, FRAC>> for u32

where Fixed<u16, FRAC>: PartialEq<u32>,

fn eq(&self, other: &FastFixed<u16, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<FastFixed<u16, FRAC>> for u64

where Fixed<u16, FRAC>: PartialEq<u64>,

fn eq(&self, other: &FastFixed<u16, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<FastFixed<u16, FRAC>> for i8

where Fixed<u16, FRAC>: PartialEq<i8>,

fn eq(&self, other: &FastFixed<u16, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<FastFixed<u16, FRAC>> for i16

where Fixed<u16, FRAC>: PartialEq<i16>,

fn eq(&self, other: &FastFixed<u16, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<FastFixed<u16, FRAC>> for i32

where Fixed<u16, FRAC>: PartialEq<i32>,

fn eq(&self, other: &FastFixed<u16, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<FastFixed<u16, FRAC>> for i64

where Fixed<u16, FRAC>: PartialEq<i64>,

fn eq(&self, other: &FastFixed<u16, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<FastFixed<u32, FRAC>> for u8

where Fixed<u32, FRAC>: PartialEq<u8>,

fn eq(&self, other: &FastFixed<u32, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<FastFixed<u32, FRAC>> for u16

where Fixed<u32, FRAC>: PartialEq<u16>,

fn eq(&self, other: &FastFixed<u32, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<FastFixed<u32, FRAC>> for u32

where Fixed<u32, FRAC>: PartialEq<u32>,

fn eq(&self, other: &FastFixed<u32, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<FastFixed<u32, FRAC>> for u64

where Fixed<u32, FRAC>: PartialEq<u64>,

fn eq(&self, other: &FastFixed<u32, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<FastFixed<u32, FRAC>> for i8

where Fixed<u32, FRAC>: PartialEq<i8>,

fn eq(&self, other: &FastFixed<u32, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<FastFixed<u32, FRAC>> for i16

where Fixed<u32, FRAC>: PartialEq<i16>,

fn eq(&self, other: &FastFixed<u32, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<FastFixed<u32, FRAC>> for i32

where Fixed<u32, FRAC>: PartialEq<i32>,

fn eq(&self, other: &FastFixed<u32, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<FastFixed<u32, FRAC>> for i64

where Fixed<u32, FRAC>: PartialEq<i64>,

fn eq(&self, other: &FastFixed<u32, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<FastFixed<u64, FRAC>> for u8

where Fixed<u64, FRAC>: PartialEq<u8>,

fn eq(&self, other: &FastFixed<u64, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<FastFixed<u64, FRAC>> for u16

where Fixed<u64, FRAC>: PartialEq<u16>,

fn eq(&self, other: &FastFixed<u64, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<FastFixed<u64, FRAC>> for u32

where Fixed<u64, FRAC>: PartialEq<u32>,

fn eq(&self, other: &FastFixed<u64, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<FastFixed<u64, FRAC>> for u64

where Fixed<u64, FRAC>: PartialEq<u64>,

fn eq(&self, other: &FastFixed<u64, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<FastFixed<u64, FRAC>> for i8

where Fixed<u64, FRAC>: PartialEq<i8>,

fn eq(&self, other: &FastFixed<u64, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<FastFixed<u64, FRAC>> for i16

where Fixed<u64, FRAC>: PartialEq<i16>,

fn eq(&self, other: &FastFixed<u64, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<FastFixed<u64, FRAC>> for i32

where Fixed<u64, FRAC>: PartialEq<i32>,

fn eq(&self, other: &FastFixed<u64, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<FastFixed<u64, FRAC>> for i64

where Fixed<u64, FRAC>: PartialEq<i64>,

fn eq(&self, other: &FastFixed<u64, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<i8> for FastFixed<i8, FRAC>

where Fixed<i8, FRAC>: PartialEq<i8>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<i8> for FastFixed<i16, FRAC>

where Fixed<i16, FRAC>: PartialEq<i8>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<i8> for FastFixed<i32, FRAC>

where Fixed<i32, FRAC>: PartialEq<i8>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<i8> for FastFixed<i64, FRAC>

where Fixed<i64, FRAC>: PartialEq<i8>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<i8> for FastFixed<u8, FRAC>

where Fixed<u8, FRAC>: PartialEq<i8>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<i8> for FastFixed<u16, FRAC>

where Fixed<u16, FRAC>: PartialEq<i8>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<i8> for FastFixed<u32, FRAC>

where Fixed<u32, FRAC>: PartialEq<i8>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<i8> for FastFixed<u64, FRAC>

where Fixed<u64, FRAC>: PartialEq<i8>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<i16> for FastFixed<i8, FRAC>

where Fixed<i8, FRAC>: PartialEq<i16>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<i16> for FastFixed<i16, FRAC>

where Fixed<i16, FRAC>: PartialEq<i16>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<i16> for FastFixed<i32, FRAC>

where Fixed<i32, FRAC>: PartialEq<i16>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<i16> for FastFixed<i64, FRAC>

where Fixed<i64, FRAC>: PartialEq<i16>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<i16> for FastFixed<u8, FRAC>

where Fixed<u8, FRAC>: PartialEq<i16>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<i16> for FastFixed<u16, FRAC>

where Fixed<u16, FRAC>: PartialEq<i16>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<i16> for FastFixed<u32, FRAC>

where Fixed<u32, FRAC>: PartialEq<i16>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<i16> for FastFixed<u64, FRAC>

where Fixed<u64, FRAC>: PartialEq<i16>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<i32> for FastFixed<i8, FRAC>

where Fixed<i8, FRAC>: PartialEq<i32>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<i32> for FastFixed<i16, FRAC>

where Fixed<i16, FRAC>: PartialEq<i32>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<i32> for FastFixed<i32, FRAC>

where Fixed<i32, FRAC>: PartialEq<i32>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<i32> for FastFixed<i64, FRAC>

where Fixed<i64, FRAC>: PartialEq<i32>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<i32> for FastFixed<u8, FRAC>

where Fixed<u8, FRAC>: PartialEq<i32>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<i32> for FastFixed<u16, FRAC>

where Fixed<u16, FRAC>: PartialEq<i32>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<i32> for FastFixed<u32, FRAC>

where Fixed<u32, FRAC>: PartialEq<i32>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<i32> for FastFixed<u64, FRAC>

where Fixed<u64, FRAC>: PartialEq<i32>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<i64> for FastFixed<i8, FRAC>

where Fixed<i8, FRAC>: PartialEq<i64>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<i64> for FastFixed<i16, FRAC>

where Fixed<i16, FRAC>: PartialEq<i64>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<i64> for FastFixed<i32, FRAC>

where Fixed<i32, FRAC>: PartialEq<i64>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<i64> for FastFixed<i64, FRAC>

where Fixed<i64, FRAC>: PartialEq<i64>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<i64> for FastFixed<u8, FRAC>

where Fixed<u8, FRAC>: PartialEq<i64>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<i64> for FastFixed<u16, FRAC>

where Fixed<u16, FRAC>: PartialEq<i64>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<i64> for FastFixed<u32, FRAC>

where Fixed<u32, FRAC>: PartialEq<i64>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<i64> for FastFixed<u64, FRAC>

where Fixed<u64, FRAC>: PartialEq<i64>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<u8> for FastFixed<u8, FRAC>

where Fixed<u8, FRAC>: PartialEq<u8>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<u8> for FastFixed<u16, FRAC>

where Fixed<u16, FRAC>: PartialEq<u8>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<u8> for FastFixed<u32, FRAC>

where Fixed<u32, FRAC>: PartialEq<u8>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<u8> for FastFixed<u64, FRAC>

where Fixed<u64, FRAC>: PartialEq<u8>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<u8> for FastFixed<i8, FRAC>

where Fixed<i8, FRAC>: PartialEq<u8>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<u8> for FastFixed<i16, FRAC>

where Fixed<i16, FRAC>: PartialEq<u8>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<u8> for FastFixed<i32, FRAC>

where Fixed<i32, FRAC>: PartialEq<u8>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<u8> for FastFixed<i64, FRAC>

where Fixed<i64, FRAC>: PartialEq<u8>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<u16> for FastFixed<u8, FRAC>

where Fixed<u8, FRAC>: PartialEq<u16>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<u16> for FastFixed<u16, FRAC>

where Fixed<u16, FRAC>: PartialEq<u16>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<u16> for FastFixed<u32, FRAC>

where Fixed<u32, FRAC>: PartialEq<u16>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<u16> for FastFixed<u64, FRAC>

where Fixed<u64, FRAC>: PartialEq<u16>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<u16> for FastFixed<i8, FRAC>

where Fixed<i8, FRAC>: PartialEq<u16>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<u16> for FastFixed<i16, FRAC>

where Fixed<i16, FRAC>: PartialEq<u16>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<u16> for FastFixed<i32, FRAC>

where Fixed<i32, FRAC>: PartialEq<u16>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<u16> for FastFixed<i64, FRAC>

where Fixed<i64, FRAC>: PartialEq<u16>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<u32> for FastFixed<u8, FRAC>

where Fixed<u8, FRAC>: PartialEq<u32>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<u32> for FastFixed<u16, FRAC>

where Fixed<u16, FRAC>: PartialEq<u32>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<u32> for FastFixed<u32, FRAC>

where Fixed<u32, FRAC>: PartialEq<u32>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<u32> for FastFixed<u64, FRAC>

where Fixed<u64, FRAC>: PartialEq<u32>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<u32> for FastFixed<i8, FRAC>

where Fixed<i8, FRAC>: PartialEq<u32>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<u32> for FastFixed<i16, FRAC>

where Fixed<i16, FRAC>: PartialEq<u32>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<u32> for FastFixed<i32, FRAC>

where Fixed<i32, FRAC>: PartialEq<u32>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<u32> for FastFixed<i64, FRAC>

where Fixed<i64, FRAC>: PartialEq<u32>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<u64> for FastFixed<u8, FRAC>

where Fixed<u8, FRAC>: PartialEq<u64>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<u64> for FastFixed<u16, FRAC>

where Fixed<u16, FRAC>: PartialEq<u64>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<u64> for FastFixed<u32, FRAC>

where Fixed<u32, FRAC>: PartialEq<u64>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<u64> for FastFixed<u64, FRAC>

where Fixed<u64, FRAC>: PartialEq<u64>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<u64> for FastFixed<i8, FRAC>

where Fixed<i8, FRAC>: PartialEq<u64>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<u64> for FastFixed<i16, FRAC>

where Fixed<i16, FRAC>: PartialEq<u64>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<u64> for FastFixed<i32, FRAC>

where Fixed<i32, FRAC>: PartialEq<u64>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<u64> for FastFixed<i64, FRAC>

where Fixed<i64, FRAC>: PartialEq<u64>,

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

Equality operator ==.

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

Inequality operator !=.

impl<I: PartialOrd + Copy, const FRAC: usize> PartialOrd for FastFixed<I, FRAC>

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<I, const FRAC: usize, E> PartialOrd<E> for FastFixed<I, FRAC>

where I: Bounded + NumCast + PartialOrd + Copy, E: FastExpression,

fn partial_cmp(&self, other: &E) -> 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<I, const FRAC: usize, L, R> PartialOrd<FastFixed<I, FRAC>> for MulExpression<L, R>

where I: Bounded + NumCast + PartialOrd + Copy, MulExpression<L, R>: FastExpression,

fn partial_cmp(&self, other: &FastFixed<I, FRAC>) -> 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<I, const FRAC: usize, L, R> PartialOrd<FastFixed<I, FRAC>> for SumExpression<L, R>

where I: Bounded + NumCast + PartialOrd + Copy, SumExpression<L, R>: FastExpression,

fn partial_cmp(&self, other: &FastFixed<I, FRAC>) -> 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<const FRAC: usize> PartialOrd<FastFixed<i8, FRAC>> for i8

where Fixed<i8, FRAC>: PartialOrd<i8>,

fn partial_cmp(&self, other: &FastFixed<i8, FRAC>) -> 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<const FRAC: usize> PartialOrd<FastFixed<i8, FRAC>> for i16

where Fixed<i8, FRAC>: PartialOrd<i16>,

fn partial_cmp(&self, other: &FastFixed<i8, FRAC>) -> 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<const FRAC: usize> PartialOrd<FastFixed<i8, FRAC>> for i32

where Fixed<i8, FRAC>: PartialOrd<i32>,

fn partial_cmp(&self, other: &FastFixed<i8, FRAC>) -> 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<const FRAC: usize> PartialOrd<FastFixed<i8, FRAC>> for i64

where Fixed<i8, FRAC>: PartialOrd<i64>,

fn partial_cmp(&self, other: &FastFixed<i8, FRAC>) -> 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<const FRAC: usize> PartialOrd<FastFixed<i8, FRAC>> for u8

where Fixed<i8, FRAC>: PartialOrd<u8>,

fn partial_cmp(&self, other: &FastFixed<i8, FRAC>) -> 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<const FRAC: usize> PartialOrd<FastFixed<i8, FRAC>> for u16

where Fixed<i8, FRAC>: PartialOrd<u16>,

fn partial_cmp(&self, other: &FastFixed<i8, FRAC>) -> 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<const FRAC: usize> PartialOrd<FastFixed<i8, FRAC>> for u32

where Fixed<i8, FRAC>: PartialOrd<u32>,

fn partial_cmp(&self, other: &FastFixed<i8, FRAC>) -> 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<const FRAC: usize> PartialOrd<FastFixed<i8, FRAC>> for u64

where Fixed<i8, FRAC>: PartialOrd<u64>,

fn partial_cmp(&self, other: &FastFixed<i8, FRAC>) -> 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<const FRAC: usize> PartialOrd<FastFixed<i16, FRAC>> for i8

where Fixed<i16, FRAC>: PartialOrd<i8>,

fn partial_cmp(&self, other: &FastFixed<i16, FRAC>) -> 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<const FRAC: usize> PartialOrd<FastFixed<i16, FRAC>> for i16

where Fixed<i16, FRAC>: PartialOrd<i16>,

fn partial_cmp(&self, other: &FastFixed<i16, FRAC>) -> 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<const FRAC: usize> PartialOrd<FastFixed<i16, FRAC>> for i32

where Fixed<i16, FRAC>: PartialOrd<i32>,

fn partial_cmp(&self, other: &FastFixed<i16, FRAC>) -> 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<const FRAC: usize> PartialOrd<FastFixed<i16, FRAC>> for i64

where Fixed<i16, FRAC>: PartialOrd<i64>,

fn partial_cmp(&self, other: &FastFixed<i16, FRAC>) -> 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<const FRAC: usize> PartialOrd<FastFixed<i16, FRAC>> for u8

where Fixed<i16, FRAC>: PartialOrd<u8>,

fn partial_cmp(&self, other: &FastFixed<i16, FRAC>) -> 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<const FRAC: usize> PartialOrd<FastFixed<i16, FRAC>> for u16

where Fixed<i16, FRAC>: PartialOrd<u16>,

fn partial_cmp(&self, other: &FastFixed<i16, FRAC>) -> 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<const FRAC: usize> PartialOrd<FastFixed<i16, FRAC>> for u32

where Fixed<i16, FRAC>: PartialOrd<u32>,

fn partial_cmp(&self, other: &FastFixed<i16, FRAC>) -> 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<const FRAC: usize> PartialOrd<FastFixed<i16, FRAC>> for u64

where Fixed<i16, FRAC>: PartialOrd<u64>,

fn partial_cmp(&self, other: &FastFixed<i16, FRAC>) -> 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<const FRAC: usize> PartialOrd<FastFixed<i32, FRAC>> for i8

where Fixed<i32, FRAC>: PartialOrd<i8>,

fn partial_cmp(&self, other: &FastFixed<i32, FRAC>) -> 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<const FRAC: usize> PartialOrd<FastFixed<i32, FRAC>> for i16

where Fixed<i32, FRAC>: PartialOrd<i16>,

fn partial_cmp(&self, other: &FastFixed<i32, FRAC>) -> 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<const FRAC: usize> PartialOrd<FastFixed<i32, FRAC>> for i32

where Fixed<i32, FRAC>: PartialOrd<i32>,

fn partial_cmp(&self, other: &FastFixed<i32, FRAC>) -> 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<const FRAC: usize> PartialOrd<FastFixed<i32, FRAC>> for i64

where Fixed<i32, FRAC>: PartialOrd<i64>,

fn partial_cmp(&self, other: &FastFixed<i32, FRAC>) -> 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<const FRAC: usize> PartialOrd<FastFixed<i32, FRAC>> for u8

where Fixed<i32, FRAC>: PartialOrd<u8>,

fn partial_cmp(&self, other: &FastFixed<i32, FRAC>) -> 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<const FRAC: usize> PartialOrd<FastFixed<i32, FRAC>> for u16

where Fixed<i32, FRAC>: PartialOrd<u16>,

fn partial_cmp(&self, other: &FastFixed<i32, FRAC>) -> 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<const FRAC: usize> PartialOrd<FastFixed<i32, FRAC>> for u32

where Fixed<i32, FRAC>: PartialOrd<u32>,

fn partial_cmp(&self, other: &FastFixed<i32, FRAC>) -> 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<const FRAC: usize> PartialOrd<FastFixed<i32, FRAC>> for u64

where Fixed<i32, FRAC>: PartialOrd<u64>,

fn partial_cmp(&self, other: &FastFixed<i32, FRAC>) -> 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<const FRAC: usize> PartialOrd<FastFixed<i64, FRAC>> for i8

where Fixed<i64, FRAC>: PartialOrd<i8>,

fn partial_cmp(&self, other: &FastFixed<i64, FRAC>) -> 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<const FRAC: usize> PartialOrd<FastFixed<i64, FRAC>> for i16

where Fixed<i64, FRAC>: PartialOrd<i16>,

fn partial_cmp(&self, other: &FastFixed<i64, FRAC>) -> 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<const FRAC: usize> PartialOrd<FastFixed<i64, FRAC>> for i32

where Fixed<i64, FRAC>: PartialOrd<i32>,

fn partial_cmp(&self, other: &FastFixed<i64, FRAC>) -> 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<const FRAC: usize> PartialOrd<FastFixed<i64, FRAC>> for i64

where Fixed<i64, FRAC>: PartialOrd<i64>,

fn partial_cmp(&self, other: &FastFixed<i64, FRAC>) -> 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<const FRAC: usize> PartialOrd<FastFixed<i64, FRAC>> for u8

where Fixed<i64, FRAC>: PartialOrd<u8>,

fn partial_cmp(&self, other: &FastFixed<i64, FRAC>) -> 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<const FRAC: usize> PartialOrd<FastFixed<i64, FRAC>> for u16

where Fixed<i64, FRAC>: PartialOrd<u16>,

fn partial_cmp(&self, other: &FastFixed<i64, FRAC>) -> 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<const FRAC: usize> PartialOrd<FastFixed<i64, FRAC>> for u32

where Fixed<i64, FRAC>: PartialOrd<u32>,

fn partial_cmp(&self, other: &FastFixed<i64, FRAC>) -> 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<const FRAC: usize> PartialOrd<FastFixed<i64, FRAC>> for u64

where Fixed<i64, FRAC>: PartialOrd<u64>,

fn partial_cmp(&self, other: &FastFixed<i64, FRAC>) -> 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<const FRAC: usize> PartialOrd<FastFixed<u8, FRAC>> for u8

where Fixed<u8, FRAC>: PartialOrd<u8>,

fn partial_cmp(&self, other: &FastFixed<u8, FRAC>) -> 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<const FRAC: usize> PartialOrd<FastFixed<u8, FRAC>> for u16

where Fixed<u8, FRAC>: PartialOrd<u16>,

fn partial_cmp(&self, other: &FastFixed<u8, FRAC>) -> 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<const FRAC: usize> PartialOrd<FastFixed<u8, FRAC>> for u32

where Fixed<u8, FRAC>: PartialOrd<u32>,

fn partial_cmp(&self, other: &FastFixed<u8, FRAC>) -> 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<const FRAC: usize> PartialOrd<FastFixed<u8, FRAC>> for u64

where Fixed<u8, FRAC>: PartialOrd<u64>,

fn partial_cmp(&self, other: &FastFixed<u8, FRAC>) -> 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<const FRAC: usize> PartialOrd<FastFixed<u8, FRAC>> for i8

where Fixed<u8, FRAC>: PartialOrd<i8>,

fn partial_cmp(&self, other: &FastFixed<u8, FRAC>) -> 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<const FRAC: usize> PartialOrd<FastFixed<u8, FRAC>> for i16

where Fixed<u8, FRAC>: PartialOrd<i16>,

fn partial_cmp(&self, other: &FastFixed<u8, FRAC>) -> 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<const FRAC: usize> PartialOrd<FastFixed<u8, FRAC>> for i32

where Fixed<u8, FRAC>: PartialOrd<i32>,

fn partial_cmp(&self, other: &FastFixed<u8, FRAC>) -> 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<const FRAC: usize> PartialOrd<FastFixed<u8, FRAC>> for i64

where Fixed<u8, FRAC>: PartialOrd<i64>,

fn partial_cmp(&self, other: &FastFixed<u8, FRAC>) -> 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<const FRAC: usize> PartialOrd<FastFixed<u16, FRAC>> for u8

where Fixed<u16, FRAC>: PartialOrd<u8>,

fn partial_cmp(&self, other: &FastFixed<u16, FRAC>) -> 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<const FRAC: usize> PartialOrd<FastFixed<u16, FRAC>> for u16

where Fixed<u16, FRAC>: PartialOrd<u16>,

fn partial_cmp(&self, other: &FastFixed<u16, FRAC>) -> 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<const FRAC: usize> PartialOrd<FastFixed<u16, FRAC>> for u32

where Fixed<u16, FRAC>: PartialOrd<u32>,

fn partial_cmp(&self, other: &FastFixed<u16, FRAC>) -> 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<const FRAC: usize> PartialOrd<FastFixed<u16, FRAC>> for u64

where Fixed<u16, FRAC>: PartialOrd<u64>,

fn partial_cmp(&self, other: &FastFixed<u16, FRAC>) -> 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<const FRAC: usize> PartialOrd<FastFixed<u16, FRAC>> for i8

where Fixed<u16, FRAC>: PartialOrd<i8>,

fn partial_cmp(&self, other: &FastFixed<u16, FRAC>) -> 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<const FRAC: usize> PartialOrd<FastFixed<u16, FRAC>> for i16

where Fixed<u16, FRAC>: PartialOrd<i16>,

fn partial_cmp(&self, other: &FastFixed<u16, FRAC>) -> 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<const FRAC: usize> PartialOrd<FastFixed<u16, FRAC>> for i32

where Fixed<u16, FRAC>: PartialOrd<i32>,

fn partial_cmp(&self, other: &FastFixed<u16, FRAC>) -> 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<const FRAC: usize> PartialOrd<FastFixed<u16, FRAC>> for i64

where Fixed<u16, FRAC>: PartialOrd<i64>,

fn partial_cmp(&self, other: &FastFixed<u16, FRAC>) -> 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<const FRAC: usize> PartialOrd<FastFixed<u32, FRAC>> for u8

where Fixed<u32, FRAC>: PartialOrd<u8>,

fn partial_cmp(&self, other: &FastFixed<u32, FRAC>) -> 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<const FRAC: usize> PartialOrd<FastFixed<u32, FRAC>> for u16

where Fixed<u32, FRAC>: PartialOrd<u16>,

fn partial_cmp(&self, other: &FastFixed<u32, FRAC>) -> 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<const FRAC: usize> PartialOrd<FastFixed<u32, FRAC>> for u32

where Fixed<u32, FRAC>: PartialOrd<u32>,

fn partial_cmp(&self, other: &FastFixed<u32, FRAC>) -> 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<const FRAC: usize> PartialOrd<FastFixed<u32, FRAC>> for u64

where Fixed<u32, FRAC>: PartialOrd<u64>,

fn partial_cmp(&self, other: &FastFixed<u32, FRAC>) -> 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<const FRAC: usize> PartialOrd<FastFixed<u32, FRAC>> for i8

where Fixed<u32, FRAC>: PartialOrd<i8>,

fn partial_cmp(&self, other: &FastFixed<u32, FRAC>) -> 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<const FRAC: usize> PartialOrd<FastFixed<u32, FRAC>> for i16

where Fixed<u32, FRAC>: PartialOrd<i16>,

fn partial_cmp(&self, other: &FastFixed<u32, FRAC>) -> 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<const FRAC: usize> PartialOrd<FastFixed<u32, FRAC>> for i32

where Fixed<u32, FRAC>: PartialOrd<i32>,

fn partial_cmp(&self, other: &FastFixed<u32, FRAC>) -> 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<const FRAC: usize> PartialOrd<FastFixed<u32, FRAC>> for i64

where Fixed<u32, FRAC>: PartialOrd<i64>,

fn partial_cmp(&self, other: &FastFixed<u32, FRAC>) -> 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<const FRAC: usize> PartialOrd<FastFixed<u64, FRAC>> for u8

where Fixed<u64, FRAC>: PartialOrd<u8>,

fn partial_cmp(&self, other: &FastFixed<u64, FRAC>) -> 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<const FRAC: usize> PartialOrd<FastFixed<u64, FRAC>> for u16

where Fixed<u64, FRAC>: PartialOrd<u16>,

fn partial_cmp(&self, other: &FastFixed<u64, FRAC>) -> 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<const FRAC: usize> PartialOrd<FastFixed<u64, FRAC>> for u32

where Fixed<u64, FRAC>: PartialOrd<u32>,

fn partial_cmp(&self, other: &FastFixed<u64, FRAC>) -> 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<const FRAC: usize> PartialOrd<FastFixed<u64, FRAC>> for u64

where Fixed<u64, FRAC>: PartialOrd<u64>,

fn partial_cmp(&self, other: &FastFixed<u64, FRAC>) -> 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<const FRAC: usize> PartialOrd<FastFixed<u64, FRAC>> for i8

where Fixed<u64, FRAC>: PartialOrd<i8>,

fn partial_cmp(&self, other: &FastFixed<u64, FRAC>) -> 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<const FRAC: usize> PartialOrd<FastFixed<u64, FRAC>> for i16

where Fixed<u64, FRAC>: PartialOrd<i16>,

fn partial_cmp(&self, other: &FastFixed<u64, FRAC>) -> 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<const FRAC: usize> PartialOrd<FastFixed<u64, FRAC>> for i32

where Fixed<u64, FRAC>: PartialOrd<i32>,

fn partial_cmp(&self, other: &FastFixed<u64, FRAC>) -> 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<const FRAC: usize> PartialOrd<FastFixed<u64, FRAC>> for i64

where Fixed<u64, FRAC>: PartialOrd<i64>,

fn partial_cmp(&self, other: &FastFixed<u64, FRAC>) -> 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<const FRAC: usize> PartialOrd<i8> for FastFixed<i8, FRAC>

where Fixed<i8, FRAC>: PartialOrd<i8>,

fn partial_cmp(&self, other: &i8) -> 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<const FRAC: usize> PartialOrd<i8> for FastFixed<i16, FRAC>

where Fixed<i16, FRAC>: PartialOrd<i8>,

fn partial_cmp(&self, other: &i8) -> 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<const FRAC: usize> PartialOrd<i8> for FastFixed<i32, FRAC>

where Fixed<i32, FRAC>: PartialOrd<i8>,

fn partial_cmp(&self, other: &i8) -> 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<const FRAC: usize> PartialOrd<i8> for FastFixed<i64, FRAC>

where Fixed<i64, FRAC>: PartialOrd<i8>,

fn partial_cmp(&self, other: &i8) -> 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<const FRAC: usize> PartialOrd<i8> for FastFixed<u8, FRAC>

where Fixed<u8, FRAC>: PartialOrd<i8>,

fn partial_cmp(&self, other: &i8) -> 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<const FRAC: usize> PartialOrd<i8> for FastFixed<u16, FRAC>

where Fixed<u16, FRAC>: PartialOrd<i8>,

fn partial_cmp(&self, other: &i8) -> 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<const FRAC: usize> PartialOrd<i8> for FastFixed<u32, FRAC>

where Fixed<u32, FRAC>: PartialOrd<i8>,

fn partial_cmp(&self, other: &i8) -> 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<const FRAC: usize> PartialOrd<i8> for FastFixed<u64, FRAC>

where Fixed<u64, FRAC>: PartialOrd<i8>,

fn partial_cmp(&self, other: &i8) -> 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<const FRAC: usize> PartialOrd<i16> for FastFixed<i8, FRAC>

where Fixed<i8, FRAC>: PartialOrd<i16>,

fn partial_cmp(&self, other: &i16) -> 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<const FRAC: usize> PartialOrd<i16> for FastFixed<i16, FRAC>

where Fixed<i16, FRAC>: PartialOrd<i16>,

fn partial_cmp(&self, other: &i16) -> 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<const FRAC: usize> PartialOrd<i16> for FastFixed<i32, FRAC>

where Fixed<i32, FRAC>: PartialOrd<i16>,

fn partial_cmp(&self, other: &i16) -> 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<const FRAC: usize> PartialOrd<i16> for FastFixed<i64, FRAC>

where Fixed<i64, FRAC>: PartialOrd<i16>,

fn partial_cmp(&self, other: &i16) -> 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<const FRAC: usize> PartialOrd<i16> for FastFixed<u8, FRAC>

where Fixed<u8, FRAC>: PartialOrd<i16>,

fn partial_cmp(&self, other: &i16) -> 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<const FRAC: usize> PartialOrd<i16> for FastFixed<u16, FRAC>

where Fixed<u16, FRAC>: PartialOrd<i16>,

fn partial_cmp(&self, other: &i16) -> 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<const FRAC: usize> PartialOrd<i16> for FastFixed<u32, FRAC>

where Fixed<u32, FRAC>: PartialOrd<i16>,

fn partial_cmp(&self, other: &i16) -> 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<const FRAC: usize> PartialOrd<i16> for FastFixed<u64, FRAC>

where Fixed<u64, FRAC>: PartialOrd<i16>,

fn partial_cmp(&self, other: &i16) -> 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<const FRAC: usize> PartialOrd<i32> for FastFixed<i8, FRAC>

where Fixed<i8, FRAC>: PartialOrd<i32>,

fn partial_cmp(&self, other: &i32) -> 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<const FRAC: usize> PartialOrd<i32> for FastFixed<i16, FRAC>

where Fixed<i16, FRAC>: PartialOrd<i32>,

fn partial_cmp(&self, other: &i32) -> 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<const FRAC: usize> PartialOrd<i32> for FastFixed<i32, FRAC>

where Fixed<i32, FRAC>: PartialOrd<i32>,

fn partial_cmp(&self, other: &i32) -> 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<const FRAC: usize> PartialOrd<i32> for FastFixed<i64, FRAC>

where Fixed<i64, FRAC>: PartialOrd<i32>,

fn partial_cmp(&self, other: &i32) -> 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<const FRAC: usize> PartialOrd<i32> for FastFixed<u8, FRAC>

where Fixed<u8, FRAC>: PartialOrd<i32>,

fn partial_cmp(&self, other: &i32) -> 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<const FRAC: usize> PartialOrd<i32> for FastFixed<u16, FRAC>

where Fixed<u16, FRAC>: PartialOrd<i32>,

fn partial_cmp(&self, other: &i32) -> 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<const FRAC: usize> PartialOrd<i32> for FastFixed<u32, FRAC>

where Fixed<u32, FRAC>: PartialOrd<i32>,

fn partial_cmp(&self, other: &i32) -> 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<const FRAC: usize> PartialOrd<i32> for FastFixed<u64, FRAC>

where Fixed<u64, FRAC>: PartialOrd<i32>,

fn partial_cmp(&self, other: &i32) -> 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<const FRAC: usize> PartialOrd<i64> for FastFixed<i8, FRAC>

where Fixed<i8, FRAC>: PartialOrd<i64>,

fn partial_cmp(&self, other: &i64) -> 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<const FRAC: usize> PartialOrd<i64> for FastFixed<i16, FRAC>

where Fixed<i16, FRAC>: PartialOrd<i64>,

fn partial_cmp(&self, other: &i64) -> 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<const FRAC: usize> PartialOrd<i64> for FastFixed<i32, FRAC>

where Fixed<i32, FRAC>: PartialOrd<i64>,

fn partial_cmp(&self, other: &i64) -> 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<const FRAC: usize> PartialOrd<i64> for FastFixed<i64, FRAC>

where Fixed<i64, FRAC>: PartialOrd<i64>,

fn partial_cmp(&self, other: &i64) -> 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<const FRAC: usize> PartialOrd<i64> for FastFixed<u8, FRAC>

where Fixed<u8, FRAC>: PartialOrd<i64>,

fn partial_cmp(&self, other: &i64) -> 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<const FRAC: usize> PartialOrd<i64> for FastFixed<u16, FRAC>

where Fixed<u16, FRAC>: PartialOrd<i64>,

fn partial_cmp(&self, other: &i64) -> 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<const FRAC: usize> PartialOrd<i64> for FastFixed<u32, FRAC>

where Fixed<u32, FRAC>: PartialOrd<i64>,

fn partial_cmp(&self, other: &i64) -> 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<const FRAC: usize> PartialOrd<i64> for FastFixed<u64, FRAC>

where Fixed<u64, FRAC>: PartialOrd<i64>,

fn partial_cmp(&self, other: &i64) -> 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<const FRAC: usize> PartialOrd<u8> for FastFixed<u8, FRAC>

where Fixed<u8, FRAC>: PartialOrd<u8>,

fn partial_cmp(&self, other: &u8) -> 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<const FRAC: usize> PartialOrd<u8> for FastFixed<u16, FRAC>

where Fixed<u16, FRAC>: PartialOrd<u8>,

fn partial_cmp(&self, other: &u8) -> 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<const FRAC: usize> PartialOrd<u8> for FastFixed<u32, FRAC>

where Fixed<u32, FRAC>: PartialOrd<u8>,

fn partial_cmp(&self, other: &u8) -> 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<const FRAC: usize> PartialOrd<u8> for FastFixed<u64, FRAC>

where Fixed<u64, FRAC>: PartialOrd<u8>,

fn partial_cmp(&self, other: &u8) -> 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<const FRAC: usize> PartialOrd<u8> for FastFixed<i8, FRAC>

where Fixed<i8, FRAC>: PartialOrd<u8>,

fn partial_cmp(&self, other: &u8) -> 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<const FRAC: usize> PartialOrd<u8> for FastFixed<i16, FRAC>

where Fixed<i16, FRAC>: PartialOrd<u8>,

fn partial_cmp(&self, other: &u8) -> 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<const FRAC: usize> PartialOrd<u8> for FastFixed<i32, FRAC>

where Fixed<i32, FRAC>: PartialOrd<u8>,

fn partial_cmp(&self, other: &u8) -> 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<const FRAC: usize> PartialOrd<u8> for FastFixed<i64, FRAC>

where Fixed<i64, FRAC>: PartialOrd<u8>,

fn partial_cmp(&self, other: &u8) -> 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<const FRAC: usize> PartialOrd<u16> for FastFixed<u8, FRAC>

where Fixed<u8, FRAC>: PartialOrd<u16>,

fn partial_cmp(&self, other: &u16) -> 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<const FRAC: usize> PartialOrd<u16> for FastFixed<u16, FRAC>

where Fixed<u16, FRAC>: PartialOrd<u16>,

fn partial_cmp(&self, other: &u16) -> 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<const FRAC: usize> PartialOrd<u16> for FastFixed<u32, FRAC>

where Fixed<u32, FRAC>: PartialOrd<u16>,

fn partial_cmp(&self, other: &u16) -> 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<const FRAC: usize> PartialOrd<u16> for FastFixed<u64, FRAC>

where Fixed<u64, FRAC>: PartialOrd<u16>,

fn partial_cmp(&self, other: &u16) -> 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<const FRAC: usize> PartialOrd<u16> for FastFixed<i8, FRAC>

where Fixed<i8, FRAC>: PartialOrd<u16>,

fn partial_cmp(&self, other: &u16) -> 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<const FRAC: usize> PartialOrd<u16> for FastFixed<i16, FRAC>

where Fixed<i16, FRAC>: PartialOrd<u16>,

fn partial_cmp(&self, other: &u16) -> 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<const FRAC: usize> PartialOrd<u16> for FastFixed<i32, FRAC>

where Fixed<i32, FRAC>: PartialOrd<u16>,

fn partial_cmp(&self, other: &u16) -> 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<const FRAC: usize> PartialOrd<u16> for FastFixed<i64, FRAC>

where Fixed<i64, FRAC>: PartialOrd<u16>,

fn partial_cmp(&self, other: &u16) -> 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<const FRAC: usize> PartialOrd<u32> for FastFixed<u8, FRAC>

where Fixed<u8, FRAC>: PartialOrd<u32>,

fn partial_cmp(&self, other: &u32) -> 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<const FRAC: usize> PartialOrd<u32> for FastFixed<u16, FRAC>

where Fixed<u16, FRAC>: PartialOrd<u32>,

fn partial_cmp(&self, other: &u32) -> 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<const FRAC: usize> PartialOrd<u32> for FastFixed<u32, FRAC>

where Fixed<u32, FRAC>: PartialOrd<u32>,

fn partial_cmp(&self, other: &u32) -> 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<const FRAC: usize> PartialOrd<u32> for FastFixed<u64, FRAC>

where Fixed<u64, FRAC>: PartialOrd<u32>,

fn partial_cmp(&self, other: &u32) -> 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<const FRAC: usize> PartialOrd<u32> for FastFixed<i8, FRAC>

where Fixed<i8, FRAC>: PartialOrd<u32>,

fn partial_cmp(&self, other: &u32) -> 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<const FRAC: usize> PartialOrd<u32> for FastFixed<i16, FRAC>

where Fixed<i16, FRAC>: PartialOrd<u32>,

fn partial_cmp(&self, other: &u32) -> 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<const FRAC: usize> PartialOrd<u32> for FastFixed<i32, FRAC>

where Fixed<i32, FRAC>: PartialOrd<u32>,

fn partial_cmp(&self, other: &u32) -> 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<const FRAC: usize> PartialOrd<u32> for FastFixed<i64, FRAC>

where Fixed<i64, FRAC>: PartialOrd<u32>,

fn partial_cmp(&self, other: &u32) -> 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<const FRAC: usize> PartialOrd<u64> for FastFixed<u8, FRAC>

where Fixed<u8, FRAC>: PartialOrd<u64>,

fn partial_cmp(&self, other: &u64) -> 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<const FRAC: usize> PartialOrd<u64> for FastFixed<u16, FRAC>

where Fixed<u16, FRAC>: PartialOrd<u64>,

fn partial_cmp(&self, other: &u64) -> 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<const FRAC: usize> PartialOrd<u64> for FastFixed<u32, FRAC>

where Fixed<u32, FRAC>: PartialOrd<u64>,

fn partial_cmp(&self, other: &u64) -> 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<const FRAC: usize> PartialOrd<u64> for FastFixed<u64, FRAC>

where Fixed<u64, FRAC>: PartialOrd<u64>,

fn partial_cmp(&self, other: &u64) -> 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<const FRAC: usize> PartialOrd<u64> for FastFixed<i8, FRAC>

where Fixed<i8, FRAC>: PartialOrd<u64>,

fn partial_cmp(&self, other: &u64) -> 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<const FRAC: usize> PartialOrd<u64> for FastFixed<i16, FRAC>

where Fixed<i16, FRAC>: PartialOrd<u64>,

fn partial_cmp(&self, other: &u64) -> 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<const FRAC: usize> PartialOrd<u64> for FastFixed<i32, FRAC>

where Fixed<i32, FRAC>: PartialOrd<u64>,

fn partial_cmp(&self, other: &u64) -> 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<const FRAC: usize> PartialOrd<u64> for FastFixed<i64, FRAC>

where Fixed<i64, FRAC>: PartialOrd<u64>,

fn partial_cmp(&self, other: &u64) -> 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<I, const FRAC: usize, E> Sub<E> for FastFixed<I, FRAC>

where I: Bounded + NumCast + Copy, E: FastExpression, FastFixed<I, FRAC>: Sub<FastFixed<I, FRAC>>,

type Output = <FastFixed<I, FRAC> as Sub>::Output

The resulting type after applying the - operator.

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

Performs the - operation.

impl<I, const FRAC: usize, L, R> Sub<FastFixed<I, FRAC>> for MulExpression<L, R>

where I: Bounded + NumCast + Copy, MulExpression<L, R>: FastExpression, FastFixed<I, FRAC>: Sub<FastFixed<I, FRAC>>,

type Output = <FastFixed<I, FRAC> as Sub>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: FastFixed<I, FRAC>) -> Self::Output

Performs the - operation.

impl<I, const FRAC: usize, L, R> Sub<FastFixed<I, FRAC>> for SumExpression<L, R>

where I: Bounded + NumCast + Copy, SumExpression<L, R>: FastExpression, FastFixed<I, FRAC>: Sub<FastFixed<I, FRAC>>,

type Output = <FastFixed<I, FRAC> as Sub>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: FastFixed<I, FRAC>) -> Self::Output

Performs the - operation.

impl<T, const FRAC: usize, U, const FRAC_R: usize> Sub<FastFixed<U, FRAC_R>> for FastFixed<T, FRAC>

where T: PromoteAddSub<U> + Zero + PartialOrd + NumCast + Copy, U: Zero + PartialOrd + NumCast + Copy, <T as PromoteAddSub<U>>::Output: FastInt,

type Output = FastFixed<<T as PromoteAddSub<U>>::Output, FRAC>

The resulting type after applying the - operator.

fn sub(self, rhs: FastFixed<U, FRAC_R>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<FastFixed<i8, FRAC>> for i8

where i8: PromoteAddSub<i8> + NumCast + Copy, <i8 as PromoteAddSub<i8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i8 as PromoteAddSub<i8>>::Output, FRAC>

The resulting type after applying the - operator.

fn sub(self, rhs: FastFixed<i8, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<FastFixed<i8, FRAC>> for i16

where i8: PromoteAddSub<i16> + NumCast + Copy, i16: NumCast + Copy, <i8 as PromoteAddSub<i16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i8 as PromoteAddSub<i16>>::Output, FRAC>

The resulting type after applying the - operator.

fn sub(self, rhs: FastFixed<i8, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<FastFixed<i8, FRAC>> for i32

where i8: PromoteAddSub<i32> + NumCast + Copy, i32: NumCast + Copy, <i8 as PromoteAddSub<i32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i8 as PromoteAddSub<i32>>::Output, FRAC>

The resulting type after applying the - operator.

fn sub(self, rhs: FastFixed<i8, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<FastFixed<i8, FRAC>> for i64

where i8: PromoteAddSub<i64> + NumCast + Copy, i64: NumCast + Copy, <i8 as PromoteAddSub<i64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i8 as PromoteAddSub<i64>>::Output, FRAC>

The resulting type after applying the - operator.

fn sub(self, rhs: FastFixed<i8, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<FastFixed<i8, FRAC>> for u8

where i8: PromoteAddSub<u8> + NumCast + Copy, u8: NumCast + Copy, <i8 as PromoteAddSub<u8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i8 as PromoteAddSub<u8>>::Output, FRAC>

The resulting type after applying the - operator.

fn sub(self, rhs: FastFixed<i8, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<FastFixed<i8, FRAC>> for u16

where i8: PromoteAddSub<u16> + NumCast + Copy, u16: NumCast + Copy, <i8 as PromoteAddSub<u16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i8 as PromoteAddSub<u16>>::Output, FRAC>

The resulting type after applying the - operator.

fn sub(self, rhs: FastFixed<i8, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<FastFixed<i8, FRAC>> for u32

where i8: PromoteAddSub<u32> + NumCast + Copy, u32: NumCast + Copy, <i8 as PromoteAddSub<u32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i8 as PromoteAddSub<u32>>::Output, FRAC>

The resulting type after applying the - operator.

fn sub(self, rhs: FastFixed<i8, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<FastFixed<i8, FRAC>> for u64

where i8: PromoteAddSub<u64> + NumCast + Copy, u64: NumCast + Copy, <i8 as PromoteAddSub<u64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i8 as PromoteAddSub<u64>>::Output, FRAC>

The resulting type after applying the - operator.

fn sub(self, rhs: FastFixed<i8, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<FastFixed<i16, FRAC>> for i8

where i16: PromoteAddSub<i8> + NumCast + Copy, i8: NumCast + Copy, <i16 as PromoteAddSub<i8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i16 as PromoteAddSub<i8>>::Output, FRAC>

The resulting type after applying the - operator.

fn sub(self, rhs: FastFixed<i16, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<FastFixed<i16, FRAC>> for i16

where i16: PromoteAddSub<i16> + NumCast + Copy, <i16 as PromoteAddSub<i16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i16 as PromoteAddSub<i16>>::Output, FRAC>

The resulting type after applying the - operator.

fn sub(self, rhs: FastFixed<i16, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<FastFixed<i16, FRAC>> for i32

where i16: PromoteAddSub<i32> + NumCast + Copy, i32: NumCast + Copy, <i16 as PromoteAddSub<i32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i16 as PromoteAddSub<i32>>::Output, FRAC>

The resulting type after applying the - operator.

fn sub(self, rhs: FastFixed<i16, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<FastFixed<i16, FRAC>> for i64

where i16: PromoteAddSub<i64> + NumCast + Copy, i64: NumCast + Copy, <i16 as PromoteAddSub<i64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i16 as PromoteAddSub<i64>>::Output, FRAC>

The resulting type after applying the - operator.

fn sub(self, rhs: FastFixed<i16, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<FastFixed<i16, FRAC>> for u8

where i16: PromoteAddSub<u8> + NumCast + Copy, u8: NumCast + Copy, <i16 as PromoteAddSub<u8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i16 as PromoteAddSub<u8>>::Output, FRAC>

The resulting type after applying the - operator.

fn sub(self, rhs: FastFixed<i16, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<FastFixed<i16, FRAC>> for u16

where i16: PromoteAddSub<u16> + NumCast + Copy, u16: NumCast + Copy, <i16 as PromoteAddSub<u16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i16 as PromoteAddSub<u16>>::Output, FRAC>

The resulting type after applying the - operator.

fn sub(self, rhs: FastFixed<i16, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<FastFixed<i16, FRAC>> for u32

where i16: PromoteAddSub<u32> + NumCast + Copy, u32: NumCast + Copy, <i16 as PromoteAddSub<u32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i16 as PromoteAddSub<u32>>::Output, FRAC>

The resulting type after applying the - operator.

fn sub(self, rhs: FastFixed<i16, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<FastFixed<i16, FRAC>> for u64

where i16: PromoteAddSub<u64> + NumCast + Copy, u64: NumCast + Copy, <i16 as PromoteAddSub<u64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i16 as PromoteAddSub<u64>>::Output, FRAC>

The resulting type after applying the - operator.

fn sub(self, rhs: FastFixed<i16, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<FastFixed<i32, FRAC>> for i8

where i32: PromoteAddSub<i8> + NumCast + Copy, i8: NumCast + Copy, <i32 as PromoteAddSub<i8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i32 as PromoteAddSub<i8>>::Output, FRAC>

The resulting type after applying the - operator.

fn sub(self, rhs: FastFixed<i32, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<FastFixed<i32, FRAC>> for i16

where i32: PromoteAddSub<i16> + NumCast + Copy, i16: NumCast + Copy, <i32 as PromoteAddSub<i16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i32 as PromoteAddSub<i16>>::Output, FRAC>

The resulting type after applying the - operator.

fn sub(self, rhs: FastFixed<i32, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<FastFixed<i32, FRAC>> for i32

where i32: PromoteAddSub<i32> + NumCast + Copy, <i32 as PromoteAddSub<i32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i32 as PromoteAddSub<i32>>::Output, FRAC>

The resulting type after applying the - operator.

fn sub(self, rhs: FastFixed<i32, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<FastFixed<i32, FRAC>> for i64

where i32: PromoteAddSub<i64> + NumCast + Copy, i64: NumCast + Copy, <i32 as PromoteAddSub<i64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i32 as PromoteAddSub<i64>>::Output, FRAC>

The resulting type after applying the - operator.

fn sub(self, rhs: FastFixed<i32, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<FastFixed<i32, FRAC>> for u8

where i32: PromoteAddSub<u8> + NumCast + Copy, u8: NumCast + Copy, <i32 as PromoteAddSub<u8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i32 as PromoteAddSub<u8>>::Output, FRAC>

The resulting type after applying the - operator.

fn sub(self, rhs: FastFixed<i32, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<FastFixed<i32, FRAC>> for u16

where i32: PromoteAddSub<u16> + NumCast + Copy, u16: NumCast + Copy, <i32 as PromoteAddSub<u16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i32 as PromoteAddSub<u16>>::Output, FRAC>

The resulting type after applying the - operator.

fn sub(self, rhs: FastFixed<i32, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<FastFixed<i32, FRAC>> for u32

where i32: PromoteAddSub<u32> + NumCast + Copy, u32: NumCast + Copy, <i32 as PromoteAddSub<u32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i32 as PromoteAddSub<u32>>::Output, FRAC>

The resulting type after applying the - operator.

fn sub(self, rhs: FastFixed<i32, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<FastFixed<i32, FRAC>> for u64

where i32: PromoteAddSub<u64> + NumCast + Copy, u64: NumCast + Copy, <i32 as PromoteAddSub<u64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i32 as PromoteAddSub<u64>>::Output, FRAC>

The resulting type after applying the - operator.

fn sub(self, rhs: FastFixed<i32, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<FastFixed<i64, FRAC>> for i8

where i64: PromoteAddSub<i8> + NumCast + Copy, i8: NumCast + Copy, <i64 as PromoteAddSub<i8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i64 as PromoteAddSub<i8>>::Output, FRAC>

The resulting type after applying the - operator.

fn sub(self, rhs: FastFixed<i64, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<FastFixed<i64, FRAC>> for i16

where i64: PromoteAddSub<i16> + NumCast + Copy, i16: NumCast + Copy, <i64 as PromoteAddSub<i16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i64 as PromoteAddSub<i16>>::Output, FRAC>

The resulting type after applying the - operator.

fn sub(self, rhs: FastFixed<i64, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<FastFixed<i64, FRAC>> for i32

where i64: PromoteAddSub<i32> + NumCast + Copy, i32: NumCast + Copy, <i64 as PromoteAddSub<i32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i64 as PromoteAddSub<i32>>::Output, FRAC>

The resulting type after applying the - operator.

fn sub(self, rhs: FastFixed<i64, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<FastFixed<i64, FRAC>> for i64

where i64: PromoteAddSub<i64> + NumCast + Copy, <i64 as PromoteAddSub<i64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i64 as PromoteAddSub<i64>>::Output, FRAC>

The resulting type after applying the - operator.

fn sub(self, rhs: FastFixed<i64, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<FastFixed<i64, FRAC>> for u8

where i64: PromoteAddSub<u8> + NumCast + Copy, u8: NumCast + Copy, <i64 as PromoteAddSub<u8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i64 as PromoteAddSub<u8>>::Output, FRAC>

The resulting type after applying the - operator.

fn sub(self, rhs: FastFixed<i64, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<FastFixed<i64, FRAC>> for u16

where i64: PromoteAddSub<u16> + NumCast + Copy, u16: NumCast + Copy, <i64 as PromoteAddSub<u16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i64 as PromoteAddSub<u16>>::Output, FRAC>

The resulting type after applying the - operator.

fn sub(self, rhs: FastFixed<i64, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<FastFixed<i64, FRAC>> for u32

where i64: PromoteAddSub<u32> + NumCast + Copy, u32: NumCast + Copy, <i64 as PromoteAddSub<u32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i64 as PromoteAddSub<u32>>::Output, FRAC>

The resulting type after applying the - operator.

fn sub(self, rhs: FastFixed<i64, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<FastFixed<i64, FRAC>> for u64

where i64: PromoteAddSub<u64> + NumCast + Copy, u64: NumCast + Copy, <i64 as PromoteAddSub<u64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i64 as PromoteAddSub<u64>>::Output, FRAC>

The resulting type after applying the - operator.

fn sub(self, rhs: FastFixed<i64, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<FastFixed<u8, FRAC>> for u8

where u8: PromoteAddSub<u8> + NumCast + Copy, <u8 as PromoteAddSub<u8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u8 as PromoteAddSub<u8>>::Output, FRAC>

The resulting type after applying the - operator.

fn sub(self, rhs: FastFixed<u8, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<FastFixed<u8, FRAC>> for u16

where u8: PromoteAddSub<u16> + NumCast + Copy, u16: NumCast + Copy, <u8 as PromoteAddSub<u16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u8 as PromoteAddSub<u16>>::Output, FRAC>

The resulting type after applying the - operator.

fn sub(self, rhs: FastFixed<u8, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<FastFixed<u8, FRAC>> for u32

where u8: PromoteAddSub<u32> + NumCast + Copy, u32: NumCast + Copy, <u8 as PromoteAddSub<u32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u8 as PromoteAddSub<u32>>::Output, FRAC>

The resulting type after applying the - operator.

fn sub(self, rhs: FastFixed<u8, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<FastFixed<u8, FRAC>> for u64

where u8: PromoteAddSub<u64> + NumCast + Copy, u64: NumCast + Copy, <u8 as PromoteAddSub<u64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u8 as PromoteAddSub<u64>>::Output, FRAC>

The resulting type after applying the - operator.

fn sub(self, rhs: FastFixed<u8, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<FastFixed<u8, FRAC>> for i8

where u8: PromoteAddSub<i8> + NumCast + Copy, i8: NumCast + Copy, <u8 as PromoteAddSub<i8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u8 as PromoteAddSub<i8>>::Output, FRAC>

The resulting type after applying the - operator.

fn sub(self, rhs: FastFixed<u8, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<FastFixed<u8, FRAC>> for i16

where u8: PromoteAddSub<i16> + NumCast + Copy, i16: NumCast + Copy, <u8 as PromoteAddSub<i16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u8 as PromoteAddSub<i16>>::Output, FRAC>

The resulting type after applying the - operator.

fn sub(self, rhs: FastFixed<u8, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<FastFixed<u8, FRAC>> for i32

where u8: PromoteAddSub<i32> + NumCast + Copy, i32: NumCast + Copy, <u8 as PromoteAddSub<i32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u8 as PromoteAddSub<i32>>::Output, FRAC>

The resulting type after applying the - operator.

fn sub(self, rhs: FastFixed<u8, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<FastFixed<u8, FRAC>> for i64

where u8: PromoteAddSub<i64> + NumCast + Copy, i64: NumCast + Copy, <u8 as PromoteAddSub<i64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u8 as PromoteAddSub<i64>>::Output, FRAC>

The resulting type after applying the - operator.

fn sub(self, rhs: FastFixed<u8, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<FastFixed<u16, FRAC>> for u8

where u16: PromoteAddSub<u8> + NumCast + Copy, u8: NumCast + Copy, <u16 as PromoteAddSub<u8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u16 as PromoteAddSub<u8>>::Output, FRAC>

The resulting type after applying the - operator.

fn sub(self, rhs: FastFixed<u16, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<FastFixed<u16, FRAC>> for u16

where u16: PromoteAddSub<u16> + NumCast + Copy, <u16 as PromoteAddSub<u16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u16 as PromoteAddSub<u16>>::Output, FRAC>

The resulting type after applying the - operator.

fn sub(self, rhs: FastFixed<u16, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<FastFixed<u16, FRAC>> for u32

where u16: PromoteAddSub<u32> + NumCast + Copy, u32: NumCast + Copy, <u16 as PromoteAddSub<u32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u16 as PromoteAddSub<u32>>::Output, FRAC>

The resulting type after applying the - operator.

fn sub(self, rhs: FastFixed<u16, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<FastFixed<u16, FRAC>> for u64

where u16: PromoteAddSub<u64> + NumCast + Copy, u64: NumCast + Copy, <u16 as PromoteAddSub<u64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u16 as PromoteAddSub<u64>>::Output, FRAC>

The resulting type after applying the - operator.

fn sub(self, rhs: FastFixed<u16, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<FastFixed<u16, FRAC>> for i8

where u16: PromoteAddSub<i8> + NumCast + Copy, i8: NumCast + Copy, <u16 as PromoteAddSub<i8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u16 as PromoteAddSub<i8>>::Output, FRAC>

The resulting type after applying the - operator.

fn sub(self, rhs: FastFixed<u16, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<FastFixed<u16, FRAC>> for i16

where u16: PromoteAddSub<i16> + NumCast + Copy, i16: NumCast + Copy, <u16 as PromoteAddSub<i16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u16 as PromoteAddSub<i16>>::Output, FRAC>

The resulting type after applying the - operator.

fn sub(self, rhs: FastFixed<u16, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<FastFixed<u16, FRAC>> for i32

where u16: PromoteAddSub<i32> + NumCast + Copy, i32: NumCast + Copy, <u16 as PromoteAddSub<i32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u16 as PromoteAddSub<i32>>::Output, FRAC>

The resulting type after applying the - operator.

fn sub(self, rhs: FastFixed<u16, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<FastFixed<u16, FRAC>> for i64

where u16: PromoteAddSub<i64> + NumCast + Copy, i64: NumCast + Copy, <u16 as PromoteAddSub<i64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u16 as PromoteAddSub<i64>>::Output, FRAC>

The resulting type after applying the - operator.

fn sub(self, rhs: FastFixed<u16, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<FastFixed<u32, FRAC>> for u8

where u32: PromoteAddSub<u8> + NumCast + Copy, u8: NumCast + Copy, <u32 as PromoteAddSub<u8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u32 as PromoteAddSub<u8>>::Output, FRAC>

The resulting type after applying the - operator.

fn sub(self, rhs: FastFixed<u32, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<FastFixed<u32, FRAC>> for u16

where u32: PromoteAddSub<u16> + NumCast + Copy, u16: NumCast + Copy, <u32 as PromoteAddSub<u16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u32 as PromoteAddSub<u16>>::Output, FRAC>

The resulting type after applying the - operator.

fn sub(self, rhs: FastFixed<u32, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<FastFixed<u32, FRAC>> for u32

where u32: PromoteAddSub<u32> + NumCast + Copy, <u32 as PromoteAddSub<u32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u32 as PromoteAddSub<u32>>::Output, FRAC>

The resulting type after applying the - operator.

fn sub(self, rhs: FastFixed<u32, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<FastFixed<u32, FRAC>> for u64

where u32: PromoteAddSub<u64> + NumCast + Copy, u64: NumCast + Copy, <u32 as PromoteAddSub<u64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u32 as PromoteAddSub<u64>>::Output, FRAC>

The resulting type after applying the - operator.

fn sub(self, rhs: FastFixed<u32, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<FastFixed<u32, FRAC>> for i8

where u32: PromoteAddSub<i8> + NumCast + Copy, i8: NumCast + Copy, <u32 as PromoteAddSub<i8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u32 as PromoteAddSub<i8>>::Output, FRAC>

The resulting type after applying the - operator.

fn sub(self, rhs: FastFixed<u32, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<FastFixed<u32, FRAC>> for i16

where u32: PromoteAddSub<i16> + NumCast + Copy, i16: NumCast + Copy, <u32 as PromoteAddSub<i16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u32 as PromoteAddSub<i16>>::Output, FRAC>

The resulting type after applying the - operator.

fn sub(self, rhs: FastFixed<u32, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<FastFixed<u32, FRAC>> for i32

where u32: PromoteAddSub<i32> + NumCast + Copy, i32: NumCast + Copy, <u32 as PromoteAddSub<i32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u32 as PromoteAddSub<i32>>::Output, FRAC>

The resulting type after applying the - operator.

fn sub(self, rhs: FastFixed<u32, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<FastFixed<u32, FRAC>> for i64

where u32: PromoteAddSub<i64> + NumCast + Copy, i64: NumCast + Copy, <u32 as PromoteAddSub<i64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u32 as PromoteAddSub<i64>>::Output, FRAC>

The resulting type after applying the - operator.

fn sub(self, rhs: FastFixed<u32, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<FastFixed<u64, FRAC>> for u8

where u64: PromoteAddSub<u8> + NumCast + Copy, u8: NumCast + Copy, <u64 as PromoteAddSub<u8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u64 as PromoteAddSub<u8>>::Output, FRAC>

The resulting type after applying the - operator.

fn sub(self, rhs: FastFixed<u64, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<FastFixed<u64, FRAC>> for u16

where u64: PromoteAddSub<u16> + NumCast + Copy, u16: NumCast + Copy, <u64 as PromoteAddSub<u16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u64 as PromoteAddSub<u16>>::Output, FRAC>

The resulting type after applying the - operator.

fn sub(self, rhs: FastFixed<u64, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<FastFixed<u64, FRAC>> for u32

where u64: PromoteAddSub<u32> + NumCast + Copy, u32: NumCast + Copy, <u64 as PromoteAddSub<u32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u64 as PromoteAddSub<u32>>::Output, FRAC>

The resulting type after applying the - operator.

fn sub(self, rhs: FastFixed<u64, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<FastFixed<u64, FRAC>> for u64

where u64: PromoteAddSub<u64> + NumCast + Copy, <u64 as PromoteAddSub<u64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u64 as PromoteAddSub<u64>>::Output, FRAC>

The resulting type after applying the - operator.

fn sub(self, rhs: FastFixed<u64, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<FastFixed<u64, FRAC>> for i8

where u64: PromoteAddSub<i8> + NumCast + Copy, i8: NumCast + Copy, <u64 as PromoteAddSub<i8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u64 as PromoteAddSub<i8>>::Output, FRAC>

The resulting type after applying the - operator.

fn sub(self, rhs: FastFixed<u64, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<FastFixed<u64, FRAC>> for i16

where u64: PromoteAddSub<i16> + NumCast + Copy, i16: NumCast + Copy, <u64 as PromoteAddSub<i16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u64 as PromoteAddSub<i16>>::Output, FRAC>

The resulting type after applying the - operator.

fn sub(self, rhs: FastFixed<u64, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<FastFixed<u64, FRAC>> for i32

where u64: PromoteAddSub<i32> + NumCast + Copy, i32: NumCast + Copy, <u64 as PromoteAddSub<i32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u64 as PromoteAddSub<i32>>::Output, FRAC>

The resulting type after applying the - operator.

fn sub(self, rhs: FastFixed<u64, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<FastFixed<u64, FRAC>> for i64

where u64: PromoteAddSub<i64> + NumCast + Copy, i64: NumCast + Copy, <u64 as PromoteAddSub<i64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u64 as PromoteAddSub<i64>>::Output, FRAC>

The resulting type after applying the - operator.

fn sub(self, rhs: FastFixed<u64, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<i8> for FastFixed<i8, FRAC>

where i8: PromoteAddSub<i8> + NumCast + Copy, <i8 as PromoteAddSub<i8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i8 as PromoteAddSub<i8>>::Output, FRAC>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<const FRAC: usize> Sub<i8> for FastFixed<i16, FRAC>

where i16: PromoteAddSub<i8> + NumCast + Copy, i8: NumCast + Copy, <i16 as PromoteAddSub<i8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i16 as PromoteAddSub<i8>>::Output, FRAC>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<const FRAC: usize> Sub<i8> for FastFixed<i32, FRAC>

where i32: PromoteAddSub<i8> + NumCast + Copy, i8: NumCast + Copy, <i32 as PromoteAddSub<i8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i32 as PromoteAddSub<i8>>::Output, FRAC>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<const FRAC: usize> Sub<i8> for FastFixed<i64, FRAC>

where i64: PromoteAddSub<i8> + NumCast + Copy, i8: NumCast + Copy, <i64 as PromoteAddSub<i8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i64 as PromoteAddSub<i8>>::Output, FRAC>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<const FRAC: usize> Sub<i8> for FastFixed<u8, FRAC>

where u8: PromoteAddSub<i8> + NumCast + Copy, i8: NumCast + Copy, <u8 as PromoteAddSub<i8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u8 as PromoteAddSub<i8>>::Output, FRAC>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<const FRAC: usize> Sub<i8> for FastFixed<u16, FRAC>

where u16: PromoteAddSub<i8> + NumCast + Copy, i8: NumCast + Copy, <u16 as PromoteAddSub<i8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u16 as PromoteAddSub<i8>>::Output, FRAC>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<const FRAC: usize> Sub<i8> for FastFixed<u32, FRAC>

where u32: PromoteAddSub<i8> + NumCast + Copy, i8: NumCast + Copy, <u32 as PromoteAddSub<i8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u32 as PromoteAddSub<i8>>::Output, FRAC>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<const FRAC: usize> Sub<i8> for FastFixed<u64, FRAC>

where u64: PromoteAddSub<i8> + NumCast + Copy, i8: NumCast + Copy, <u64 as PromoteAddSub<i8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u64 as PromoteAddSub<i8>>::Output, FRAC>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<const FRAC: usize> Sub<i16> for FastFixed<i8, FRAC>

where i8: PromoteAddSub<i16> + NumCast + Copy, i16: NumCast + Copy, <i8 as PromoteAddSub<i16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i8 as PromoteAddSub<i16>>::Output, FRAC>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<const FRAC: usize> Sub<i16> for FastFixed<i16, FRAC>

where i16: PromoteAddSub<i16> + NumCast + Copy, <i16 as PromoteAddSub<i16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i16 as PromoteAddSub<i16>>::Output, FRAC>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<const FRAC: usize> Sub<i16> for FastFixed<i32, FRAC>

where i32: PromoteAddSub<i16> + NumCast + Copy, i16: NumCast + Copy, <i32 as PromoteAddSub<i16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i32 as PromoteAddSub<i16>>::Output, FRAC>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<const FRAC: usize> Sub<i16> for FastFixed<i64, FRAC>

where i64: PromoteAddSub<i16> + NumCast + Copy, i16: NumCast + Copy, <i64 as PromoteAddSub<i16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i64 as PromoteAddSub<i16>>::Output, FRAC>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<const FRAC: usize> Sub<i16> for FastFixed<u8, FRAC>

where u8: PromoteAddSub<i16> + NumCast + Copy, i16: NumCast + Copy, <u8 as PromoteAddSub<i16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u8 as PromoteAddSub<i16>>::Output, FRAC>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<const FRAC: usize> Sub<i16> for FastFixed<u16, FRAC>

where u16: PromoteAddSub<i16> + NumCast + Copy, i16: NumCast + Copy, <u16 as PromoteAddSub<i16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u16 as PromoteAddSub<i16>>::Output, FRAC>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<const FRAC: usize> Sub<i16> for FastFixed<u32, FRAC>

where u32: PromoteAddSub<i16> + NumCast + Copy, i16: NumCast + Copy, <u32 as PromoteAddSub<i16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u32 as PromoteAddSub<i16>>::Output, FRAC>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<const FRAC: usize> Sub<i16> for FastFixed<u64, FRAC>

where u64: PromoteAddSub<i16> + NumCast + Copy, i16: NumCast + Copy, <u64 as PromoteAddSub<i16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u64 as PromoteAddSub<i16>>::Output, FRAC>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<const FRAC: usize> Sub<i32> for FastFixed<i8, FRAC>

where i8: PromoteAddSub<i32> + NumCast + Copy, i32: NumCast + Copy, <i8 as PromoteAddSub<i32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i8 as PromoteAddSub<i32>>::Output, FRAC>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<const FRAC: usize> Sub<i32> for FastFixed<i16, FRAC>

where i16: PromoteAddSub<i32> + NumCast + Copy, i32: NumCast + Copy, <i16 as PromoteAddSub<i32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i16 as PromoteAddSub<i32>>::Output, FRAC>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<const FRAC: usize> Sub<i32> for FastFixed<i32, FRAC>

where i32: PromoteAddSub<i32> + NumCast + Copy, <i32 as PromoteAddSub<i32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i32 as PromoteAddSub<i32>>::Output, FRAC>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<const FRAC: usize> Sub<i32> for FastFixed<i64, FRAC>

where i64: PromoteAddSub<i32> + NumCast + Copy, i32: NumCast + Copy, <i64 as PromoteAddSub<i32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i64 as PromoteAddSub<i32>>::Output, FRAC>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<const FRAC: usize> Sub<i32> for FastFixed<u8, FRAC>

where u8: PromoteAddSub<i32> + NumCast + Copy, i32: NumCast + Copy, <u8 as PromoteAddSub<i32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u8 as PromoteAddSub<i32>>::Output, FRAC>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<const FRAC: usize> Sub<i32> for FastFixed<u16, FRAC>

where u16: PromoteAddSub<i32> + NumCast + Copy, i32: NumCast + Copy, <u16 as PromoteAddSub<i32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u16 as PromoteAddSub<i32>>::Output, FRAC>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<const FRAC: usize> Sub<i32> for FastFixed<u32, FRAC>

where u32: PromoteAddSub<i32> + NumCast + Copy, i32: NumCast + Copy, <u32 as PromoteAddSub<i32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u32 as PromoteAddSub<i32>>::Output, FRAC>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<const FRAC: usize> Sub<i32> for FastFixed<u64, FRAC>

where u64: PromoteAddSub<i32> + NumCast + Copy, i32: NumCast + Copy, <u64 as PromoteAddSub<i32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u64 as PromoteAddSub<i32>>::Output, FRAC>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<const FRAC: usize> Sub<i64> for FastFixed<i8, FRAC>

where i8: PromoteAddSub<i64> + NumCast + Copy, i64: NumCast + Copy, <i8 as PromoteAddSub<i64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i8 as PromoteAddSub<i64>>::Output, FRAC>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<const FRAC: usize> Sub<i64> for FastFixed<i16, FRAC>

where i16: PromoteAddSub<i64> + NumCast + Copy, i64: NumCast + Copy, <i16 as PromoteAddSub<i64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i16 as PromoteAddSub<i64>>::Output, FRAC>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<const FRAC: usize> Sub<i64> for FastFixed<i32, FRAC>

where i32: PromoteAddSub<i64> + NumCast + Copy, i64: NumCast + Copy, <i32 as PromoteAddSub<i64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i32 as PromoteAddSub<i64>>::Output, FRAC>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<const FRAC: usize> Sub<i64> for FastFixed<i64, FRAC>

where i64: PromoteAddSub<i64> + NumCast + Copy, <i64 as PromoteAddSub<i64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i64 as PromoteAddSub<i64>>::Output, FRAC>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<const FRAC: usize> Sub<i64> for FastFixed<u8, FRAC>

where u8: PromoteAddSub<i64> + NumCast + Copy, i64: NumCast + Copy, <u8 as PromoteAddSub<i64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u8 as PromoteAddSub<i64>>::Output, FRAC>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<const FRAC: usize> Sub<i64> for FastFixed<u16, FRAC>

where u16: PromoteAddSub<i64> + NumCast + Copy, i64: NumCast + Copy, <u16 as PromoteAddSub<i64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u16 as PromoteAddSub<i64>>::Output, FRAC>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<const FRAC: usize> Sub<i64> for FastFixed<u32, FRAC>

where u32: PromoteAddSub<i64> + NumCast + Copy, i64: NumCast + Copy, <u32 as PromoteAddSub<i64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u32 as PromoteAddSub<i64>>::Output, FRAC>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<const FRAC: usize> Sub<i64> for FastFixed<u64, FRAC>

where u64: PromoteAddSub<i64> + NumCast + Copy, i64: NumCast + Copy, <u64 as PromoteAddSub<i64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u64 as PromoteAddSub<i64>>::Output, FRAC>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<const FRAC: usize> Sub<u8> for FastFixed<u8, FRAC>

where u8: PromoteAddSub<u8> + NumCast + Copy, <u8 as PromoteAddSub<u8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u8 as PromoteAddSub<u8>>::Output, FRAC>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<const FRAC: usize> Sub<u8> for FastFixed<u16, FRAC>

where u16: PromoteAddSub<u8> + NumCast + Copy, u8: NumCast + Copy, <u16 as PromoteAddSub<u8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u16 as PromoteAddSub<u8>>::Output, FRAC>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<const FRAC: usize> Sub<u8> for FastFixed<u32, FRAC>

where u32: PromoteAddSub<u8> + NumCast + Copy, u8: NumCast + Copy, <u32 as PromoteAddSub<u8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u32 as PromoteAddSub<u8>>::Output, FRAC>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<const FRAC: usize> Sub<u8> for FastFixed<u64, FRAC>

where u64: PromoteAddSub<u8> + NumCast + Copy, u8: NumCast + Copy, <u64 as PromoteAddSub<u8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u64 as PromoteAddSub<u8>>::Output, FRAC>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<const FRAC: usize> Sub<u8> for FastFixed<i8, FRAC>

where i8: PromoteAddSub<u8> + NumCast + Copy, u8: NumCast + Copy, <i8 as PromoteAddSub<u8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i8 as PromoteAddSub<u8>>::Output, FRAC>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<const FRAC: usize> Sub<u8> for FastFixed<i16, FRAC>

where i16: PromoteAddSub<u8> + NumCast + Copy, u8: NumCast + Copy, <i16 as PromoteAddSub<u8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i16 as PromoteAddSub<u8>>::Output, FRAC>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<const FRAC: usize> Sub<u8> for FastFixed<i32, FRAC>

where i32: PromoteAddSub<u8> + NumCast + Copy, u8: NumCast + Copy, <i32 as PromoteAddSub<u8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i32 as PromoteAddSub<u8>>::Output, FRAC>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<const FRAC: usize> Sub<u8> for FastFixed<i64, FRAC>

where i64: PromoteAddSub<u8> + NumCast + Copy, u8: NumCast + Copy, <i64 as PromoteAddSub<u8>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i64 as PromoteAddSub<u8>>::Output, FRAC>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<const FRAC: usize> Sub<u16> for FastFixed<u8, FRAC>

where u8: PromoteAddSub<u16> + NumCast + Copy, u16: NumCast + Copy, <u8 as PromoteAddSub<u16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u8 as PromoteAddSub<u16>>::Output, FRAC>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<const FRAC: usize> Sub<u16> for FastFixed<u16, FRAC>

where u16: PromoteAddSub<u16> + NumCast + Copy, <u16 as PromoteAddSub<u16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u16 as PromoteAddSub<u16>>::Output, FRAC>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<const FRAC: usize> Sub<u16> for FastFixed<u32, FRAC>

where u32: PromoteAddSub<u16> + NumCast + Copy, u16: NumCast + Copy, <u32 as PromoteAddSub<u16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u32 as PromoteAddSub<u16>>::Output, FRAC>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<const FRAC: usize> Sub<u16> for FastFixed<u64, FRAC>

where u64: PromoteAddSub<u16> + NumCast + Copy, u16: NumCast + Copy, <u64 as PromoteAddSub<u16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u64 as PromoteAddSub<u16>>::Output, FRAC>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<const FRAC: usize> Sub<u16> for FastFixed<i8, FRAC>

where i8: PromoteAddSub<u16> + NumCast + Copy, u16: NumCast + Copy, <i8 as PromoteAddSub<u16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i8 as PromoteAddSub<u16>>::Output, FRAC>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<const FRAC: usize> Sub<u16> for FastFixed<i16, FRAC>

where i16: PromoteAddSub<u16> + NumCast + Copy, u16: NumCast + Copy, <i16 as PromoteAddSub<u16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i16 as PromoteAddSub<u16>>::Output, FRAC>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<const FRAC: usize> Sub<u16> for FastFixed<i32, FRAC>

where i32: PromoteAddSub<u16> + NumCast + Copy, u16: NumCast + Copy, <i32 as PromoteAddSub<u16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i32 as PromoteAddSub<u16>>::Output, FRAC>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<const FRAC: usize> Sub<u16> for FastFixed<i64, FRAC>

where i64: PromoteAddSub<u16> + NumCast + Copy, u16: NumCast + Copy, <i64 as PromoteAddSub<u16>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i64 as PromoteAddSub<u16>>::Output, FRAC>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<const FRAC: usize> Sub<u32> for FastFixed<u8, FRAC>

where u8: PromoteAddSub<u32> + NumCast + Copy, u32: NumCast + Copy, <u8 as PromoteAddSub<u32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u8 as PromoteAddSub<u32>>::Output, FRAC>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<const FRAC: usize> Sub<u32> for FastFixed<u16, FRAC>

where u16: PromoteAddSub<u32> + NumCast + Copy, u32: NumCast + Copy, <u16 as PromoteAddSub<u32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u16 as PromoteAddSub<u32>>::Output, FRAC>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<const FRAC: usize> Sub<u32> for FastFixed<u32, FRAC>

where u32: PromoteAddSub<u32> + NumCast + Copy, <u32 as PromoteAddSub<u32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u32 as PromoteAddSub<u32>>::Output, FRAC>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<const FRAC: usize> Sub<u32> for FastFixed<u64, FRAC>

where u64: PromoteAddSub<u32> + NumCast + Copy, u32: NumCast + Copy, <u64 as PromoteAddSub<u32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u64 as PromoteAddSub<u32>>::Output, FRAC>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<const FRAC: usize> Sub<u32> for FastFixed<i8, FRAC>

where i8: PromoteAddSub<u32> + NumCast + Copy, u32: NumCast + Copy, <i8 as PromoteAddSub<u32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i8 as PromoteAddSub<u32>>::Output, FRAC>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<const FRAC: usize> Sub<u32> for FastFixed<i16, FRAC>

where i16: PromoteAddSub<u32> + NumCast + Copy, u32: NumCast + Copy, <i16 as PromoteAddSub<u32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i16 as PromoteAddSub<u32>>::Output, FRAC>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<const FRAC: usize> Sub<u32> for FastFixed<i32, FRAC>

where i32: PromoteAddSub<u32> + NumCast + Copy, u32: NumCast + Copy, <i32 as PromoteAddSub<u32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i32 as PromoteAddSub<u32>>::Output, FRAC>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<const FRAC: usize> Sub<u32> for FastFixed<i64, FRAC>

where i64: PromoteAddSub<u32> + NumCast + Copy, u32: NumCast + Copy, <i64 as PromoteAddSub<u32>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i64 as PromoteAddSub<u32>>::Output, FRAC>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<const FRAC: usize> Sub<u64> for FastFixed<u8, FRAC>

where u8: PromoteAddSub<u64> + NumCast + Copy, u64: NumCast + Copy, <u8 as PromoteAddSub<u64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u8 as PromoteAddSub<u64>>::Output, FRAC>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<const FRAC: usize> Sub<u64> for FastFixed<u16, FRAC>

where u16: PromoteAddSub<u64> + NumCast + Copy, u64: NumCast + Copy, <u16 as PromoteAddSub<u64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u16 as PromoteAddSub<u64>>::Output, FRAC>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<const FRAC: usize> Sub<u64> for FastFixed<u32, FRAC>

where u32: PromoteAddSub<u64> + NumCast + Copy, u64: NumCast + Copy, <u32 as PromoteAddSub<u64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u32 as PromoteAddSub<u64>>::Output, FRAC>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<const FRAC: usize> Sub<u64> for FastFixed<u64, FRAC>

where u64: PromoteAddSub<u64> + NumCast + Copy, <u64 as PromoteAddSub<u64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<u64 as PromoteAddSub<u64>>::Output, FRAC>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<const FRAC: usize> Sub<u64> for FastFixed<i8, FRAC>

where i8: PromoteAddSub<u64> + NumCast + Copy, u64: NumCast + Copy, <i8 as PromoteAddSub<u64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i8 as PromoteAddSub<u64>>::Output, FRAC>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<const FRAC: usize> Sub<u64> for FastFixed<i16, FRAC>

where i16: PromoteAddSub<u64> + NumCast + Copy, u64: NumCast + Copy, <i16 as PromoteAddSub<u64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i16 as PromoteAddSub<u64>>::Output, FRAC>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<const FRAC: usize> Sub<u64> for FastFixed<i32, FRAC>

where i32: PromoteAddSub<u64> + NumCast + Copy, u64: NumCast + Copy, <i32 as PromoteAddSub<u64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i32 as PromoteAddSub<u64>>::Output, FRAC>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<const FRAC: usize> Sub<u64> for FastFixed<i64, FRAC>

where i64: PromoteAddSub<u64> + NumCast + Copy, u64: NumCast + Copy, <i64 as PromoteAddSub<u64>>::Output: Bounded + NumCast + Copy + FastInt,

type Output = FastFixed<<i64 as PromoteAddSub<u64>>::Output, FRAC>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<I, const FRAC: usize, U, const FRAC_R: usize> SubAssign<FastFixed<U, FRAC_R>> for FastFixed<I, FRAC>

where I: PromoteAddSub<U> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt + TryFrom<<I as PromoteAddSub<U>>::Output>, <I as PromoteAddSub<U>>::Output: FastInt, U: Zero + PartialOrd + NumCast + Copy, FastFixed<I, FRAC>: Sub<FastFixed<U, FRAC_R>, Output = FastFixed<<I as PromoteAddSub<U>>::Output, FRAC>>,

fn sub_assign(&mut self, rhs: FastFixed<U, FRAC_R>)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<i8> for FastFixed<i8, FRAC>

where i8: PromoteAddSub<i8> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i8 as PromoteAddSub<i8>>::Output: FastInt, FastFixed<i8, FRAC>: Sub<i8, Output = FastFixed<<i8 as PromoteAddSub<i8>>::Output, FRAC>>,

fn sub_assign(&mut self, rhs: i8)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<i8> for FastFixed<i16, FRAC>

where i16: PromoteAddSub<i8> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i16 as PromoteAddSub<i8>>::Output: FastInt, i8: Zero + PartialOrd + NumCast + Copy, FastFixed<i16, FRAC>: Sub<i8, Output = FastFixed<<i16 as PromoteAddSub<i8>>::Output, FRAC>>,

fn sub_assign(&mut self, rhs: i8)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<i8> for FastFixed<i32, FRAC>

where i32: PromoteAddSub<i8> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i32 as PromoteAddSub<i8>>::Output: FastInt, i8: Zero + PartialOrd + NumCast + Copy, FastFixed<i32, FRAC>: Sub<i8, Output = FastFixed<<i32 as PromoteAddSub<i8>>::Output, FRAC>>,

fn sub_assign(&mut self, rhs: i8)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<i8> for FastFixed<i64, FRAC>

where i64: PromoteAddSub<i8> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i64 as PromoteAddSub<i8>>::Output: FastInt, i8: Zero + PartialOrd + NumCast + Copy, FastFixed<i64, FRAC>: Sub<i8, Output = FastFixed<<i64 as PromoteAddSub<i8>>::Output, FRAC>>,

fn sub_assign(&mut self, rhs: i8)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<i8> for FastFixed<u8, FRAC>

where u8: PromoteAddSub<i8> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u8 as PromoteAddSub<i8>>::Output: FastInt, i8: Zero + PartialOrd + NumCast + Copy, FastFixed<u8, FRAC>: Sub<i8, Output = FastFixed<<u8 as PromoteAddSub<i8>>::Output, FRAC>>,

fn sub_assign(&mut self, rhs: i8)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<i8> for FastFixed<u16, FRAC>

where u16: PromoteAddSub<i8> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u16 as PromoteAddSub<i8>>::Output: FastInt, i8: Zero + PartialOrd + NumCast + Copy, FastFixed<u16, FRAC>: Sub<i8, Output = FastFixed<<u16 as PromoteAddSub<i8>>::Output, FRAC>>,

fn sub_assign(&mut self, rhs: i8)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<i8> for FastFixed<u32, FRAC>

where u32: PromoteAddSub<i8> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u32 as PromoteAddSub<i8>>::Output: FastInt, i8: Zero + PartialOrd + NumCast + Copy, FastFixed<u32, FRAC>: Sub<i8, Output = FastFixed<<u32 as PromoteAddSub<i8>>::Output, FRAC>>,

fn sub_assign(&mut self, rhs: i8)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<i8> for FastFixed<u64, FRAC>

where u64: PromoteAddSub<i8> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u64 as PromoteAddSub<i8>>::Output: FastInt, i8: Zero + PartialOrd + NumCast + Copy, FastFixed<u64, FRAC>: Sub<i8, Output = FastFixed<<u64 as PromoteAddSub<i8>>::Output, FRAC>>,

fn sub_assign(&mut self, rhs: i8)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<i16> for FastFixed<i8, FRAC>

where i8: PromoteAddSub<i16> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i8 as PromoteAddSub<i16>>::Output: FastInt, i16: Zero + PartialOrd + NumCast + Copy, FastFixed<i8, FRAC>: Sub<i16, Output = FastFixed<<i8 as PromoteAddSub<i16>>::Output, FRAC>>,

fn sub_assign(&mut self, rhs: i16)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<i16> for FastFixed<i16, FRAC>

where i16: PromoteAddSub<i16> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i16 as PromoteAddSub<i16>>::Output: FastInt, FastFixed<i16, FRAC>: Sub<i16, Output = FastFixed<<i16 as PromoteAddSub<i16>>::Output, FRAC>>,

fn sub_assign(&mut self, rhs: i16)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<i16> for FastFixed<i32, FRAC>

where i32: PromoteAddSub<i16> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i32 as PromoteAddSub<i16>>::Output: FastInt, i16: Zero + PartialOrd + NumCast + Copy, FastFixed<i32, FRAC>: Sub<i16, Output = FastFixed<<i32 as PromoteAddSub<i16>>::Output, FRAC>>,

fn sub_assign(&mut self, rhs: i16)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<i16> for FastFixed<i64, FRAC>

where i64: PromoteAddSub<i16> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i64 as PromoteAddSub<i16>>::Output: FastInt, i16: Zero + PartialOrd + NumCast + Copy, FastFixed<i64, FRAC>: Sub<i16, Output = FastFixed<<i64 as PromoteAddSub<i16>>::Output, FRAC>>,

fn sub_assign(&mut self, rhs: i16)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<i16> for FastFixed<u8, FRAC>

where u8: PromoteAddSub<i16> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u8 as PromoteAddSub<i16>>::Output: FastInt, i16: Zero + PartialOrd + NumCast + Copy, FastFixed<u8, FRAC>: Sub<i16, Output = FastFixed<<u8 as PromoteAddSub<i16>>::Output, FRAC>>,

fn sub_assign(&mut self, rhs: i16)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<i16> for FastFixed<u16, FRAC>

where u16: PromoteAddSub<i16> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u16 as PromoteAddSub<i16>>::Output: FastInt, i16: Zero + PartialOrd + NumCast + Copy, FastFixed<u16, FRAC>: Sub<i16, Output = FastFixed<<u16 as PromoteAddSub<i16>>::Output, FRAC>>,

fn sub_assign(&mut self, rhs: i16)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<i16> for FastFixed<u32, FRAC>

where u32: PromoteAddSub<i16> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u32 as PromoteAddSub<i16>>::Output: FastInt, i16: Zero + PartialOrd + NumCast + Copy, FastFixed<u32, FRAC>: Sub<i16, Output = FastFixed<<u32 as PromoteAddSub<i16>>::Output, FRAC>>,

fn sub_assign(&mut self, rhs: i16)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<i16> for FastFixed<u64, FRAC>

where u64: PromoteAddSub<i16> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u64 as PromoteAddSub<i16>>::Output: FastInt, i16: Zero + PartialOrd + NumCast + Copy, FastFixed<u64, FRAC>: Sub<i16, Output = FastFixed<<u64 as PromoteAddSub<i16>>::Output, FRAC>>,

fn sub_assign(&mut self, rhs: i16)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<i32> for FastFixed<i8, FRAC>

where i8: PromoteAddSub<i32> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i8 as PromoteAddSub<i32>>::Output: FastInt, i32: Zero + PartialOrd + NumCast + Copy, FastFixed<i8, FRAC>: Sub<i32, Output = FastFixed<<i8 as PromoteAddSub<i32>>::Output, FRAC>>,

fn sub_assign(&mut self, rhs: i32)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<i32> for FastFixed<i16, FRAC>

where i16: PromoteAddSub<i32> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i16 as PromoteAddSub<i32>>::Output: FastInt, i32: Zero + PartialOrd + NumCast + Copy, FastFixed<i16, FRAC>: Sub<i32, Output = FastFixed<<i16 as PromoteAddSub<i32>>::Output, FRAC>>,

fn sub_assign(&mut self, rhs: i32)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<i32> for FastFixed<i32, FRAC>

where i32: PromoteAddSub<i32> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i32 as PromoteAddSub<i32>>::Output: FastInt, FastFixed<i32, FRAC>: Sub<i32, Output = FastFixed<<i32 as PromoteAddSub<i32>>::Output, FRAC>>,

fn sub_assign(&mut self, rhs: i32)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<i32> for FastFixed<i64, FRAC>

where i64: PromoteAddSub<i32> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i64 as PromoteAddSub<i32>>::Output: FastInt, i32: Zero + PartialOrd + NumCast + Copy, FastFixed<i64, FRAC>: Sub<i32, Output = FastFixed<<i64 as PromoteAddSub<i32>>::Output, FRAC>>,

fn sub_assign(&mut self, rhs: i32)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<i32> for FastFixed<u8, FRAC>

where u8: PromoteAddSub<i32> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u8 as PromoteAddSub<i32>>::Output: FastInt, i32: Zero + PartialOrd + NumCast + Copy, FastFixed<u8, FRAC>: Sub<i32, Output = FastFixed<<u8 as PromoteAddSub<i32>>::Output, FRAC>>,

fn sub_assign(&mut self, rhs: i32)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<i32> for FastFixed<u16, FRAC>

where u16: PromoteAddSub<i32> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u16 as PromoteAddSub<i32>>::Output: FastInt, i32: Zero + PartialOrd + NumCast + Copy, FastFixed<u16, FRAC>: Sub<i32, Output = FastFixed<<u16 as PromoteAddSub<i32>>::Output, FRAC>>,

fn sub_assign(&mut self, rhs: i32)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<i32> for FastFixed<u32, FRAC>

where u32: PromoteAddSub<i32> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u32 as PromoteAddSub<i32>>::Output: FastInt, i32: Zero + PartialOrd + NumCast + Copy, FastFixed<u32, FRAC>: Sub<i32, Output = FastFixed<<u32 as PromoteAddSub<i32>>::Output, FRAC>>,

fn sub_assign(&mut self, rhs: i32)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<i32> for FastFixed<u64, FRAC>

where u64: PromoteAddSub<i32> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u64 as PromoteAddSub<i32>>::Output: FastInt, i32: Zero + PartialOrd + NumCast + Copy, FastFixed<u64, FRAC>: Sub<i32, Output = FastFixed<<u64 as PromoteAddSub<i32>>::Output, FRAC>>,

fn sub_assign(&mut self, rhs: i32)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<i64> for FastFixed<i8, FRAC>

where i8: PromoteAddSub<i64> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i8 as PromoteAddSub<i64>>::Output: FastInt, i64: Zero + PartialOrd + NumCast + Copy, FastFixed<i8, FRAC>: Sub<i64, Output = FastFixed<<i8 as PromoteAddSub<i64>>::Output, FRAC>>,

fn sub_assign(&mut self, rhs: i64)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<i64> for FastFixed<i16, FRAC>

where i16: PromoteAddSub<i64> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i16 as PromoteAddSub<i64>>::Output: FastInt, i64: Zero + PartialOrd + NumCast + Copy, FastFixed<i16, FRAC>: Sub<i64, Output = FastFixed<<i16 as PromoteAddSub<i64>>::Output, FRAC>>,

fn sub_assign(&mut self, rhs: i64)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<i64> for FastFixed<i32, FRAC>

where i32: PromoteAddSub<i64> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i32 as PromoteAddSub<i64>>::Output: FastInt, i64: Zero + PartialOrd + NumCast + Copy, FastFixed<i32, FRAC>: Sub<i64, Output = FastFixed<<i32 as PromoteAddSub<i64>>::Output, FRAC>>,

fn sub_assign(&mut self, rhs: i64)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<i64> for FastFixed<i64, FRAC>

where i64: PromoteAddSub<i64> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i64 as PromoteAddSub<i64>>::Output: FastInt, FastFixed<i64, FRAC>: Sub<i64, Output = FastFixed<<i64 as PromoteAddSub<i64>>::Output, FRAC>>,

fn sub_assign(&mut self, rhs: i64)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<i64> for FastFixed<u8, FRAC>

where u8: PromoteAddSub<i64> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u8 as PromoteAddSub<i64>>::Output: FastInt, i64: Zero + PartialOrd + NumCast + Copy, FastFixed<u8, FRAC>: Sub<i64, Output = FastFixed<<u8 as PromoteAddSub<i64>>::Output, FRAC>>,

fn sub_assign(&mut self, rhs: i64)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<i64> for FastFixed<u16, FRAC>

where u16: PromoteAddSub<i64> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u16 as PromoteAddSub<i64>>::Output: FastInt, i64: Zero + PartialOrd + NumCast + Copy, FastFixed<u16, FRAC>: Sub<i64, Output = FastFixed<<u16 as PromoteAddSub<i64>>::Output, FRAC>>,

fn sub_assign(&mut self, rhs: i64)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<i64> for FastFixed<u32, FRAC>

where u32: PromoteAddSub<i64> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u32 as PromoteAddSub<i64>>::Output: FastInt, i64: Zero + PartialOrd + NumCast + Copy, FastFixed<u32, FRAC>: Sub<i64, Output = FastFixed<<u32 as PromoteAddSub<i64>>::Output, FRAC>>,

fn sub_assign(&mut self, rhs: i64)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<i64> for FastFixed<u64, FRAC>

where u64: PromoteAddSub<i64> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u64 as PromoteAddSub<i64>>::Output: FastInt, i64: Zero + PartialOrd + NumCast + Copy, FastFixed<u64, FRAC>: Sub<i64, Output = FastFixed<<u64 as PromoteAddSub<i64>>::Output, FRAC>>,

fn sub_assign(&mut self, rhs: i64)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<u8> for FastFixed<u8, FRAC>

where u8: PromoteAddSub<u8> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u8 as PromoteAddSub<u8>>::Output: FastInt, FastFixed<u8, FRAC>: Sub<u8, Output = FastFixed<<u8 as PromoteAddSub<u8>>::Output, FRAC>>,

fn sub_assign(&mut self, rhs: u8)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<u8> for FastFixed<u16, FRAC>

where u16: PromoteAddSub<u8> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u16 as PromoteAddSub<u8>>::Output: FastInt, u8: Zero + PartialOrd + NumCast + Copy, FastFixed<u16, FRAC>: Sub<u8, Output = FastFixed<<u16 as PromoteAddSub<u8>>::Output, FRAC>>,

fn sub_assign(&mut self, rhs: u8)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<u8> for FastFixed<u32, FRAC>

where u32: PromoteAddSub<u8> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u32 as PromoteAddSub<u8>>::Output: FastInt, u8: Zero + PartialOrd + NumCast + Copy, FastFixed<u32, FRAC>: Sub<u8, Output = FastFixed<<u32 as PromoteAddSub<u8>>::Output, FRAC>>,

fn sub_assign(&mut self, rhs: u8)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<u8> for FastFixed<u64, FRAC>

where u64: PromoteAddSub<u8> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u64 as PromoteAddSub<u8>>::Output: FastInt, u8: Zero + PartialOrd + NumCast + Copy, FastFixed<u64, FRAC>: Sub<u8, Output = FastFixed<<u64 as PromoteAddSub<u8>>::Output, FRAC>>,

fn sub_assign(&mut self, rhs: u8)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<u8> for FastFixed<i8, FRAC>

where i8: PromoteAddSub<u8> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i8 as PromoteAddSub<u8>>::Output: FastInt, u8: Zero + PartialOrd + NumCast + Copy, FastFixed<i8, FRAC>: Sub<u8, Output = FastFixed<<i8 as PromoteAddSub<u8>>::Output, FRAC>>,

fn sub_assign(&mut self, rhs: u8)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<u8> for FastFixed<i16, FRAC>

where i16: PromoteAddSub<u8> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i16 as PromoteAddSub<u8>>::Output: FastInt, u8: Zero + PartialOrd + NumCast + Copy, FastFixed<i16, FRAC>: Sub<u8, Output = FastFixed<<i16 as PromoteAddSub<u8>>::Output, FRAC>>,

fn sub_assign(&mut self, rhs: u8)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<u8> for FastFixed<i32, FRAC>

where i32: PromoteAddSub<u8> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i32 as PromoteAddSub<u8>>::Output: FastInt, u8: Zero + PartialOrd + NumCast + Copy, FastFixed<i32, FRAC>: Sub<u8, Output = FastFixed<<i32 as PromoteAddSub<u8>>::Output, FRAC>>,

fn sub_assign(&mut self, rhs: u8)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<u8> for FastFixed<i64, FRAC>

where i64: PromoteAddSub<u8> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i64 as PromoteAddSub<u8>>::Output: FastInt, u8: Zero + PartialOrd + NumCast + Copy, FastFixed<i64, FRAC>: Sub<u8, Output = FastFixed<<i64 as PromoteAddSub<u8>>::Output, FRAC>>,

fn sub_assign(&mut self, rhs: u8)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<u16> for FastFixed<u8, FRAC>

where u8: PromoteAddSub<u16> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u8 as PromoteAddSub<u16>>::Output: FastInt, u16: Zero + PartialOrd + NumCast + Copy, FastFixed<u8, FRAC>: Sub<u16, Output = FastFixed<<u8 as PromoteAddSub<u16>>::Output, FRAC>>,

fn sub_assign(&mut self, rhs: u16)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<u16> for FastFixed<u16, FRAC>

where u16: PromoteAddSub<u16> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u16 as PromoteAddSub<u16>>::Output: FastInt, FastFixed<u16, FRAC>: Sub<u16, Output = FastFixed<<u16 as PromoteAddSub<u16>>::Output, FRAC>>,

fn sub_assign(&mut self, rhs: u16)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<u16> for FastFixed<u32, FRAC>

where u32: PromoteAddSub<u16> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u32 as PromoteAddSub<u16>>::Output: FastInt, u16: Zero + PartialOrd + NumCast + Copy, FastFixed<u32, FRAC>: Sub<u16, Output = FastFixed<<u32 as PromoteAddSub<u16>>::Output, FRAC>>,

fn sub_assign(&mut self, rhs: u16)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<u16> for FastFixed<u64, FRAC>

where u64: PromoteAddSub<u16> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u64 as PromoteAddSub<u16>>::Output: FastInt, u16: Zero + PartialOrd + NumCast + Copy, FastFixed<u64, FRAC>: Sub<u16, Output = FastFixed<<u64 as PromoteAddSub<u16>>::Output, FRAC>>,

fn sub_assign(&mut self, rhs: u16)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<u16> for FastFixed<i8, FRAC>

where i8: PromoteAddSub<u16> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i8 as PromoteAddSub<u16>>::Output: FastInt, u16: Zero + PartialOrd + NumCast + Copy, FastFixed<i8, FRAC>: Sub<u16, Output = FastFixed<<i8 as PromoteAddSub<u16>>::Output, FRAC>>,

fn sub_assign(&mut self, rhs: u16)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<u16> for FastFixed<i16, FRAC>

where i16: PromoteAddSub<u16> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i16 as PromoteAddSub<u16>>::Output: FastInt, u16: Zero + PartialOrd + NumCast + Copy, FastFixed<i16, FRAC>: Sub<u16, Output = FastFixed<<i16 as PromoteAddSub<u16>>::Output, FRAC>>,

fn sub_assign(&mut self, rhs: u16)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<u16> for FastFixed<i32, FRAC>

where i32: PromoteAddSub<u16> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i32 as PromoteAddSub<u16>>::Output: FastInt, u16: Zero + PartialOrd + NumCast + Copy, FastFixed<i32, FRAC>: Sub<u16, Output = FastFixed<<i32 as PromoteAddSub<u16>>::Output, FRAC>>,

fn sub_assign(&mut self, rhs: u16)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<u16> for FastFixed<i64, FRAC>

where i64: PromoteAddSub<u16> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i64 as PromoteAddSub<u16>>::Output: FastInt, u16: Zero + PartialOrd + NumCast + Copy, FastFixed<i64, FRAC>: Sub<u16, Output = FastFixed<<i64 as PromoteAddSub<u16>>::Output, FRAC>>,

fn sub_assign(&mut self, rhs: u16)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<u32> for FastFixed<u8, FRAC>

where u8: PromoteAddSub<u32> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u8 as PromoteAddSub<u32>>::Output: FastInt, u32: Zero + PartialOrd + NumCast + Copy, FastFixed<u8, FRAC>: Sub<u32, Output = FastFixed<<u8 as PromoteAddSub<u32>>::Output, FRAC>>,

fn sub_assign(&mut self, rhs: u32)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<u32> for FastFixed<u16, FRAC>

where u16: PromoteAddSub<u32> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u16 as PromoteAddSub<u32>>::Output: FastInt, u32: Zero + PartialOrd + NumCast + Copy, FastFixed<u16, FRAC>: Sub<u32, Output = FastFixed<<u16 as PromoteAddSub<u32>>::Output, FRAC>>,

fn sub_assign(&mut self, rhs: u32)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<u32> for FastFixed<u32, FRAC>

where u32: PromoteAddSub<u32> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u32 as PromoteAddSub<u32>>::Output: FastInt, FastFixed<u32, FRAC>: Sub<u32, Output = FastFixed<<u32 as PromoteAddSub<u32>>::Output, FRAC>>,

fn sub_assign(&mut self, rhs: u32)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<u32> for FastFixed<u64, FRAC>

where u64: PromoteAddSub<u32> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u64 as PromoteAddSub<u32>>::Output: FastInt, u32: Zero + PartialOrd + NumCast + Copy, FastFixed<u64, FRAC>: Sub<u32, Output = FastFixed<<u64 as PromoteAddSub<u32>>::Output, FRAC>>,

fn sub_assign(&mut self, rhs: u32)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<u32> for FastFixed<i8, FRAC>

where i8: PromoteAddSub<u32> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i8 as PromoteAddSub<u32>>::Output: FastInt, u32: Zero + PartialOrd + NumCast + Copy, FastFixed<i8, FRAC>: Sub<u32, Output = FastFixed<<i8 as PromoteAddSub<u32>>::Output, FRAC>>,

fn sub_assign(&mut self, rhs: u32)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<u32> for FastFixed<i16, FRAC>

where i16: PromoteAddSub<u32> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i16 as PromoteAddSub<u32>>::Output: FastInt, u32: Zero + PartialOrd + NumCast + Copy, FastFixed<i16, FRAC>: Sub<u32, Output = FastFixed<<i16 as PromoteAddSub<u32>>::Output, FRAC>>,

fn sub_assign(&mut self, rhs: u32)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<u32> for FastFixed<i32, FRAC>

where i32: PromoteAddSub<u32> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i32 as PromoteAddSub<u32>>::Output: FastInt, u32: Zero + PartialOrd + NumCast + Copy, FastFixed<i32, FRAC>: Sub<u32, Output = FastFixed<<i32 as PromoteAddSub<u32>>::Output, FRAC>>,

fn sub_assign(&mut self, rhs: u32)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<u32> for FastFixed<i64, FRAC>

where i64: PromoteAddSub<u32> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i64 as PromoteAddSub<u32>>::Output: FastInt, u32: Zero + PartialOrd + NumCast + Copy, FastFixed<i64, FRAC>: Sub<u32, Output = FastFixed<<i64 as PromoteAddSub<u32>>::Output, FRAC>>,

fn sub_assign(&mut self, rhs: u32)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<u64> for FastFixed<u8, FRAC>

where u8: PromoteAddSub<u64> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u8 as PromoteAddSub<u64>>::Output: FastInt, u64: Zero + PartialOrd + NumCast + Copy, FastFixed<u8, FRAC>: Sub<u64, Output = FastFixed<<u8 as PromoteAddSub<u64>>::Output, FRAC>>,

fn sub_assign(&mut self, rhs: u64)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<u64> for FastFixed<u16, FRAC>

where u16: PromoteAddSub<u64> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u16 as PromoteAddSub<u64>>::Output: FastInt, u64: Zero + PartialOrd + NumCast + Copy, FastFixed<u16, FRAC>: Sub<u64, Output = FastFixed<<u16 as PromoteAddSub<u64>>::Output, FRAC>>,

fn sub_assign(&mut self, rhs: u64)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<u64> for FastFixed<u32, FRAC>

where u32: PromoteAddSub<u64> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u32 as PromoteAddSub<u64>>::Output: FastInt, u64: Zero + PartialOrd + NumCast + Copy, FastFixed<u32, FRAC>: Sub<u64, Output = FastFixed<<u32 as PromoteAddSub<u64>>::Output, FRAC>>,

fn sub_assign(&mut self, rhs: u64)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<u64> for FastFixed<u64, FRAC>

where u64: PromoteAddSub<u64> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <u64 as PromoteAddSub<u64>>::Output: FastInt, FastFixed<u64, FRAC>: Sub<u64, Output = FastFixed<<u64 as PromoteAddSub<u64>>::Output, FRAC>>,

fn sub_assign(&mut self, rhs: u64)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<u64> for FastFixed<i8, FRAC>

where i8: PromoteAddSub<u64> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i8 as PromoteAddSub<u64>>::Output: FastInt, u64: Zero + PartialOrd + NumCast + Copy, FastFixed<i8, FRAC>: Sub<u64, Output = FastFixed<<i8 as PromoteAddSub<u64>>::Output, FRAC>>,

fn sub_assign(&mut self, rhs: u64)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<u64> for FastFixed<i16, FRAC>

where i16: PromoteAddSub<u64> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i16 as PromoteAddSub<u64>>::Output: FastInt, u64: Zero + PartialOrd + NumCast + Copy, FastFixed<i16, FRAC>: Sub<u64, Output = FastFixed<<i16 as PromoteAddSub<u64>>::Output, FRAC>>,

fn sub_assign(&mut self, rhs: u64)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<u64> for FastFixed<i32, FRAC>

where i32: PromoteAddSub<u64> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i32 as PromoteAddSub<u64>>::Output: FastInt, u64: Zero + PartialOrd + NumCast + Copy, FastFixed<i32, FRAC>: Sub<u64, Output = FastFixed<<i32 as PromoteAddSub<u64>>::Output, FRAC>>,

fn sub_assign(&mut self, rhs: u64)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<u64> for FastFixed<i64, FRAC>

where i64: PromoteAddSub<u64> + Zero + PartialOrd + Bounded + NumCast + Copy + FastInt, <i64 as PromoteAddSub<u64>>::Output: FastInt, u64: Zero + PartialOrd + NumCast + Copy, FastFixed<i64, FRAC>: Sub<u64, Output = FastFixed<<i64 as PromoteAddSub<u64>>::Output, FRAC>>,

fn sub_assign(&mut self, rhs: u64)

Performs the -= operation.