Struct Fixed 

pub struct Fixed<I, const FRAC: usize> { /* private fields */ }

A fixed-point number represented by an underlying integer type and a fractional bit depth.

Fixed provides precise, saturating arithmetic operations with convergent rounding.

Generics

• I: The underlying integer type (e.g. i32, i64).
• FRAC: The number of bits reserved for the fractional component.

Implementations

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

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

Returns the given raw integer as a fixed-point value in this format.

pub const fn raw_value(&self) -> I

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

pub const fn value(&self) -> Value<I, FRAC>

Returns the fixed-point value as an intermediate value type.

pub fn from_ratio(numerator: I, denominator: I) -> Self

where I: Bounded + NumCast + Copy, Value<I, 0>: ConvertValue<i128, FRAC>,

Returns a Fixed value representing the ratio between numerator and denominator.

pub fn mul_to<U, const FRAC_R: usize, R, const FRAC_OUT: usize>( self, other: Fixed<U, FRAC_R>, ) -> Fixed<R, FRAC_OUT>

where I: Into<i128> + Copy, U: Into<i128> + Copy, R: Bounded + NumCast + Copy,

Multiplies self with another Fixed value and scales directly to target resolution.

impl<I: Bounded + NumCast + Copy, const FRAC: usize> Fixed<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.

pub fn epsilon() -> Self

where I: One,

Returns the smallest positive value of this fixed point format.

pub fn from_integer(val: i128) -> Self

where I: Bounded + NumCast + Copy, Value<I, 0>: ConvertValue<I, FRAC>,

Explicit conversion from an integer value.

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

where Value<OtherI, OTHER_FRAC>: ConvertValue<I, FRAC>,

Explicit conversion from another fixed-point format.

impl<I, const FRAC: usize> Fixed<I, FRAC>

pub fn ceiling(&self) -> I

where I: Bounded + NumCast + Copy + Into<i128> + One + Zero,

Returns the closest integer value greater-than or equal-to this fixed-point value.

pub fn floor(&self) -> I

where I: Bounded + NumCast + Copy + Into<i128> + Zero,

Returns the closest integer value less-than or equal-to this fixed-point value.

pub fn round(&self) -> I

where I: Bounded + NumCast + Copy + Into<i128> + Zero,

Returns the rounded value of this fixed-point value as an integer.

pub fn integral(&self) -> Self

where I: Bounded + NumCast + PartialOrd + Copy,

Returns the integral component of this fixed-point value.

pub fn fraction(&self) -> Self

where I: Bounded + NumCast + PartialOrd + Copy + Zero + Sub<Output = I>,

Returns the fractional component of this fixed-point value.

pub fn absolute(&self) -> Self

where I: Bounded + NumCast + Copy + Into<i128>,

Returns the absolute value of this fixed-point value.

Note: If the underlying value is the minimum value representable by a signed type (e.g., I::MIN), its mathematical absolute value cannot be represented and will saturate to I::MAX.

impl<I, const FRAC: usize> Fixed<I, FRAC>

pub fn rational(&self) -> RationalFormatter<'_, I, FRAC>

Returns a helper that displays the fixed-point number formatted as a rational fraction (e.g., 1+1/2).

Trait Implementations

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

where T: PromoteAddSub<U> + Copy, U: Copy, T::Output: Bounded + NumCast + Copy, Value<T, FRAC>: ConvertValue<i128, FRAC>, Value<U, FRAC_R>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

where i8: PromoteAddSub<i8> + Copy, <i8 as PromoteAddSub<i8>>::Output: Bounded + NumCast + Copy, Value<i8, FRAC>: ConvertValue<i128, FRAC>, Value<i8, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

where i8: PromoteAddSub<i16> + Copy, i16: Copy, <i8 as PromoteAddSub<i16>>::Output: Bounded + NumCast + Copy, Value<i8, FRAC>: ConvertValue<i128, FRAC>, Value<i16, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

where i8: PromoteAddSub<i32> + Copy, i32: Copy, <i8 as PromoteAddSub<i32>>::Output: Bounded + NumCast + Copy, Value<i8, FRAC>: ConvertValue<i128, FRAC>, Value<i32, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

where i8: PromoteAddSub<i64> + Copy, i64: Copy, <i8 as PromoteAddSub<i64>>::Output: Bounded + NumCast + Copy, Value<i8, FRAC>: ConvertValue<i128, FRAC>, Value<i64, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

where i8: PromoteAddSub<u8> + Copy, u8: Copy, <i8 as PromoteAddSub<u8>>::Output: Bounded + NumCast + Copy, Value<i8, FRAC>: ConvertValue<i128, FRAC>, Value<u8, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

where i8: PromoteAddSub<u16> + Copy, u16: Copy, <i8 as PromoteAddSub<u16>>::Output: Bounded + NumCast + Copy, Value<i8, FRAC>: ConvertValue<i128, FRAC>, Value<u16, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

where i8: PromoteAddSub<u32> + Copy, u32: Copy, <i8 as PromoteAddSub<u32>>::Output: Bounded + NumCast + Copy, Value<i8, FRAC>: ConvertValue<i128, FRAC>, Value<u32, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

where i8: PromoteAddSub<u64> + Copy, u64: Copy, <i8 as PromoteAddSub<u64>>::Output: Bounded + NumCast + Copy, Value<i8, FRAC>: ConvertValue<i128, FRAC>, Value<u64, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

where i16: PromoteAddSub<i8> + Copy, i8: Copy, <i16 as PromoteAddSub<i8>>::Output: Bounded + NumCast + Copy, Value<i16, FRAC>: ConvertValue<i128, FRAC>, Value<i8, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

where i16: PromoteAddSub<i16> + Copy, <i16 as PromoteAddSub<i16>>::Output: Bounded + NumCast + Copy, Value<i16, FRAC>: ConvertValue<i128, FRAC>, Value<i16, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

where i16: PromoteAddSub<i32> + Copy, i32: Copy, <i16 as PromoteAddSub<i32>>::Output: Bounded + NumCast + Copy, Value<i16, FRAC>: ConvertValue<i128, FRAC>, Value<i32, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

where i16: PromoteAddSub<i64> + Copy, i64: Copy, <i16 as PromoteAddSub<i64>>::Output: Bounded + NumCast + Copy, Value<i16, FRAC>: ConvertValue<i128, FRAC>, Value<i64, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

where i16: PromoteAddSub<u8> + Copy, u8: Copy, <i16 as PromoteAddSub<u8>>::Output: Bounded + NumCast + Copy, Value<i16, FRAC>: ConvertValue<i128, FRAC>, Value<u8, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

where i16: PromoteAddSub<u16> + Copy, u16: Copy, <i16 as PromoteAddSub<u16>>::Output: Bounded + NumCast + Copy, Value<i16, FRAC>: ConvertValue<i128, FRAC>, Value<u16, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

where i16: PromoteAddSub<u32> + Copy, u32: Copy, <i16 as PromoteAddSub<u32>>::Output: Bounded + NumCast + Copy, Value<i16, FRAC>: ConvertValue<i128, FRAC>, Value<u32, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

where i16: PromoteAddSub<u64> + Copy, u64: Copy, <i16 as PromoteAddSub<u64>>::Output: Bounded + NumCast + Copy, Value<i16, FRAC>: ConvertValue<i128, FRAC>, Value<u64, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

where i32: PromoteAddSub<i8> + Copy, i8: Copy, <i32 as PromoteAddSub<i8>>::Output: Bounded + NumCast + Copy, Value<i32, FRAC>: ConvertValue<i128, FRAC>, Value<i8, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

where i32: PromoteAddSub<i16> + Copy, i16: Copy, <i32 as PromoteAddSub<i16>>::Output: Bounded + NumCast + Copy, Value<i32, FRAC>: ConvertValue<i128, FRAC>, Value<i16, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

where i32: PromoteAddSub<i32> + Copy, <i32 as PromoteAddSub<i32>>::Output: Bounded + NumCast + Copy, Value<i32, FRAC>: ConvertValue<i128, FRAC>, Value<i32, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

where i32: PromoteAddSub<i64> + Copy, i64: Copy, <i32 as PromoteAddSub<i64>>::Output: Bounded + NumCast + Copy, Value<i32, FRAC>: ConvertValue<i128, FRAC>, Value<i64, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

where i32: PromoteAddSub<u8> + Copy, u8: Copy, <i32 as PromoteAddSub<u8>>::Output: Bounded + NumCast + Copy, Value<i32, FRAC>: ConvertValue<i128, FRAC>, Value<u8, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

where i32: PromoteAddSub<u16> + Copy, u16: Copy, <i32 as PromoteAddSub<u16>>::Output: Bounded + NumCast + Copy, Value<i32, FRAC>: ConvertValue<i128, FRAC>, Value<u16, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

where i32: PromoteAddSub<u32> + Copy, u32: Copy, <i32 as PromoteAddSub<u32>>::Output: Bounded + NumCast + Copy, Value<i32, FRAC>: ConvertValue<i128, FRAC>, Value<u32, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

where i32: PromoteAddSub<u64> + Copy, u64: Copy, <i32 as PromoteAddSub<u64>>::Output: Bounded + NumCast + Copy, Value<i32, FRAC>: ConvertValue<i128, FRAC>, Value<u64, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

where i64: PromoteAddSub<i8> + Copy, i8: Copy, <i64 as PromoteAddSub<i8>>::Output: Bounded + NumCast + Copy, Value<i64, FRAC>: ConvertValue<i128, FRAC>, Value<i8, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

where i64: PromoteAddSub<i16> + Copy, i16: Copy, <i64 as PromoteAddSub<i16>>::Output: Bounded + NumCast + Copy, Value<i64, FRAC>: ConvertValue<i128, FRAC>, Value<i16, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

where i64: PromoteAddSub<i32> + Copy, i32: Copy, <i64 as PromoteAddSub<i32>>::Output: Bounded + NumCast + Copy, Value<i64, FRAC>: ConvertValue<i128, FRAC>, Value<i32, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

where i64: PromoteAddSub<i64> + Copy, <i64 as PromoteAddSub<i64>>::Output: Bounded + NumCast + Copy, Value<i64, FRAC>: ConvertValue<i128, FRAC>, Value<i64, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

where i64: PromoteAddSub<u8> + Copy, u8: Copy, <i64 as PromoteAddSub<u8>>::Output: Bounded + NumCast + Copy, Value<i64, FRAC>: ConvertValue<i128, FRAC>, Value<u8, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

where i64: PromoteAddSub<u16> + Copy, u16: Copy, <i64 as PromoteAddSub<u16>>::Output: Bounded + NumCast + Copy, Value<i64, FRAC>: ConvertValue<i128, FRAC>, Value<u16, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

where i64: PromoteAddSub<u32> + Copy, u32: Copy, <i64 as PromoteAddSub<u32>>::Output: Bounded + NumCast + Copy, Value<i64, FRAC>: ConvertValue<i128, FRAC>, Value<u32, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

where i64: PromoteAddSub<u64> + Copy, u64: Copy, <i64 as PromoteAddSub<u64>>::Output: Bounded + NumCast + Copy, Value<i64, FRAC>: ConvertValue<i128, FRAC>, Value<u64, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

where u8: PromoteAddSub<u8> + Copy, <u8 as PromoteAddSub<u8>>::Output: Bounded + NumCast + Copy, Value<u8, FRAC>: ConvertValue<i128, FRAC>, Value<u8, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

where u8: PromoteAddSub<u16> + Copy, u16: Copy, <u8 as PromoteAddSub<u16>>::Output: Bounded + NumCast + Copy, Value<u8, FRAC>: ConvertValue<i128, FRAC>, Value<u16, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

where u8: PromoteAddSub<u32> + Copy, u32: Copy, <u8 as PromoteAddSub<u32>>::Output: Bounded + NumCast + Copy, Value<u8, FRAC>: ConvertValue<i128, FRAC>, Value<u32, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

where u8: PromoteAddSub<u64> + Copy, u64: Copy, <u8 as PromoteAddSub<u64>>::Output: Bounded + NumCast + Copy, Value<u8, FRAC>: ConvertValue<i128, FRAC>, Value<u64, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

where u8: PromoteAddSub<i8> + Copy, i8: Copy, <u8 as PromoteAddSub<i8>>::Output: Bounded + NumCast + Copy, Value<u8, FRAC>: ConvertValue<i128, FRAC>, Value<i8, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

where u8: PromoteAddSub<i16> + Copy, i16: Copy, <u8 as PromoteAddSub<i16>>::Output: Bounded + NumCast + Copy, Value<u8, FRAC>: ConvertValue<i128, FRAC>, Value<i16, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

where u8: PromoteAddSub<i32> + Copy, i32: Copy, <u8 as PromoteAddSub<i32>>::Output: Bounded + NumCast + Copy, Value<u8, FRAC>: ConvertValue<i128, FRAC>, Value<i32, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

where u8: PromoteAddSub<i64> + Copy, i64: Copy, <u8 as PromoteAddSub<i64>>::Output: Bounded + NumCast + Copy, Value<u8, FRAC>: ConvertValue<i128, FRAC>, Value<i64, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

where u16: PromoteAddSub<u8> + Copy, u8: Copy, <u16 as PromoteAddSub<u8>>::Output: Bounded + NumCast + Copy, Value<u16, FRAC>: ConvertValue<i128, FRAC>, Value<u8, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

where u16: PromoteAddSub<u16> + Copy, <u16 as PromoteAddSub<u16>>::Output: Bounded + NumCast + Copy, Value<u16, FRAC>: ConvertValue<i128, FRAC>, Value<u16, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

where u16: PromoteAddSub<u32> + Copy, u32: Copy, <u16 as PromoteAddSub<u32>>::Output: Bounded + NumCast + Copy, Value<u16, FRAC>: ConvertValue<i128, FRAC>, Value<u32, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

where u16: PromoteAddSub<u64> + Copy, u64: Copy, <u16 as PromoteAddSub<u64>>::Output: Bounded + NumCast + Copy, Value<u16, FRAC>: ConvertValue<i128, FRAC>, Value<u64, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

where u16: PromoteAddSub<i8> + Copy, i8: Copy, <u16 as PromoteAddSub<i8>>::Output: Bounded + NumCast + Copy, Value<u16, FRAC>: ConvertValue<i128, FRAC>, Value<i8, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

where u16: PromoteAddSub<i16> + Copy, i16: Copy, <u16 as PromoteAddSub<i16>>::Output: Bounded + NumCast + Copy, Value<u16, FRAC>: ConvertValue<i128, FRAC>, Value<i16, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

where u16: PromoteAddSub<i32> + Copy, i32: Copy, <u16 as PromoteAddSub<i32>>::Output: Bounded + NumCast + Copy, Value<u16, FRAC>: ConvertValue<i128, FRAC>, Value<i32, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

where u16: PromoteAddSub<i64> + Copy, i64: Copy, <u16 as PromoteAddSub<i64>>::Output: Bounded + NumCast + Copy, Value<u16, FRAC>: ConvertValue<i128, FRAC>, Value<i64, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

where u32: PromoteAddSub<u8> + Copy, u8: Copy, <u32 as PromoteAddSub<u8>>::Output: Bounded + NumCast + Copy, Value<u32, FRAC>: ConvertValue<i128, FRAC>, Value<u8, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

where u32: PromoteAddSub<u16> + Copy, u16: Copy, <u32 as PromoteAddSub<u16>>::Output: Bounded + NumCast + Copy, Value<u32, FRAC>: ConvertValue<i128, FRAC>, Value<u16, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

where u32: PromoteAddSub<u32> + Copy, <u32 as PromoteAddSub<u32>>::Output: Bounded + NumCast + Copy, Value<u32, FRAC>: ConvertValue<i128, FRAC>, Value<u32, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

where u32: PromoteAddSub<u64> + Copy, u64: Copy, <u32 as PromoteAddSub<u64>>::Output: Bounded + NumCast + Copy, Value<u32, FRAC>: ConvertValue<i128, FRAC>, Value<u64, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

where u32: PromoteAddSub<i8> + Copy, i8: Copy, <u32 as PromoteAddSub<i8>>::Output: Bounded + NumCast + Copy, Value<u32, FRAC>: ConvertValue<i128, FRAC>, Value<i8, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

where u32: PromoteAddSub<i16> + Copy, i16: Copy, <u32 as PromoteAddSub<i16>>::Output: Bounded + NumCast + Copy, Value<u32, FRAC>: ConvertValue<i128, FRAC>, Value<i16, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

where u32: PromoteAddSub<i32> + Copy, i32: Copy, <u32 as PromoteAddSub<i32>>::Output: Bounded + NumCast + Copy, Value<u32, FRAC>: ConvertValue<i128, FRAC>, Value<i32, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

where u32: PromoteAddSub<i64> + Copy, i64: Copy, <u32 as PromoteAddSub<i64>>::Output: Bounded + NumCast + Copy, Value<u32, FRAC>: ConvertValue<i128, FRAC>, Value<i64, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

where u64: PromoteAddSub<u8> + Copy, u8: Copy, <u64 as PromoteAddSub<u8>>::Output: Bounded + NumCast + Copy, Value<u64, FRAC>: ConvertValue<i128, FRAC>, Value<u8, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

where u64: PromoteAddSub<u16> + Copy, u16: Copy, <u64 as PromoteAddSub<u16>>::Output: Bounded + NumCast + Copy, Value<u64, FRAC>: ConvertValue<i128, FRAC>, Value<u16, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

where u64: PromoteAddSub<u32> + Copy, u32: Copy, <u64 as PromoteAddSub<u32>>::Output: Bounded + NumCast + Copy, Value<u64, FRAC>: ConvertValue<i128, FRAC>, Value<u32, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

where u64: PromoteAddSub<u64> + Copy, <u64 as PromoteAddSub<u64>>::Output: Bounded + NumCast + Copy, Value<u64, FRAC>: ConvertValue<i128, FRAC>, Value<u64, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

where u64: PromoteAddSub<i8> + Copy, i8: Copy, <u64 as PromoteAddSub<i8>>::Output: Bounded + NumCast + Copy, Value<u64, FRAC>: ConvertValue<i128, FRAC>, Value<i8, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

where u64: PromoteAddSub<i16> + Copy, i16: Copy, <u64 as PromoteAddSub<i16>>::Output: Bounded + NumCast + Copy, Value<u64, FRAC>: ConvertValue<i128, FRAC>, Value<i16, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

where u64: PromoteAddSub<i32> + Copy, i32: Copy, <u64 as PromoteAddSub<i32>>::Output: Bounded + NumCast + Copy, Value<u64, FRAC>: ConvertValue<i128, FRAC>, Value<i32, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

where u64: PromoteAddSub<i64> + Copy, i64: Copy, <u64 as PromoteAddSub<i64>>::Output: Bounded + NumCast + Copy, Value<u64, FRAC>: ConvertValue<i128, FRAC>, Value<i64, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

where i8: PromoteAddSub<i8> + Copy, <i8 as PromoteAddSub<i8>>::Output: Bounded + NumCast + Copy, Value<i8, FRAC>: ConvertValue<i128, FRAC>, Value<i8, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<i16, FRAC>

where i16: PromoteAddSub<i8> + Copy, i8: Copy, <i16 as PromoteAddSub<i8>>::Output: Bounded + NumCast + Copy, Value<i16, FRAC>: ConvertValue<i128, FRAC>, Value<i8, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<i32, FRAC>

where i32: PromoteAddSub<i8> + Copy, i8: Copy, <i32 as PromoteAddSub<i8>>::Output: Bounded + NumCast + Copy, Value<i32, FRAC>: ConvertValue<i128, FRAC>, Value<i8, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<i64, FRAC>

where i64: PromoteAddSub<i8> + Copy, i8: Copy, <i64 as PromoteAddSub<i8>>::Output: Bounded + NumCast + Copy, Value<i64, FRAC>: ConvertValue<i128, FRAC>, Value<i8, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u8, FRAC>

where u8: PromoteAddSub<i8> + Copy, i8: Copy, <u8 as PromoteAddSub<i8>>::Output: Bounded + NumCast + Copy, Value<u8, FRAC>: ConvertValue<i128, FRAC>, Value<i8, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u16, FRAC>

where u16: PromoteAddSub<i8> + Copy, i8: Copy, <u16 as PromoteAddSub<i8>>::Output: Bounded + NumCast + Copy, Value<u16, FRAC>: ConvertValue<i128, FRAC>, Value<i8, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u32, FRAC>

where u32: PromoteAddSub<i8> + Copy, i8: Copy, <u32 as PromoteAddSub<i8>>::Output: Bounded + NumCast + Copy, Value<u32, FRAC>: ConvertValue<i128, FRAC>, Value<i8, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u64, FRAC>

where u64: PromoteAddSub<i8> + Copy, i8: Copy, <u64 as PromoteAddSub<i8>>::Output: Bounded + NumCast + Copy, Value<u64, FRAC>: ConvertValue<i128, FRAC>, Value<i8, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<i8, FRAC>

where i8: PromoteAddSub<i16> + Copy, i16: Copy, <i8 as PromoteAddSub<i16>>::Output: Bounded + NumCast + Copy, Value<i8, FRAC>: ConvertValue<i128, FRAC>, Value<i16, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<i16, FRAC>

where i16: PromoteAddSub<i16> + Copy, <i16 as PromoteAddSub<i16>>::Output: Bounded + NumCast + Copy, Value<i16, FRAC>: ConvertValue<i128, FRAC>, Value<i16, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<i32, FRAC>

where i32: PromoteAddSub<i16> + Copy, i16: Copy, <i32 as PromoteAddSub<i16>>::Output: Bounded + NumCast + Copy, Value<i32, FRAC>: ConvertValue<i128, FRAC>, Value<i16, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<i64, FRAC>

where i64: PromoteAddSub<i16> + Copy, i16: Copy, <i64 as PromoteAddSub<i16>>::Output: Bounded + NumCast + Copy, Value<i64, FRAC>: ConvertValue<i128, FRAC>, Value<i16, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u8, FRAC>

where u8: PromoteAddSub<i16> + Copy, i16: Copy, <u8 as PromoteAddSub<i16>>::Output: Bounded + NumCast + Copy, Value<u8, FRAC>: ConvertValue<i128, FRAC>, Value<i16, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u16, FRAC>

where u16: PromoteAddSub<i16> + Copy, i16: Copy, <u16 as PromoteAddSub<i16>>::Output: Bounded + NumCast + Copy, Value<u16, FRAC>: ConvertValue<i128, FRAC>, Value<i16, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u32, FRAC>

where u32: PromoteAddSub<i16> + Copy, i16: Copy, <u32 as PromoteAddSub<i16>>::Output: Bounded + NumCast + Copy, Value<u32, FRAC>: ConvertValue<i128, FRAC>, Value<i16, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u64, FRAC>

where u64: PromoteAddSub<i16> + Copy, i16: Copy, <u64 as PromoteAddSub<i16>>::Output: Bounded + NumCast + Copy, Value<u64, FRAC>: ConvertValue<i128, FRAC>, Value<i16, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<i8, FRAC>

where i8: PromoteAddSub<i32> + Copy, i32: Copy, <i8 as PromoteAddSub<i32>>::Output: Bounded + NumCast + Copy, Value<i8, FRAC>: ConvertValue<i128, FRAC>, Value<i32, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<i16, FRAC>

where i16: PromoteAddSub<i32> + Copy, i32: Copy, <i16 as PromoteAddSub<i32>>::Output: Bounded + NumCast + Copy, Value<i16, FRAC>: ConvertValue<i128, FRAC>, Value<i32, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<i32, FRAC>

where i32: PromoteAddSub<i32> + Copy, <i32 as PromoteAddSub<i32>>::Output: Bounded + NumCast + Copy, Value<i32, FRAC>: ConvertValue<i128, FRAC>, Value<i32, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<i64, FRAC>

where i64: PromoteAddSub<i32> + Copy, i32: Copy, <i64 as PromoteAddSub<i32>>::Output: Bounded + NumCast + Copy, Value<i64, FRAC>: ConvertValue<i128, FRAC>, Value<i32, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u8, FRAC>

where u8: PromoteAddSub<i32> + Copy, i32: Copy, <u8 as PromoteAddSub<i32>>::Output: Bounded + NumCast + Copy, Value<u8, FRAC>: ConvertValue<i128, FRAC>, Value<i32, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u16, FRAC>

where u16: PromoteAddSub<i32> + Copy, i32: Copy, <u16 as PromoteAddSub<i32>>::Output: Bounded + NumCast + Copy, Value<u16, FRAC>: ConvertValue<i128, FRAC>, Value<i32, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u32, FRAC>

where u32: PromoteAddSub<i32> + Copy, i32: Copy, <u32 as PromoteAddSub<i32>>::Output: Bounded + NumCast + Copy, Value<u32, FRAC>: ConvertValue<i128, FRAC>, Value<i32, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u64, FRAC>

where u64: PromoteAddSub<i32> + Copy, i32: Copy, <u64 as PromoteAddSub<i32>>::Output: Bounded + NumCast + Copy, Value<u64, FRAC>: ConvertValue<i128, FRAC>, Value<i32, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<i8, FRAC>

where i8: PromoteAddSub<i64> + Copy, i64: Copy, <i8 as PromoteAddSub<i64>>::Output: Bounded + NumCast + Copy, Value<i8, FRAC>: ConvertValue<i128, FRAC>, Value<i64, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<i16, FRAC>

where i16: PromoteAddSub<i64> + Copy, i64: Copy, <i16 as PromoteAddSub<i64>>::Output: Bounded + NumCast + Copy, Value<i16, FRAC>: ConvertValue<i128, FRAC>, Value<i64, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<i32, FRAC>

where i32: PromoteAddSub<i64> + Copy, i64: Copy, <i32 as PromoteAddSub<i64>>::Output: Bounded + NumCast + Copy, Value<i32, FRAC>: ConvertValue<i128, FRAC>, Value<i64, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<i64, FRAC>

where i64: PromoteAddSub<i64> + Copy, <i64 as PromoteAddSub<i64>>::Output: Bounded + NumCast + Copy, Value<i64, FRAC>: ConvertValue<i128, FRAC>, Value<i64, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u8, FRAC>

where u8: PromoteAddSub<i64> + Copy, i64: Copy, <u8 as PromoteAddSub<i64>>::Output: Bounded + NumCast + Copy, Value<u8, FRAC>: ConvertValue<i128, FRAC>, Value<i64, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u16, FRAC>

where u16: PromoteAddSub<i64> + Copy, i64: Copy, <u16 as PromoteAddSub<i64>>::Output: Bounded + NumCast + Copy, Value<u16, FRAC>: ConvertValue<i128, FRAC>, Value<i64, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u32, FRAC>

where u32: PromoteAddSub<i64> + Copy, i64: Copy, <u32 as PromoteAddSub<i64>>::Output: Bounded + NumCast + Copy, Value<u32, FRAC>: ConvertValue<i128, FRAC>, Value<i64, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u64, FRAC>

where u64: PromoteAddSub<i64> + Copy, i64: Copy, <u64 as PromoteAddSub<i64>>::Output: Bounded + NumCast + Copy, Value<u64, FRAC>: ConvertValue<i128, FRAC>, Value<i64, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u8, FRAC>

where u8: PromoteAddSub<u8> + Copy, <u8 as PromoteAddSub<u8>>::Output: Bounded + NumCast + Copy, Value<u8, FRAC>: ConvertValue<i128, FRAC>, Value<u8, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u16, FRAC>

where u16: PromoteAddSub<u8> + Copy, u8: Copy, <u16 as PromoteAddSub<u8>>::Output: Bounded + NumCast + Copy, Value<u16, FRAC>: ConvertValue<i128, FRAC>, Value<u8, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u32, FRAC>

where u32: PromoteAddSub<u8> + Copy, u8: Copy, <u32 as PromoteAddSub<u8>>::Output: Bounded + NumCast + Copy, Value<u32, FRAC>: ConvertValue<i128, FRAC>, Value<u8, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u64, FRAC>

where u64: PromoteAddSub<u8> + Copy, u8: Copy, <u64 as PromoteAddSub<u8>>::Output: Bounded + NumCast + Copy, Value<u64, FRAC>: ConvertValue<i128, FRAC>, Value<u8, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<i8, FRAC>

where i8: PromoteAddSub<u8> + Copy, u8: Copy, <i8 as PromoteAddSub<u8>>::Output: Bounded + NumCast + Copy, Value<i8, FRAC>: ConvertValue<i128, FRAC>, Value<u8, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<i16, FRAC>

where i16: PromoteAddSub<u8> + Copy, u8: Copy, <i16 as PromoteAddSub<u8>>::Output: Bounded + NumCast + Copy, Value<i16, FRAC>: ConvertValue<i128, FRAC>, Value<u8, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<i32, FRAC>

where i32: PromoteAddSub<u8> + Copy, u8: Copy, <i32 as PromoteAddSub<u8>>::Output: Bounded + NumCast + Copy, Value<i32, FRAC>: ConvertValue<i128, FRAC>, Value<u8, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<i64, FRAC>

where i64: PromoteAddSub<u8> + Copy, u8: Copy, <i64 as PromoteAddSub<u8>>::Output: Bounded + NumCast + Copy, Value<i64, FRAC>: ConvertValue<i128, FRAC>, Value<u8, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u8, FRAC>

where u8: PromoteAddSub<u16> + Copy, u16: Copy, <u8 as PromoteAddSub<u16>>::Output: Bounded + NumCast + Copy, Value<u8, FRAC>: ConvertValue<i128, FRAC>, Value<u16, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u16, FRAC>

where u16: PromoteAddSub<u16> + Copy, <u16 as PromoteAddSub<u16>>::Output: Bounded + NumCast + Copy, Value<u16, FRAC>: ConvertValue<i128, FRAC>, Value<u16, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u32, FRAC>

where u32: PromoteAddSub<u16> + Copy, u16: Copy, <u32 as PromoteAddSub<u16>>::Output: Bounded + NumCast + Copy, Value<u32, FRAC>: ConvertValue<i128, FRAC>, Value<u16, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u64, FRAC>

where u64: PromoteAddSub<u16> + Copy, u16: Copy, <u64 as PromoteAddSub<u16>>::Output: Bounded + NumCast + Copy, Value<u64, FRAC>: ConvertValue<i128, FRAC>, Value<u16, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<i8, FRAC>

where i8: PromoteAddSub<u16> + Copy, u16: Copy, <i8 as PromoteAddSub<u16>>::Output: Bounded + NumCast + Copy, Value<i8, FRAC>: ConvertValue<i128, FRAC>, Value<u16, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<i16, FRAC>

where i16: PromoteAddSub<u16> + Copy, u16: Copy, <i16 as PromoteAddSub<u16>>::Output: Bounded + NumCast + Copy, Value<i16, FRAC>: ConvertValue<i128, FRAC>, Value<u16, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<i32, FRAC>

where i32: PromoteAddSub<u16> + Copy, u16: Copy, <i32 as PromoteAddSub<u16>>::Output: Bounded + NumCast + Copy, Value<i32, FRAC>: ConvertValue<i128, FRAC>, Value<u16, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<i64, FRAC>

where i64: PromoteAddSub<u16> + Copy, u16: Copy, <i64 as PromoteAddSub<u16>>::Output: Bounded + NumCast + Copy, Value<i64, FRAC>: ConvertValue<i128, FRAC>, Value<u16, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u8, FRAC>

where u8: PromoteAddSub<u32> + Copy, u32: Copy, <u8 as PromoteAddSub<u32>>::Output: Bounded + NumCast + Copy, Value<u8, FRAC>: ConvertValue<i128, FRAC>, Value<u32, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u16, FRAC>

where u16: PromoteAddSub<u32> + Copy, u32: Copy, <u16 as PromoteAddSub<u32>>::Output: Bounded + NumCast + Copy, Value<u16, FRAC>: ConvertValue<i128, FRAC>, Value<u32, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u32, FRAC>

where u32: PromoteAddSub<u32> + Copy, <u32 as PromoteAddSub<u32>>::Output: Bounded + NumCast + Copy, Value<u32, FRAC>: ConvertValue<i128, FRAC>, Value<u32, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u64, FRAC>

where u64: PromoteAddSub<u32> + Copy, u32: Copy, <u64 as PromoteAddSub<u32>>::Output: Bounded + NumCast + Copy, Value<u64, FRAC>: ConvertValue<i128, FRAC>, Value<u32, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<i8, FRAC>

where i8: PromoteAddSub<u32> + Copy, u32: Copy, <i8 as PromoteAddSub<u32>>::Output: Bounded + NumCast + Copy, Value<i8, FRAC>: ConvertValue<i128, FRAC>, Value<u32, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<i16, FRAC>

where i16: PromoteAddSub<u32> + Copy, u32: Copy, <i16 as PromoteAddSub<u32>>::Output: Bounded + NumCast + Copy, Value<i16, FRAC>: ConvertValue<i128, FRAC>, Value<u32, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<i32, FRAC>

where i32: PromoteAddSub<u32> + Copy, u32: Copy, <i32 as PromoteAddSub<u32>>::Output: Bounded + NumCast + Copy, Value<i32, FRAC>: ConvertValue<i128, FRAC>, Value<u32, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<i64, FRAC>

where i64: PromoteAddSub<u32> + Copy, u32: Copy, <i64 as PromoteAddSub<u32>>::Output: Bounded + NumCast + Copy, Value<i64, FRAC>: ConvertValue<i128, FRAC>, Value<u32, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u8, FRAC>

where u8: PromoteAddSub<u64> + Copy, u64: Copy, <u8 as PromoteAddSub<u64>>::Output: Bounded + NumCast + Copy, Value<u8, FRAC>: ConvertValue<i128, FRAC>, Value<u64, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u16, FRAC>

where u16: PromoteAddSub<u64> + Copy, u64: Copy, <u16 as PromoteAddSub<u64>>::Output: Bounded + NumCast + Copy, Value<u16, FRAC>: ConvertValue<i128, FRAC>, Value<u64, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u32, FRAC>

where u32: PromoteAddSub<u64> + Copy, u64: Copy, <u32 as PromoteAddSub<u64>>::Output: Bounded + NumCast + Copy, Value<u32, FRAC>: ConvertValue<i128, FRAC>, Value<u64, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u64, FRAC>

where u64: PromoteAddSub<u64> + Copy, <u64 as PromoteAddSub<u64>>::Output: Bounded + NumCast + Copy, Value<u64, FRAC>: ConvertValue<i128, FRAC>, Value<u64, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<i8, FRAC>

where i8: PromoteAddSub<u64> + Copy, u64: Copy, <i8 as PromoteAddSub<u64>>::Output: Bounded + NumCast + Copy, Value<i8, FRAC>: ConvertValue<i128, FRAC>, Value<u64, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<i16, FRAC>

where i16: PromoteAddSub<u64> + Copy, u64: Copy, <i16 as PromoteAddSub<u64>>::Output: Bounded + NumCast + Copy, Value<i16, FRAC>: ConvertValue<i128, FRAC>, Value<u64, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<i32, FRAC>

where i32: PromoteAddSub<u64> + Copy, u64: Copy, <i32 as PromoteAddSub<u64>>::Output: Bounded + NumCast + Copy, Value<i32, FRAC>: ConvertValue<i128, FRAC>, Value<u64, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<i64, FRAC>

where i64: PromoteAddSub<u64> + Copy, u64: Copy, <i64 as PromoteAddSub<u64>>::Output: Bounded + NumCast + Copy, Value<i64, FRAC>: ConvertValue<i128, FRAC>, Value<u64, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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<Fixed<U, FRAC_R>> for Fixed<I, FRAC>

where I: PromoteAddSub<U> + Copy + Bounded + NumCast + TryFrom<I::Output>, U: Copy, I::Output: Bounded + NumCast + Copy + PartialOrd + Zero, Value<I, FRAC>: ConvertValue<i128, FRAC>, Value<U, FRAC_R>: ConvertValue<i128, FRAC>,

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

Performs the += operation.

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

where i8: PromoteAddSub<i8> + Bounded + NumCast + Copy, <i8 as PromoteAddSub<i8>>::Output: Bounded + NumCast + Copy, Value<i8, FRAC>: ConvertValue<i128, FRAC>, Value<i8, 0>: ConvertValue<i128, FRAC>,

fn add_assign(&mut self, rhs: i8)

Performs the += operation.

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

where i16: PromoteAddSub<i8> + Bounded + NumCast + Copy, i8: Copy, <i16 as PromoteAddSub<i8>>::Output: Bounded + NumCast + Copy, Value<i16, FRAC>: ConvertValue<i128, FRAC>, Value<i8, 0>: ConvertValue<i128, FRAC>,

fn add_assign(&mut self, rhs: i8)

Performs the += operation.

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

where i32: PromoteAddSub<i8> + Bounded + NumCast + Copy, i8: Copy, <i32 as PromoteAddSub<i8>>::Output: Bounded + NumCast + Copy, Value<i32, FRAC>: ConvertValue<i128, FRAC>, Value<i8, 0>: ConvertValue<i128, FRAC>,

fn add_assign(&mut self, rhs: i8)

Performs the += operation.

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

where i64: PromoteAddSub<i8> + Bounded + NumCast + Copy, i8: Copy, <i64 as PromoteAddSub<i8>>::Output: Bounded + NumCast + Copy, Value<i64, FRAC>: ConvertValue<i128, FRAC>, Value<i8, 0>: ConvertValue<i128, FRAC>,

fn add_assign(&mut self, rhs: i8)

Performs the += operation.

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

where u8: PromoteAddSub<i8> + Bounded + NumCast + Copy, i8: Copy, <u8 as PromoteAddSub<i8>>::Output: Bounded + NumCast + Copy, Value<u8, FRAC>: ConvertValue<i128, FRAC>, Value<i8, 0>: ConvertValue<i128, FRAC>,

fn add_assign(&mut self, rhs: i8)

Performs the += operation.

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

where u16: PromoteAddSub<i8> + Bounded + NumCast + Copy, i8: Copy, <u16 as PromoteAddSub<i8>>::Output: Bounded + NumCast + Copy, Value<u16, FRAC>: ConvertValue<i128, FRAC>, Value<i8, 0>: ConvertValue<i128, FRAC>,

fn add_assign(&mut self, rhs: i8)

Performs the += operation.

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

where u32: PromoteAddSub<i8> + Bounded + NumCast + Copy, i8: Copy, <u32 as PromoteAddSub<i8>>::Output: Bounded + NumCast + Copy, Value<u32, FRAC>: ConvertValue<i128, FRAC>, Value<i8, 0>: ConvertValue<i128, FRAC>,

fn add_assign(&mut self, rhs: i8)

Performs the += operation.

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

where u64: PromoteAddSub<i8> + Bounded + NumCast + Copy, i8: Copy, <u64 as PromoteAddSub<i8>>::Output: Bounded + NumCast + Copy, Value<u64, FRAC>: ConvertValue<i128, FRAC>, Value<i8, 0>: ConvertValue<i128, FRAC>,

fn add_assign(&mut self, rhs: i8)

Performs the += operation.

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

where i8: PromoteAddSub<i16> + Bounded + NumCast + Copy, i16: Copy, <i8 as PromoteAddSub<i16>>::Output: Bounded + NumCast + Copy, Value<i8, FRAC>: ConvertValue<i128, FRAC>, Value<i16, 0>: ConvertValue<i128, FRAC>,

fn add_assign(&mut self, rhs: i16)

Performs the += operation.

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

where i16: PromoteAddSub<i16> + Bounded + NumCast + Copy, <i16 as PromoteAddSub<i16>>::Output: Bounded + NumCast + Copy, Value<i16, FRAC>: ConvertValue<i128, FRAC>, Value<i16, 0>: ConvertValue<i128, FRAC>,

fn add_assign(&mut self, rhs: i16)

Performs the += operation.

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

where i32: PromoteAddSub<i16> + Bounded + NumCast + Copy, i16: Copy, <i32 as PromoteAddSub<i16>>::Output: Bounded + NumCast + Copy, Value<i32, FRAC>: ConvertValue<i128, FRAC>, Value<i16, 0>: ConvertValue<i128, FRAC>,

fn add_assign(&mut self, rhs: i16)

Performs the += operation.

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

where i64: PromoteAddSub<i16> + Bounded + NumCast + Copy, i16: Copy, <i64 as PromoteAddSub<i16>>::Output: Bounded + NumCast + Copy, Value<i64, FRAC>: ConvertValue<i128, FRAC>, Value<i16, 0>: ConvertValue<i128, FRAC>,

fn add_assign(&mut self, rhs: i16)

Performs the += operation.

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

where u8: PromoteAddSub<i16> + Bounded + NumCast + Copy, i16: Copy, <u8 as PromoteAddSub<i16>>::Output: Bounded + NumCast + Copy, Value<u8, FRAC>: ConvertValue<i128, FRAC>, Value<i16, 0>: ConvertValue<i128, FRAC>,

fn add_assign(&mut self, rhs: i16)

Performs the += operation.

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

where u16: PromoteAddSub<i16> + Bounded + NumCast + Copy, i16: Copy, <u16 as PromoteAddSub<i16>>::Output: Bounded + NumCast + Copy, Value<u16, FRAC>: ConvertValue<i128, FRAC>, Value<i16, 0>: ConvertValue<i128, FRAC>,

fn add_assign(&mut self, rhs: i16)

Performs the += operation.

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

where u32: PromoteAddSub<i16> + Bounded + NumCast + Copy, i16: Copy, <u32 as PromoteAddSub<i16>>::Output: Bounded + NumCast + Copy, Value<u32, FRAC>: ConvertValue<i128, FRAC>, Value<i16, 0>: ConvertValue<i128, FRAC>,

fn add_assign(&mut self, rhs: i16)

Performs the += operation.

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

where u64: PromoteAddSub<i16> + Bounded + NumCast + Copy, i16: Copy, <u64 as PromoteAddSub<i16>>::Output: Bounded + NumCast + Copy, Value<u64, FRAC>: ConvertValue<i128, FRAC>, Value<i16, 0>: ConvertValue<i128, FRAC>,

fn add_assign(&mut self, rhs: i16)

Performs the += operation.

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

where i8: PromoteAddSub<i32> + Bounded + NumCast + Copy, i32: Copy, <i8 as PromoteAddSub<i32>>::Output: Bounded + NumCast + Copy, Value<i8, FRAC>: ConvertValue<i128, FRAC>, Value<i32, 0>: ConvertValue<i128, FRAC>,

fn add_assign(&mut self, rhs: i32)

Performs the += operation.

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

where i16: PromoteAddSub<i32> + Bounded + NumCast + Copy, i32: Copy, <i16 as PromoteAddSub<i32>>::Output: Bounded + NumCast + Copy, Value<i16, FRAC>: ConvertValue<i128, FRAC>, Value<i32, 0>: ConvertValue<i128, FRAC>,

fn add_assign(&mut self, rhs: i32)

Performs the += operation.

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

where i32: PromoteAddSub<i32> + Bounded + NumCast + Copy, <i32 as PromoteAddSub<i32>>::Output: Bounded + NumCast + Copy, Value<i32, FRAC>: ConvertValue<i128, FRAC>, Value<i32, 0>: ConvertValue<i128, FRAC>,

fn add_assign(&mut self, rhs: i32)

Performs the += operation.

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

where i64: PromoteAddSub<i32> + Bounded + NumCast + Copy, i32: Copy, <i64 as PromoteAddSub<i32>>::Output: Bounded + NumCast + Copy, Value<i64, FRAC>: ConvertValue<i128, FRAC>, Value<i32, 0>: ConvertValue<i128, FRAC>,

fn add_assign(&mut self, rhs: i32)

Performs the += operation.

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

where u8: PromoteAddSub<i32> + Bounded + NumCast + Copy, i32: Copy, <u8 as PromoteAddSub<i32>>::Output: Bounded + NumCast + Copy, Value<u8, FRAC>: ConvertValue<i128, FRAC>, Value<i32, 0>: ConvertValue<i128, FRAC>,

fn add_assign(&mut self, rhs: i32)

Performs the += operation.

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

where u16: PromoteAddSub<i32> + Bounded + NumCast + Copy, i32: Copy, <u16 as PromoteAddSub<i32>>::Output: Bounded + NumCast + Copy, Value<u16, FRAC>: ConvertValue<i128, FRAC>, Value<i32, 0>: ConvertValue<i128, FRAC>,

fn add_assign(&mut self, rhs: i32)

Performs the += operation.

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

where u32: PromoteAddSub<i32> + Bounded + NumCast + Copy, i32: Copy, <u32 as PromoteAddSub<i32>>::Output: Bounded + NumCast + Copy, Value<u32, FRAC>: ConvertValue<i128, FRAC>, Value<i32, 0>: ConvertValue<i128, FRAC>,

fn add_assign(&mut self, rhs: i32)

Performs the += operation.

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

where u64: PromoteAddSub<i32> + Bounded + NumCast + Copy, i32: Copy, <u64 as PromoteAddSub<i32>>::Output: Bounded + NumCast + Copy, Value<u64, FRAC>: ConvertValue<i128, FRAC>, Value<i32, 0>: ConvertValue<i128, FRAC>,

fn add_assign(&mut self, rhs: i32)

Performs the += operation.

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

where i8: PromoteAddSub<i64> + Bounded + NumCast + Copy, i64: Copy, <i8 as PromoteAddSub<i64>>::Output: Bounded + NumCast + Copy, Value<i8, FRAC>: ConvertValue<i128, FRAC>, Value<i64, 0>: ConvertValue<i128, FRAC>,

fn add_assign(&mut self, rhs: i64)

Performs the += operation.

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

where i16: PromoteAddSub<i64> + Bounded + NumCast + Copy, i64: Copy, <i16 as PromoteAddSub<i64>>::Output: Bounded + NumCast + Copy, Value<i16, FRAC>: ConvertValue<i128, FRAC>, Value<i64, 0>: ConvertValue<i128, FRAC>,

fn add_assign(&mut self, rhs: i64)

Performs the += operation.

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

where i32: PromoteAddSub<i64> + Bounded + NumCast + Copy, i64: Copy, <i32 as PromoteAddSub<i64>>::Output: Bounded + NumCast + Copy, Value<i32, FRAC>: ConvertValue<i128, FRAC>, Value<i64, 0>: ConvertValue<i128, FRAC>,

fn add_assign(&mut self, rhs: i64)

Performs the += operation.

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

where i64: PromoteAddSub<i64> + Bounded + NumCast + Copy, <i64 as PromoteAddSub<i64>>::Output: Bounded + NumCast + Copy, Value<i64, FRAC>: ConvertValue<i128, FRAC>, Value<i64, 0>: ConvertValue<i128, FRAC>,

fn add_assign(&mut self, rhs: i64)

Performs the += operation.

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

where u8: PromoteAddSub<i64> + Bounded + NumCast + Copy, i64: Copy, <u8 as PromoteAddSub<i64>>::Output: Bounded + NumCast + Copy, Value<u8, FRAC>: ConvertValue<i128, FRAC>, Value<i64, 0>: ConvertValue<i128, FRAC>,

fn add_assign(&mut self, rhs: i64)

Performs the += operation.

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

where u16: PromoteAddSub<i64> + Bounded + NumCast + Copy, i64: Copy, <u16 as PromoteAddSub<i64>>::Output: Bounded + NumCast + Copy, Value<u16, FRAC>: ConvertValue<i128, FRAC>, Value<i64, 0>: ConvertValue<i128, FRAC>,

fn add_assign(&mut self, rhs: i64)

Performs the += operation.

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

where u32: PromoteAddSub<i64> + Bounded + NumCast + Copy, i64: Copy, <u32 as PromoteAddSub<i64>>::Output: Bounded + NumCast + Copy, Value<u32, FRAC>: ConvertValue<i128, FRAC>, Value<i64, 0>: ConvertValue<i128, FRAC>,

fn add_assign(&mut self, rhs: i64)

Performs the += operation.

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

where u64: PromoteAddSub<i64> + Bounded + NumCast + Copy, i64: Copy, <u64 as PromoteAddSub<i64>>::Output: Bounded + NumCast + Copy, Value<u64, FRAC>: ConvertValue<i128, FRAC>, Value<i64, 0>: ConvertValue<i128, FRAC>,

fn add_assign(&mut self, rhs: i64)

Performs the += operation.

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

where u8: PromoteAddSub<u8> + Bounded + NumCast + Copy, <u8 as PromoteAddSub<u8>>::Output: Bounded + NumCast + Copy, Value<u8, FRAC>: ConvertValue<i128, FRAC>, Value<u8, 0>: ConvertValue<i128, FRAC>,

fn add_assign(&mut self, rhs: u8)

Performs the += operation.

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

where u16: PromoteAddSub<u8> + Bounded + NumCast + Copy, u8: Copy, <u16 as PromoteAddSub<u8>>::Output: Bounded + NumCast + Copy, Value<u16, FRAC>: ConvertValue<i128, FRAC>, Value<u8, 0>: ConvertValue<i128, FRAC>,

fn add_assign(&mut self, rhs: u8)

Performs the += operation.

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

where u32: PromoteAddSub<u8> + Bounded + NumCast + Copy, u8: Copy, <u32 as PromoteAddSub<u8>>::Output: Bounded + NumCast + Copy, Value<u32, FRAC>: ConvertValue<i128, FRAC>, Value<u8, 0>: ConvertValue<i128, FRAC>,

fn add_assign(&mut self, rhs: u8)

Performs the += operation.

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

where u64: PromoteAddSub<u8> + Bounded + NumCast + Copy, u8: Copy, <u64 as PromoteAddSub<u8>>::Output: Bounded + NumCast + Copy, Value<u64, FRAC>: ConvertValue<i128, FRAC>, Value<u8, 0>: ConvertValue<i128, FRAC>,

fn add_assign(&mut self, rhs: u8)

Performs the += operation.

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

where i8: PromoteAddSub<u8> + Bounded + NumCast + Copy, u8: Copy, <i8 as PromoteAddSub<u8>>::Output: Bounded + NumCast + Copy, Value<i8, FRAC>: ConvertValue<i128, FRAC>, Value<u8, 0>: ConvertValue<i128, FRAC>,

fn add_assign(&mut self, rhs: u8)

Performs the += operation.

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

where i16: PromoteAddSub<u8> + Bounded + NumCast + Copy, u8: Copy, <i16 as PromoteAddSub<u8>>::Output: Bounded + NumCast + Copy, Value<i16, FRAC>: ConvertValue<i128, FRAC>, Value<u8, 0>: ConvertValue<i128, FRAC>,

fn add_assign(&mut self, rhs: u8)

Performs the += operation.

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

where i32: PromoteAddSub<u8> + Bounded + NumCast + Copy, u8: Copy, <i32 as PromoteAddSub<u8>>::Output: Bounded + NumCast + Copy, Value<i32, FRAC>: ConvertValue<i128, FRAC>, Value<u8, 0>: ConvertValue<i128, FRAC>,

fn add_assign(&mut self, rhs: u8)

Performs the += operation.

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

where i64: PromoteAddSub<u8> + Bounded + NumCast + Copy, u8: Copy, <i64 as PromoteAddSub<u8>>::Output: Bounded + NumCast + Copy, Value<i64, FRAC>: ConvertValue<i128, FRAC>, Value<u8, 0>: ConvertValue<i128, FRAC>,

fn add_assign(&mut self, rhs: u8)

Performs the += operation.

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

where u8: PromoteAddSub<u16> + Bounded + NumCast + Copy, u16: Copy, <u8 as PromoteAddSub<u16>>::Output: Bounded + NumCast + Copy, Value<u8, FRAC>: ConvertValue<i128, FRAC>, Value<u16, 0>: ConvertValue<i128, FRAC>,

fn add_assign(&mut self, rhs: u16)

Performs the += operation.

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

where u16: PromoteAddSub<u16> + Bounded + NumCast + Copy, <u16 as PromoteAddSub<u16>>::Output: Bounded + NumCast + Copy, Value<u16, FRAC>: ConvertValue<i128, FRAC>, Value<u16, 0>: ConvertValue<i128, FRAC>,

fn add_assign(&mut self, rhs: u16)

Performs the += operation.

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

where u32: PromoteAddSub<u16> + Bounded + NumCast + Copy, u16: Copy, <u32 as PromoteAddSub<u16>>::Output: Bounded + NumCast + Copy, Value<u32, FRAC>: ConvertValue<i128, FRAC>, Value<u16, 0>: ConvertValue<i128, FRAC>,

fn add_assign(&mut self, rhs: u16)

Performs the += operation.

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

where u64: PromoteAddSub<u16> + Bounded + NumCast + Copy, u16: Copy, <u64 as PromoteAddSub<u16>>::Output: Bounded + NumCast + Copy, Value<u64, FRAC>: ConvertValue<i128, FRAC>, Value<u16, 0>: ConvertValue<i128, FRAC>,

fn add_assign(&mut self, rhs: u16)

Performs the += operation.

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

where i8: PromoteAddSub<u16> + Bounded + NumCast + Copy, u16: Copy, <i8 as PromoteAddSub<u16>>::Output: Bounded + NumCast + Copy, Value<i8, FRAC>: ConvertValue<i128, FRAC>, Value<u16, 0>: ConvertValue<i128, FRAC>,

fn add_assign(&mut self, rhs: u16)

Performs the += operation.

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

where i16: PromoteAddSub<u16> + Bounded + NumCast + Copy, u16: Copy, <i16 as PromoteAddSub<u16>>::Output: Bounded + NumCast + Copy, Value<i16, FRAC>: ConvertValue<i128, FRAC>, Value<u16, 0>: ConvertValue<i128, FRAC>,

fn add_assign(&mut self, rhs: u16)

Performs the += operation.

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

where i32: PromoteAddSub<u16> + Bounded + NumCast + Copy, u16: Copy, <i32 as PromoteAddSub<u16>>::Output: Bounded + NumCast + Copy, Value<i32, FRAC>: ConvertValue<i128, FRAC>, Value<u16, 0>: ConvertValue<i128, FRAC>,

fn add_assign(&mut self, rhs: u16)

Performs the += operation.

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

where i64: PromoteAddSub<u16> + Bounded + NumCast + Copy, u16: Copy, <i64 as PromoteAddSub<u16>>::Output: Bounded + NumCast + Copy, Value<i64, FRAC>: ConvertValue<i128, FRAC>, Value<u16, 0>: ConvertValue<i128, FRAC>,

fn add_assign(&mut self, rhs: u16)

Performs the += operation.

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

where u8: PromoteAddSub<u32> + Bounded + NumCast + Copy, u32: Copy, <u8 as PromoteAddSub<u32>>::Output: Bounded + NumCast + Copy, Value<u8, FRAC>: ConvertValue<i128, FRAC>, Value<u32, 0>: ConvertValue<i128, FRAC>,

fn add_assign(&mut self, rhs: u32)

Performs the += operation.

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

where u16: PromoteAddSub<u32> + Bounded + NumCast + Copy, u32: Copy, <u16 as PromoteAddSub<u32>>::Output: Bounded + NumCast + Copy, Value<u16, FRAC>: ConvertValue<i128, FRAC>, Value<u32, 0>: ConvertValue<i128, FRAC>,

fn add_assign(&mut self, rhs: u32)

Performs the += operation.

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

where u32: PromoteAddSub<u32> + Bounded + NumCast + Copy, <u32 as PromoteAddSub<u32>>::Output: Bounded + NumCast + Copy, Value<u32, FRAC>: ConvertValue<i128, FRAC>, Value<u32, 0>: ConvertValue<i128, FRAC>,

fn add_assign(&mut self, rhs: u32)

Performs the += operation.

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

where u64: PromoteAddSub<u32> + Bounded + NumCast + Copy, u32: Copy, <u64 as PromoteAddSub<u32>>::Output: Bounded + NumCast + Copy, Value<u64, FRAC>: ConvertValue<i128, FRAC>, Value<u32, 0>: ConvertValue<i128, FRAC>,

fn add_assign(&mut self, rhs: u32)

Performs the += operation.

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

where i8: PromoteAddSub<u32> + Bounded + NumCast + Copy, u32: Copy, <i8 as PromoteAddSub<u32>>::Output: Bounded + NumCast + Copy, Value<i8, FRAC>: ConvertValue<i128, FRAC>, Value<u32, 0>: ConvertValue<i128, FRAC>,

fn add_assign(&mut self, rhs: u32)

Performs the += operation.

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

where i16: PromoteAddSub<u32> + Bounded + NumCast + Copy, u32: Copy, <i16 as PromoteAddSub<u32>>::Output: Bounded + NumCast + Copy, Value<i16, FRAC>: ConvertValue<i128, FRAC>, Value<u32, 0>: ConvertValue<i128, FRAC>,

fn add_assign(&mut self, rhs: u32)

Performs the += operation.

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

where i32: PromoteAddSub<u32> + Bounded + NumCast + Copy, u32: Copy, <i32 as PromoteAddSub<u32>>::Output: Bounded + NumCast + Copy, Value<i32, FRAC>: ConvertValue<i128, FRAC>, Value<u32, 0>: ConvertValue<i128, FRAC>,

fn add_assign(&mut self, rhs: u32)

Performs the += operation.

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

where i64: PromoteAddSub<u32> + Bounded + NumCast + Copy, u32: Copy, <i64 as PromoteAddSub<u32>>::Output: Bounded + NumCast + Copy, Value<i64, FRAC>: ConvertValue<i128, FRAC>, Value<u32, 0>: ConvertValue<i128, FRAC>,

fn add_assign(&mut self, rhs: u32)

Performs the += operation.

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

where u8: PromoteAddSub<u64> + Bounded + NumCast + Copy, u64: Copy, <u8 as PromoteAddSub<u64>>::Output: Bounded + NumCast + Copy, Value<u8, FRAC>: ConvertValue<i128, FRAC>, Value<u64, 0>: ConvertValue<i128, FRAC>,

fn add_assign(&mut self, rhs: u64)

Performs the += operation.

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

where u16: PromoteAddSub<u64> + Bounded + NumCast + Copy, u64: Copy, <u16 as PromoteAddSub<u64>>::Output: Bounded + NumCast + Copy, Value<u16, FRAC>: ConvertValue<i128, FRAC>, Value<u64, 0>: ConvertValue<i128, FRAC>,

fn add_assign(&mut self, rhs: u64)

Performs the += operation.

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

where u32: PromoteAddSub<u64> + Bounded + NumCast + Copy, u64: Copy, <u32 as PromoteAddSub<u64>>::Output: Bounded + NumCast + Copy, Value<u32, FRAC>: ConvertValue<i128, FRAC>, Value<u64, 0>: ConvertValue<i128, FRAC>,

fn add_assign(&mut self, rhs: u64)

Performs the += operation.

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

where u64: PromoteAddSub<u64> + Bounded + NumCast + Copy, <u64 as PromoteAddSub<u64>>::Output: Bounded + NumCast + Copy, Value<u64, FRAC>: ConvertValue<i128, FRAC>, Value<u64, 0>: ConvertValue<i128, FRAC>,

fn add_assign(&mut self, rhs: u64)

Performs the += operation.

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

where i8: PromoteAddSub<u64> + Bounded + NumCast + Copy, u64: Copy, <i8 as PromoteAddSub<u64>>::Output: Bounded + NumCast + Copy, Value<i8, FRAC>: ConvertValue<i128, FRAC>, Value<u64, 0>: ConvertValue<i128, FRAC>,

fn add_assign(&mut self, rhs: u64)

Performs the += operation.

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

where i16: PromoteAddSub<u64> + Bounded + NumCast + Copy, u64: Copy, <i16 as PromoteAddSub<u64>>::Output: Bounded + NumCast + Copy, Value<i16, FRAC>: ConvertValue<i128, FRAC>, Value<u64, 0>: ConvertValue<i128, FRAC>,

fn add_assign(&mut self, rhs: u64)

Performs the += operation.

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

where i32: PromoteAddSub<u64> + Bounded + NumCast + Copy, u64: Copy, <i32 as PromoteAddSub<u64>>::Output: Bounded + NumCast + Copy, Value<i32, FRAC>: ConvertValue<i128, FRAC>, Value<u64, 0>: ConvertValue<i128, FRAC>,

fn add_assign(&mut self, rhs: u64)

Performs the += operation.

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

where i64: PromoteAddSub<u64> + Bounded + NumCast + Copy, u64: Copy, <i64 as PromoteAddSub<u64>>::Output: Bounded + NumCast + Copy, Value<i64, FRAC>: ConvertValue<i128, FRAC>, Value<u64, 0>: ConvertValue<i128, FRAC>,

fn add_assign(&mut self, rhs: u64)

Performs the += operation.

impl<I: Clone, const FRAC: usize> Clone for Fixed<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 Fixed<I, FRAC>

impl<I, const FRAC: usize> Debug for Fixed<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 Fixed<I, FRAC>

fn default() -> Self

Returns the “default value” for a type.

impl<I, const FRAC: usize> Display for Fixed<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<Fixed<IR, FR>> for Fixed<IL, FL>

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

The resulting type after applying the / operator.

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

Performs the / operation.

impl<IL, const FL: usize> Div<i8> for Fixed<IL, FL>

type Output = DivExpression<Fixed<IL, FL>, Fixed<i8, 0>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<IL, const FL: usize> Div<i16> for Fixed<IL, FL>

type Output = DivExpression<Fixed<IL, FL>, Fixed<i16, 0>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<IL, const FL: usize> Div<i32> for Fixed<IL, FL>

type Output = DivExpression<Fixed<IL, FL>, Fixed<i32, 0>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<IL, const FL: usize> Div<i64> for Fixed<IL, FL>

type Output = DivExpression<Fixed<IL, FL>, Fixed<i64, 0>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<IL, const FL: usize> Div<u8> for Fixed<IL, FL>

type Output = DivExpression<Fixed<IL, FL>, Fixed<u8, 0>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<IL, const FL: usize> Div<u16> for Fixed<IL, FL>

type Output = DivExpression<Fixed<IL, FL>, Fixed<u16, 0>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<IL, const FL: usize> Div<u32> for Fixed<IL, FL>

type Output = DivExpression<Fixed<IL, FL>, Fixed<u32, 0>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<IL, const FL: usize> Div<u64> for Fixed<IL, FL>

type Output = DivExpression<Fixed<IL, FL>, Fixed<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 Fixed<I, FRAC>

where Self: Copy, Fixed<I, FRAC>: From<DivExpression<Self, Self>>,

fn div_assign(&mut self, rhs: Self)

Performs the /= operation.

impl<I, const FRAC: usize> Eq for Fixed<I, FRAC>

where I: Into<i128> + Copy,

impl<I, const TARGET_FRAC: usize, IL, const FL: usize, IR, const FR: usize> From<DivExpression<Fixed<IL, FL>, Fixed<IR, FR>>> for Fixed<I, TARGET_FRAC>

where I: Bounded + TryFrom<i128> + Copy, IL: Into<i128> + Copy, IR: Into<i128> + Copy,

fn from(expr: DivExpression<Fixed<IL, FL>, Fixed<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: Copy, const FRAC: usize> From<Value<I, FRAC>> for Fixed<I, FRAC>

fn from(val: Value<I, FRAC>) -> Self

Converts to this type from the input type.

impl<I: Hash, const FRAC: usize> Hash for Fixed<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 Fixed<I, FRAC>

where I: Into<i128> + Copy,

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

Formats the value using the given formatter.

impl<T, const FRAC: usize, U, const FRAC_R: usize> Mul<Fixed<U, FRAC_R>> for Fixed<T, FRAC>

where T: PromoteMul<U> + Into<i128> + Copy, U: Into<i128> + Copy, T::Output: Bounded + NumCast + Copy,

type Output = Fixed<<T as PromoteMul<U>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: Fixed<U, FRAC_R>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<Fixed<i8, FRAC>> for i8

where i8: PromoteMul<i8> + Copy, <i8 as PromoteMul<i8>>::Output: Bounded + NumCast + Copy, Value<i8, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<i8 as PromoteMul<i8>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: Fixed<i8, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<Fixed<i8, FRAC>> for i16

where i8: PromoteMul<i16> + Copy, i16: Copy, <i8 as PromoteMul<i16>>::Output: Bounded + NumCast + Copy, Value<i8, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<i8 as PromoteMul<i16>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: Fixed<i8, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<Fixed<i8, FRAC>> for i32

where i8: PromoteMul<i32> + Copy, i32: Copy, <i8 as PromoteMul<i32>>::Output: Bounded + NumCast + Copy, Value<i8, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<i8 as PromoteMul<i32>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: Fixed<i8, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<Fixed<i8, FRAC>> for i64

where i8: PromoteMul<i64> + Copy, i64: Copy, <i8 as PromoteMul<i64>>::Output: Bounded + NumCast + Copy, Value<i8, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<i8 as PromoteMul<i64>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: Fixed<i8, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<Fixed<i8, FRAC>> for u8

where i8: PromoteMul<u8> + Copy, u8: Copy, <i8 as PromoteMul<u8>>::Output: Bounded + NumCast + Copy, Value<i8, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<i8 as PromoteMul<u8>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: Fixed<i8, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<Fixed<i8, FRAC>> for u16

where i8: PromoteMul<u16> + Copy, u16: Copy, <i8 as PromoteMul<u16>>::Output: Bounded + NumCast + Copy, Value<i8, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<i8 as PromoteMul<u16>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: Fixed<i8, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<Fixed<i8, FRAC>> for u32

where i8: PromoteMul<u32> + Copy, u32: Copy, <i8 as PromoteMul<u32>>::Output: Bounded + NumCast + Copy, Value<i8, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<i8 as PromoteMul<u32>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: Fixed<i8, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<Fixed<i8, FRAC>> for u64

where i8: PromoteMul<u64> + Copy, u64: Copy, <i8 as PromoteMul<u64>>::Output: Bounded + NumCast + Copy, Value<i8, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<i8 as PromoteMul<u64>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: Fixed<i8, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<Fixed<i16, FRAC>> for i8

where i16: PromoteMul<i8> + Copy, i8: Copy, <i16 as PromoteMul<i8>>::Output: Bounded + NumCast + Copy, Value<i16, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<i16 as PromoteMul<i8>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: Fixed<i16, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<Fixed<i16, FRAC>> for i16

where i16: PromoteMul<i16> + Copy, <i16 as PromoteMul<i16>>::Output: Bounded + NumCast + Copy, Value<i16, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<i16 as PromoteMul<i16>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: Fixed<i16, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<Fixed<i16, FRAC>> for i32

where i16: PromoteMul<i32> + Copy, i32: Copy, <i16 as PromoteMul<i32>>::Output: Bounded + NumCast + Copy, Value<i16, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<i16 as PromoteMul<i32>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: Fixed<i16, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<Fixed<i16, FRAC>> for i64

where i16: PromoteMul<i64> + Copy, i64: Copy, <i16 as PromoteMul<i64>>::Output: Bounded + NumCast + Copy, Value<i16, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<i16 as PromoteMul<i64>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: Fixed<i16, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<Fixed<i16, FRAC>> for u8

where i16: PromoteMul<u8> + Copy, u8: Copy, <i16 as PromoteMul<u8>>::Output: Bounded + NumCast + Copy, Value<i16, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<i16 as PromoteMul<u8>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: Fixed<i16, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<Fixed<i16, FRAC>> for u16

where i16: PromoteMul<u16> + Copy, u16: Copy, <i16 as PromoteMul<u16>>::Output: Bounded + NumCast + Copy, Value<i16, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<i16 as PromoteMul<u16>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: Fixed<i16, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<Fixed<i16, FRAC>> for u32

where i16: PromoteMul<u32> + Copy, u32: Copy, <i16 as PromoteMul<u32>>::Output: Bounded + NumCast + Copy, Value<i16, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<i16 as PromoteMul<u32>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: Fixed<i16, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<Fixed<i16, FRAC>> for u64

where i16: PromoteMul<u64> + Copy, u64: Copy, <i16 as PromoteMul<u64>>::Output: Bounded + NumCast + Copy, Value<i16, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<i16 as PromoteMul<u64>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: Fixed<i16, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<Fixed<i32, FRAC>> for i8

where i32: PromoteMul<i8> + Copy, i8: Copy, <i32 as PromoteMul<i8>>::Output: Bounded + NumCast + Copy, Value<i32, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<i32 as PromoteMul<i8>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: Fixed<i32, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<Fixed<i32, FRAC>> for i16

where i32: PromoteMul<i16> + Copy, i16: Copy, <i32 as PromoteMul<i16>>::Output: Bounded + NumCast + Copy, Value<i32, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<i32 as PromoteMul<i16>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: Fixed<i32, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<Fixed<i32, FRAC>> for i32

where i32: PromoteMul<i32> + Copy, <i32 as PromoteMul<i32>>::Output: Bounded + NumCast + Copy, Value<i32, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<i32 as PromoteMul<i32>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: Fixed<i32, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<Fixed<i32, FRAC>> for i64

where i32: PromoteMul<i64> + Copy, i64: Copy, <i32 as PromoteMul<i64>>::Output: Bounded + NumCast + Copy, Value<i32, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<i32 as PromoteMul<i64>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: Fixed<i32, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<Fixed<i32, FRAC>> for u8

where i32: PromoteMul<u8> + Copy, u8: Copy, <i32 as PromoteMul<u8>>::Output: Bounded + NumCast + Copy, Value<i32, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<i32 as PromoteMul<u8>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: Fixed<i32, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<Fixed<i32, FRAC>> for u16

where i32: PromoteMul<u16> + Copy, u16: Copy, <i32 as PromoteMul<u16>>::Output: Bounded + NumCast + Copy, Value<i32, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<i32 as PromoteMul<u16>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: Fixed<i32, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<Fixed<i32, FRAC>> for u32

where i32: PromoteMul<u32> + Copy, u32: Copy, <i32 as PromoteMul<u32>>::Output: Bounded + NumCast + Copy, Value<i32, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<i32 as PromoteMul<u32>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: Fixed<i32, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<Fixed<i32, FRAC>> for u64

where i32: PromoteMul<u64> + Copy, u64: Copy, <i32 as PromoteMul<u64>>::Output: Bounded + NumCast + Copy, Value<i32, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<i32 as PromoteMul<u64>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: Fixed<i32, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<Fixed<i64, FRAC>> for i8

where i64: PromoteMul<i8> + Copy, i8: Copy, <i64 as PromoteMul<i8>>::Output: Bounded + NumCast + Copy, Value<i64, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<i64 as PromoteMul<i8>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: Fixed<i64, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<Fixed<i64, FRAC>> for i16

where i64: PromoteMul<i16> + Copy, i16: Copy, <i64 as PromoteMul<i16>>::Output: Bounded + NumCast + Copy, Value<i64, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<i64 as PromoteMul<i16>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: Fixed<i64, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<Fixed<i64, FRAC>> for i32

where i64: PromoteMul<i32> + Copy, i32: Copy, <i64 as PromoteMul<i32>>::Output: Bounded + NumCast + Copy, Value<i64, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<i64 as PromoteMul<i32>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: Fixed<i64, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<Fixed<i64, FRAC>> for i64

where i64: PromoteMul<i64> + Copy, <i64 as PromoteMul<i64>>::Output: Bounded + NumCast + Copy, Value<i64, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<i64 as PromoteMul<i64>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: Fixed<i64, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<Fixed<i64, FRAC>> for u8

where i64: PromoteMul<u8> + Copy, u8: Copy, <i64 as PromoteMul<u8>>::Output: Bounded + NumCast + Copy, Value<i64, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<i64 as PromoteMul<u8>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: Fixed<i64, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<Fixed<i64, FRAC>> for u16

where i64: PromoteMul<u16> + Copy, u16: Copy, <i64 as PromoteMul<u16>>::Output: Bounded + NumCast + Copy, Value<i64, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<i64 as PromoteMul<u16>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: Fixed<i64, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<Fixed<i64, FRAC>> for u32

where i64: PromoteMul<u32> + Copy, u32: Copy, <i64 as PromoteMul<u32>>::Output: Bounded + NumCast + Copy, Value<i64, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<i64 as PromoteMul<u32>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: Fixed<i64, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<Fixed<i64, FRAC>> for u64

where i64: PromoteMul<u64> + Copy, u64: Copy, <i64 as PromoteMul<u64>>::Output: Bounded + NumCast + Copy, Value<i64, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<i64 as PromoteMul<u64>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: Fixed<i64, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<Fixed<u8, FRAC>> for u8

where u8: PromoteMul<u8> + Copy, <u8 as PromoteMul<u8>>::Output: Bounded + NumCast + Copy, Value<u8, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<u8 as PromoteMul<u8>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: Fixed<u8, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<Fixed<u8, FRAC>> for u16

where u8: PromoteMul<u16> + Copy, u16: Copy, <u8 as PromoteMul<u16>>::Output: Bounded + NumCast + Copy, Value<u8, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<u8 as PromoteMul<u16>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: Fixed<u8, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<Fixed<u8, FRAC>> for u32

where u8: PromoteMul<u32> + Copy, u32: Copy, <u8 as PromoteMul<u32>>::Output: Bounded + NumCast + Copy, Value<u8, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<u8 as PromoteMul<u32>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: Fixed<u8, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<Fixed<u8, FRAC>> for u64

where u8: PromoteMul<u64> + Copy, u64: Copy, <u8 as PromoteMul<u64>>::Output: Bounded + NumCast + Copy, Value<u8, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<u8 as PromoteMul<u64>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: Fixed<u8, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<Fixed<u8, FRAC>> for i8

where u8: PromoteMul<i8> + Copy, i8: Copy, <u8 as PromoteMul<i8>>::Output: Bounded + NumCast + Copy, Value<u8, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<u8 as PromoteMul<i8>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: Fixed<u8, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<Fixed<u8, FRAC>> for i16

where u8: PromoteMul<i16> + Copy, i16: Copy, <u8 as PromoteMul<i16>>::Output: Bounded + NumCast + Copy, Value<u8, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<u8 as PromoteMul<i16>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: Fixed<u8, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<Fixed<u8, FRAC>> for i32

where u8: PromoteMul<i32> + Copy, i32: Copy, <u8 as PromoteMul<i32>>::Output: Bounded + NumCast + Copy, Value<u8, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<u8 as PromoteMul<i32>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: Fixed<u8, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<Fixed<u8, FRAC>> for i64

where u8: PromoteMul<i64> + Copy, i64: Copy, <u8 as PromoteMul<i64>>::Output: Bounded + NumCast + Copy, Value<u8, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<u8 as PromoteMul<i64>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: Fixed<u8, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<Fixed<u16, FRAC>> for u8

where u16: PromoteMul<u8> + Copy, u8: Copy, <u16 as PromoteMul<u8>>::Output: Bounded + NumCast + Copy, Value<u16, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<u16 as PromoteMul<u8>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: Fixed<u16, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<Fixed<u16, FRAC>> for u16

where u16: PromoteMul<u16> + Copy, <u16 as PromoteMul<u16>>::Output: Bounded + NumCast + Copy, Value<u16, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<u16 as PromoteMul<u16>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: Fixed<u16, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<Fixed<u16, FRAC>> for u32

where u16: PromoteMul<u32> + Copy, u32: Copy, <u16 as PromoteMul<u32>>::Output: Bounded + NumCast + Copy, Value<u16, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<u16 as PromoteMul<u32>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: Fixed<u16, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<Fixed<u16, FRAC>> for u64

where u16: PromoteMul<u64> + Copy, u64: Copy, <u16 as PromoteMul<u64>>::Output: Bounded + NumCast + Copy, Value<u16, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<u16 as PromoteMul<u64>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: Fixed<u16, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<Fixed<u16, FRAC>> for i8

where u16: PromoteMul<i8> + Copy, i8: Copy, <u16 as PromoteMul<i8>>::Output: Bounded + NumCast + Copy, Value<u16, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<u16 as PromoteMul<i8>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: Fixed<u16, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<Fixed<u16, FRAC>> for i16

where u16: PromoteMul<i16> + Copy, i16: Copy, <u16 as PromoteMul<i16>>::Output: Bounded + NumCast + Copy, Value<u16, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<u16 as PromoteMul<i16>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: Fixed<u16, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<Fixed<u16, FRAC>> for i32

where u16: PromoteMul<i32> + Copy, i32: Copy, <u16 as PromoteMul<i32>>::Output: Bounded + NumCast + Copy, Value<u16, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<u16 as PromoteMul<i32>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: Fixed<u16, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<Fixed<u16, FRAC>> for i64

where u16: PromoteMul<i64> + Copy, i64: Copy, <u16 as PromoteMul<i64>>::Output: Bounded + NumCast + Copy, Value<u16, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<u16 as PromoteMul<i64>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: Fixed<u16, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<Fixed<u32, FRAC>> for u8

where u32: PromoteMul<u8> + Copy, u8: Copy, <u32 as PromoteMul<u8>>::Output: Bounded + NumCast + Copy, Value<u32, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<u32 as PromoteMul<u8>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: Fixed<u32, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<Fixed<u32, FRAC>> for u16

where u32: PromoteMul<u16> + Copy, u16: Copy, <u32 as PromoteMul<u16>>::Output: Bounded + NumCast + Copy, Value<u32, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<u32 as PromoteMul<u16>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: Fixed<u32, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<Fixed<u32, FRAC>> for u32

where u32: PromoteMul<u32> + Copy, <u32 as PromoteMul<u32>>::Output: Bounded + NumCast + Copy, Value<u32, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<u32 as PromoteMul<u32>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: Fixed<u32, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<Fixed<u32, FRAC>> for u64

where u32: PromoteMul<u64> + Copy, u64: Copy, <u32 as PromoteMul<u64>>::Output: Bounded + NumCast + Copy, Value<u32, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<u32 as PromoteMul<u64>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: Fixed<u32, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<Fixed<u32, FRAC>> for i8

where u32: PromoteMul<i8> + Copy, i8: Copy, <u32 as PromoteMul<i8>>::Output: Bounded + NumCast + Copy, Value<u32, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<u32 as PromoteMul<i8>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: Fixed<u32, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<Fixed<u32, FRAC>> for i16

where u32: PromoteMul<i16> + Copy, i16: Copy, <u32 as PromoteMul<i16>>::Output: Bounded + NumCast + Copy, Value<u32, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<u32 as PromoteMul<i16>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: Fixed<u32, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<Fixed<u32, FRAC>> for i32

where u32: PromoteMul<i32> + Copy, i32: Copy, <u32 as PromoteMul<i32>>::Output: Bounded + NumCast + Copy, Value<u32, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<u32 as PromoteMul<i32>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: Fixed<u32, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<Fixed<u32, FRAC>> for i64

where u32: PromoteMul<i64> + Copy, i64: Copy, <u32 as PromoteMul<i64>>::Output: Bounded + NumCast + Copy, Value<u32, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<u32 as PromoteMul<i64>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: Fixed<u32, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<Fixed<u64, FRAC>> for u8

where u64: PromoteMul<u8> + Copy, u8: Copy, <u64 as PromoteMul<u8>>::Output: Bounded + NumCast + Copy, Value<u64, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<u64 as PromoteMul<u8>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: Fixed<u64, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<Fixed<u64, FRAC>> for u16

where u64: PromoteMul<u16> + Copy, u16: Copy, <u64 as PromoteMul<u16>>::Output: Bounded + NumCast + Copy, Value<u64, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<u64 as PromoteMul<u16>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: Fixed<u64, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<Fixed<u64, FRAC>> for u32

where u64: PromoteMul<u32> + Copy, u32: Copy, <u64 as PromoteMul<u32>>::Output: Bounded + NumCast + Copy, Value<u64, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<u64 as PromoteMul<u32>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: Fixed<u64, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<Fixed<u64, FRAC>> for u64

where u64: PromoteMul<u64> + Copy, <u64 as PromoteMul<u64>>::Output: Bounded + NumCast + Copy, Value<u64, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<u64 as PromoteMul<u64>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: Fixed<u64, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<Fixed<u64, FRAC>> for i8

where u64: PromoteMul<i8> + Copy, i8: Copy, <u64 as PromoteMul<i8>>::Output: Bounded + NumCast + Copy, Value<u64, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<u64 as PromoteMul<i8>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: Fixed<u64, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<Fixed<u64, FRAC>> for i16

where u64: PromoteMul<i16> + Copy, i16: Copy, <u64 as PromoteMul<i16>>::Output: Bounded + NumCast + Copy, Value<u64, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<u64 as PromoteMul<i16>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: Fixed<u64, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<Fixed<u64, FRAC>> for i32

where u64: PromoteMul<i32> + Copy, i32: Copy, <u64 as PromoteMul<i32>>::Output: Bounded + NumCast + Copy, Value<u64, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<u64 as PromoteMul<i32>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: Fixed<u64, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<Fixed<u64, FRAC>> for i64

where u64: PromoteMul<i64> + Copy, i64: Copy, <u64 as PromoteMul<i64>>::Output: Bounded + NumCast + Copy, Value<u64, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<u64 as PromoteMul<i64>>::Output, FRAC>

The resulting type after applying the * operator.

fn mul(self, rhs: Fixed<u64, FRAC>) -> Self::Output

Performs the * operation.

impl<const FRAC: usize> Mul<i8> for Fixed<i8, FRAC>

where i8: PromoteMul<i8> + Copy, <i8 as PromoteMul<i8>>::Output: Bounded + NumCast + Copy, Value<i8, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<i16, FRAC>

where i16: PromoteMul<i8> + Copy, i8: Copy, <i16 as PromoteMul<i8>>::Output: Bounded + NumCast + Copy, Value<i16, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<i32, FRAC>

where i32: PromoteMul<i8> + Copy, i8: Copy, <i32 as PromoteMul<i8>>::Output: Bounded + NumCast + Copy, Value<i32, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<i64, FRAC>

where i64: PromoteMul<i8> + Copy, i8: Copy, <i64 as PromoteMul<i8>>::Output: Bounded + NumCast + Copy, Value<i64, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u8, FRAC>

where u8: PromoteMul<i8> + Copy, i8: Copy, <u8 as PromoteMul<i8>>::Output: Bounded + NumCast + Copy, Value<u8, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u16, FRAC>

where u16: PromoteMul<i8> + Copy, i8: Copy, <u16 as PromoteMul<i8>>::Output: Bounded + NumCast + Copy, Value<u16, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u32, FRAC>

where u32: PromoteMul<i8> + Copy, i8: Copy, <u32 as PromoteMul<i8>>::Output: Bounded + NumCast + Copy, Value<u32, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u64, FRAC>

where u64: PromoteMul<i8> + Copy, i8: Copy, <u64 as PromoteMul<i8>>::Output: Bounded + NumCast + Copy, Value<u64, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<i8, FRAC>

where i8: PromoteMul<i16> + Copy, i16: Copy, <i8 as PromoteMul<i16>>::Output: Bounded + NumCast + Copy, Value<i8, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<i16, FRAC>

where i16: PromoteMul<i16> + Copy, <i16 as PromoteMul<i16>>::Output: Bounded + NumCast + Copy, Value<i16, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<i32, FRAC>

where i32: PromoteMul<i16> + Copy, i16: Copy, <i32 as PromoteMul<i16>>::Output: Bounded + NumCast + Copy, Value<i32, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<i64, FRAC>

where i64: PromoteMul<i16> + Copy, i16: Copy, <i64 as PromoteMul<i16>>::Output: Bounded + NumCast + Copy, Value<i64, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u8, FRAC>

where u8: PromoteMul<i16> + Copy, i16: Copy, <u8 as PromoteMul<i16>>::Output: Bounded + NumCast + Copy, Value<u8, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u16, FRAC>

where u16: PromoteMul<i16> + Copy, i16: Copy, <u16 as PromoteMul<i16>>::Output: Bounded + NumCast + Copy, Value<u16, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u32, FRAC>

where u32: PromoteMul<i16> + Copy, i16: Copy, <u32 as PromoteMul<i16>>::Output: Bounded + NumCast + Copy, Value<u32, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u64, FRAC>

where u64: PromoteMul<i16> + Copy, i16: Copy, <u64 as PromoteMul<i16>>::Output: Bounded + NumCast + Copy, Value<u64, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<i8, FRAC>

where i8: PromoteMul<i32> + Copy, i32: Copy, <i8 as PromoteMul<i32>>::Output: Bounded + NumCast + Copy, Value<i8, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<i16, FRAC>

where i16: PromoteMul<i32> + Copy, i32: Copy, <i16 as PromoteMul<i32>>::Output: Bounded + NumCast + Copy, Value<i16, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<i32, FRAC>

where i32: PromoteMul<i32> + Copy, <i32 as PromoteMul<i32>>::Output: Bounded + NumCast + Copy, Value<i32, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<i64, FRAC>

where i64: PromoteMul<i32> + Copy, i32: Copy, <i64 as PromoteMul<i32>>::Output: Bounded + NumCast + Copy, Value<i64, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u8, FRAC>

where u8: PromoteMul<i32> + Copy, i32: Copy, <u8 as PromoteMul<i32>>::Output: Bounded + NumCast + Copy, Value<u8, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u16, FRAC>

where u16: PromoteMul<i32> + Copy, i32: Copy, <u16 as PromoteMul<i32>>::Output: Bounded + NumCast + Copy, Value<u16, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u32, FRAC>

where u32: PromoteMul<i32> + Copy, i32: Copy, <u32 as PromoteMul<i32>>::Output: Bounded + NumCast + Copy, Value<u32, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u64, FRAC>

where u64: PromoteMul<i32> + Copy, i32: Copy, <u64 as PromoteMul<i32>>::Output: Bounded + NumCast + Copy, Value<u64, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<i8, FRAC>

where i8: PromoteMul<i64> + Copy, i64: Copy, <i8 as PromoteMul<i64>>::Output: Bounded + NumCast + Copy, Value<i8, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<i16, FRAC>

where i16: PromoteMul<i64> + Copy, i64: Copy, <i16 as PromoteMul<i64>>::Output: Bounded + NumCast + Copy, Value<i16, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<i32, FRAC>

where i32: PromoteMul<i64> + Copy, i64: Copy, <i32 as PromoteMul<i64>>::Output: Bounded + NumCast + Copy, Value<i32, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<i64, FRAC>

where i64: PromoteMul<i64> + Copy, <i64 as PromoteMul<i64>>::Output: Bounded + NumCast + Copy, Value<i64, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u8, FRAC>

where u8: PromoteMul<i64> + Copy, i64: Copy, <u8 as PromoteMul<i64>>::Output: Bounded + NumCast + Copy, Value<u8, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u16, FRAC>

where u16: PromoteMul<i64> + Copy, i64: Copy, <u16 as PromoteMul<i64>>::Output: Bounded + NumCast + Copy, Value<u16, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u32, FRAC>

where u32: PromoteMul<i64> + Copy, i64: Copy, <u32 as PromoteMul<i64>>::Output: Bounded + NumCast + Copy, Value<u32, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u64, FRAC>

where u64: PromoteMul<i64> + Copy, i64: Copy, <u64 as PromoteMul<i64>>::Output: Bounded + NumCast + Copy, Value<u64, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u8, FRAC>

where u8: PromoteMul<u8> + Copy, <u8 as PromoteMul<u8>>::Output: Bounded + NumCast + Copy, Value<u8, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u16, FRAC>

where u16: PromoteMul<u8> + Copy, u8: Copy, <u16 as PromoteMul<u8>>::Output: Bounded + NumCast + Copy, Value<u16, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u32, FRAC>

where u32: PromoteMul<u8> + Copy, u8: Copy, <u32 as PromoteMul<u8>>::Output: Bounded + NumCast + Copy, Value<u32, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u64, FRAC>

where u64: PromoteMul<u8> + Copy, u8: Copy, <u64 as PromoteMul<u8>>::Output: Bounded + NumCast + Copy, Value<u64, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<i8, FRAC>

where i8: PromoteMul<u8> + Copy, u8: Copy, <i8 as PromoteMul<u8>>::Output: Bounded + NumCast + Copy, Value<i8, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<i16, FRAC>

where i16: PromoteMul<u8> + Copy, u8: Copy, <i16 as PromoteMul<u8>>::Output: Bounded + NumCast + Copy, Value<i16, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<i32, FRAC>

where i32: PromoteMul<u8> + Copy, u8: Copy, <i32 as PromoteMul<u8>>::Output: Bounded + NumCast + Copy, Value<i32, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<i64, FRAC>

where i64: PromoteMul<u8> + Copy, u8: Copy, <i64 as PromoteMul<u8>>::Output: Bounded + NumCast + Copy, Value<i64, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u8, FRAC>

where u8: PromoteMul<u16> + Copy, u16: Copy, <u8 as PromoteMul<u16>>::Output: Bounded + NumCast + Copy, Value<u8, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u16, FRAC>

where u16: PromoteMul<u16> + Copy, <u16 as PromoteMul<u16>>::Output: Bounded + NumCast + Copy, Value<u16, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u32, FRAC>

where u32: PromoteMul<u16> + Copy, u16: Copy, <u32 as PromoteMul<u16>>::Output: Bounded + NumCast + Copy, Value<u32, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u64, FRAC>

where u64: PromoteMul<u16> + Copy, u16: Copy, <u64 as PromoteMul<u16>>::Output: Bounded + NumCast + Copy, Value<u64, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<i8, FRAC>

where i8: PromoteMul<u16> + Copy, u16: Copy, <i8 as PromoteMul<u16>>::Output: Bounded + NumCast + Copy, Value<i8, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<i16, FRAC>

where i16: PromoteMul<u16> + Copy, u16: Copy, <i16 as PromoteMul<u16>>::Output: Bounded + NumCast + Copy, Value<i16, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<i32, FRAC>

where i32: PromoteMul<u16> + Copy, u16: Copy, <i32 as PromoteMul<u16>>::Output: Bounded + NumCast + Copy, Value<i32, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<i64, FRAC>

where i64: PromoteMul<u16> + Copy, u16: Copy, <i64 as PromoteMul<u16>>::Output: Bounded + NumCast + Copy, Value<i64, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u8, FRAC>

where u8: PromoteMul<u32> + Copy, u32: Copy, <u8 as PromoteMul<u32>>::Output: Bounded + NumCast + Copy, Value<u8, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u16, FRAC>

where u16: PromoteMul<u32> + Copy, u32: Copy, <u16 as PromoteMul<u32>>::Output: Bounded + NumCast + Copy, Value<u16, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u32, FRAC>

where u32: PromoteMul<u32> + Copy, <u32 as PromoteMul<u32>>::Output: Bounded + NumCast + Copy, Value<u32, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u64, FRAC>

where u64: PromoteMul<u32> + Copy, u32: Copy, <u64 as PromoteMul<u32>>::Output: Bounded + NumCast + Copy, Value<u64, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<i8, FRAC>

where i8: PromoteMul<u32> + Copy, u32: Copy, <i8 as PromoteMul<u32>>::Output: Bounded + NumCast + Copy, Value<i8, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<i16, FRAC>

where i16: PromoteMul<u32> + Copy, u32: Copy, <i16 as PromoteMul<u32>>::Output: Bounded + NumCast + Copy, Value<i16, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<i32, FRAC>

where i32: PromoteMul<u32> + Copy, u32: Copy, <i32 as PromoteMul<u32>>::Output: Bounded + NumCast + Copy, Value<i32, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<i64, FRAC>

where i64: PromoteMul<u32> + Copy, u32: Copy, <i64 as PromoteMul<u32>>::Output: Bounded + NumCast + Copy, Value<i64, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u8, FRAC>

where u8: PromoteMul<u64> + Copy, u64: Copy, <u8 as PromoteMul<u64>>::Output: Bounded + NumCast + Copy, Value<u8, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u16, FRAC>

where u16: PromoteMul<u64> + Copy, u64: Copy, <u16 as PromoteMul<u64>>::Output: Bounded + NumCast + Copy, Value<u16, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u32, FRAC>

where u32: PromoteMul<u64> + Copy, u64: Copy, <u32 as PromoteMul<u64>>::Output: Bounded + NumCast + Copy, Value<u32, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u64, FRAC>

where u64: PromoteMul<u64> + Copy, <u64 as PromoteMul<u64>>::Output: Bounded + NumCast + Copy, Value<u64, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<i8, FRAC>

where i8: PromoteMul<u64> + Copy, u64: Copy, <i8 as PromoteMul<u64>>::Output: Bounded + NumCast + Copy, Value<i8, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<i16, FRAC>

where i16: PromoteMul<u64> + Copy, u64: Copy, <i16 as PromoteMul<u64>>::Output: Bounded + NumCast + Copy, Value<i16, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<i32, FRAC>

where i32: PromoteMul<u64> + Copy, u64: Copy, <i32 as PromoteMul<u64>>::Output: Bounded + NumCast + Copy, Value<i32, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<i64, FRAC>

where i64: PromoteMul<u64> + Copy, u64: Copy, <i64 as PromoteMul<u64>>::Output: Bounded + NumCast + Copy, Value<i64, FRAC>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<I, FRAC>

where I: Bounded + NumCast + Into<i128> + Copy,

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<i8> for Fixed<i8, FRAC>

where i8: PromoteMul<i8> + Bounded + NumCast + Copy, <i8 as PromoteMul<i8>>::Output: Bounded + NumCast + Copy, Value<i8, FRAC>: ConvertValue<i128, FRAC>,

fn mul_assign(&mut self, rhs: i8)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<i8> for Fixed<i16, FRAC>

where i16: PromoteMul<i8> + Bounded + NumCast + Copy, i8: Copy, <i16 as PromoteMul<i8>>::Output: Bounded + NumCast + Copy, Value<i16, FRAC>: ConvertValue<i128, FRAC>,

fn mul_assign(&mut self, rhs: i8)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<i8> for Fixed<i32, FRAC>

where i32: PromoteMul<i8> + Bounded + NumCast + Copy, i8: Copy, <i32 as PromoteMul<i8>>::Output: Bounded + NumCast + Copy, Value<i32, FRAC>: ConvertValue<i128, FRAC>,

fn mul_assign(&mut self, rhs: i8)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<i8> for Fixed<i64, FRAC>

where i64: PromoteMul<i8> + Bounded + NumCast + Copy, i8: Copy, <i64 as PromoteMul<i8>>::Output: Bounded + NumCast + Copy, Value<i64, FRAC>: ConvertValue<i128, FRAC>,

fn mul_assign(&mut self, rhs: i8)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<i8> for Fixed<u8, FRAC>

where u8: PromoteMul<i8> + Bounded + NumCast + Copy, i8: Copy, <u8 as PromoteMul<i8>>::Output: Bounded + NumCast + Copy, Value<u8, FRAC>: ConvertValue<i128, FRAC>,

fn mul_assign(&mut self, rhs: i8)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<i8> for Fixed<u16, FRAC>

where u16: PromoteMul<i8> + Bounded + NumCast + Copy, i8: Copy, <u16 as PromoteMul<i8>>::Output: Bounded + NumCast + Copy, Value<u16, FRAC>: ConvertValue<i128, FRAC>,

fn mul_assign(&mut self, rhs: i8)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<i8> for Fixed<u32, FRAC>

where u32: PromoteMul<i8> + Bounded + NumCast + Copy, i8: Copy, <u32 as PromoteMul<i8>>::Output: Bounded + NumCast + Copy, Value<u32, FRAC>: ConvertValue<i128, FRAC>,

fn mul_assign(&mut self, rhs: i8)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<i8> for Fixed<u64, FRAC>

where u64: PromoteMul<i8> + Bounded + NumCast + Copy, i8: Copy, <u64 as PromoteMul<i8>>::Output: Bounded + NumCast + Copy, Value<u64, FRAC>: ConvertValue<i128, FRAC>,

fn mul_assign(&mut self, rhs: i8)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<i16> for Fixed<i8, FRAC>

where i8: PromoteMul<i16> + Bounded + NumCast + Copy, i16: Copy, <i8 as PromoteMul<i16>>::Output: Bounded + NumCast + Copy, Value<i8, FRAC>: ConvertValue<i128, FRAC>,

fn mul_assign(&mut self, rhs: i16)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<i16> for Fixed<i16, FRAC>

where i16: PromoteMul<i16> + Bounded + NumCast + Copy, <i16 as PromoteMul<i16>>::Output: Bounded + NumCast + Copy, Value<i16, FRAC>: ConvertValue<i128, FRAC>,

fn mul_assign(&mut self, rhs: i16)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<i16> for Fixed<i32, FRAC>

where i32: PromoteMul<i16> + Bounded + NumCast + Copy, i16: Copy, <i32 as PromoteMul<i16>>::Output: Bounded + NumCast + Copy, Value<i32, FRAC>: ConvertValue<i128, FRAC>,

fn mul_assign(&mut self, rhs: i16)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<i16> for Fixed<i64, FRAC>

where i64: PromoteMul<i16> + Bounded + NumCast + Copy, i16: Copy, <i64 as PromoteMul<i16>>::Output: Bounded + NumCast + Copy, Value<i64, FRAC>: ConvertValue<i128, FRAC>,

fn mul_assign(&mut self, rhs: i16)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<i16> for Fixed<u8, FRAC>

where u8: PromoteMul<i16> + Bounded + NumCast + Copy, i16: Copy, <u8 as PromoteMul<i16>>::Output: Bounded + NumCast + Copy, Value<u8, FRAC>: ConvertValue<i128, FRAC>,

fn mul_assign(&mut self, rhs: i16)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<i16> for Fixed<u16, FRAC>

where u16: PromoteMul<i16> + Bounded + NumCast + Copy, i16: Copy, <u16 as PromoteMul<i16>>::Output: Bounded + NumCast + Copy, Value<u16, FRAC>: ConvertValue<i128, FRAC>,

fn mul_assign(&mut self, rhs: i16)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<i16> for Fixed<u32, FRAC>

where u32: PromoteMul<i16> + Bounded + NumCast + Copy, i16: Copy, <u32 as PromoteMul<i16>>::Output: Bounded + NumCast + Copy, Value<u32, FRAC>: ConvertValue<i128, FRAC>,

fn mul_assign(&mut self, rhs: i16)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<i16> for Fixed<u64, FRAC>

where u64: PromoteMul<i16> + Bounded + NumCast + Copy, i16: Copy, <u64 as PromoteMul<i16>>::Output: Bounded + NumCast + Copy, Value<u64, FRAC>: ConvertValue<i128, FRAC>,

fn mul_assign(&mut self, rhs: i16)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<i32> for Fixed<i8, FRAC>

where i8: PromoteMul<i32> + Bounded + NumCast + Copy, i32: Copy, <i8 as PromoteMul<i32>>::Output: Bounded + NumCast + Copy, Value<i8, FRAC>: ConvertValue<i128, FRAC>,

fn mul_assign(&mut self, rhs: i32)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<i32> for Fixed<i16, FRAC>

where i16: PromoteMul<i32> + Bounded + NumCast + Copy, i32: Copy, <i16 as PromoteMul<i32>>::Output: Bounded + NumCast + Copy, Value<i16, FRAC>: ConvertValue<i128, FRAC>,

fn mul_assign(&mut self, rhs: i32)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<i32> for Fixed<i32, FRAC>

where i32: PromoteMul<i32> + Bounded + NumCast + Copy, <i32 as PromoteMul<i32>>::Output: Bounded + NumCast + Copy, Value<i32, FRAC>: ConvertValue<i128, FRAC>,

fn mul_assign(&mut self, rhs: i32)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<i32> for Fixed<i64, FRAC>

where i64: PromoteMul<i32> + Bounded + NumCast + Copy, i32: Copy, <i64 as PromoteMul<i32>>::Output: Bounded + NumCast + Copy, Value<i64, FRAC>: ConvertValue<i128, FRAC>,

fn mul_assign(&mut self, rhs: i32)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<i32> for Fixed<u8, FRAC>

where u8: PromoteMul<i32> + Bounded + NumCast + Copy, i32: Copy, <u8 as PromoteMul<i32>>::Output: Bounded + NumCast + Copy, Value<u8, FRAC>: ConvertValue<i128, FRAC>,

fn mul_assign(&mut self, rhs: i32)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<i32> for Fixed<u16, FRAC>

where u16: PromoteMul<i32> + Bounded + NumCast + Copy, i32: Copy, <u16 as PromoteMul<i32>>::Output: Bounded + NumCast + Copy, Value<u16, FRAC>: ConvertValue<i128, FRAC>,

fn mul_assign(&mut self, rhs: i32)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<i32> for Fixed<u32, FRAC>

where u32: PromoteMul<i32> + Bounded + NumCast + Copy, i32: Copy, <u32 as PromoteMul<i32>>::Output: Bounded + NumCast + Copy, Value<u32, FRAC>: ConvertValue<i128, FRAC>,

fn mul_assign(&mut self, rhs: i32)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<i32> for Fixed<u64, FRAC>

where u64: PromoteMul<i32> + Bounded + NumCast + Copy, i32: Copy, <u64 as PromoteMul<i32>>::Output: Bounded + NumCast + Copy, Value<u64, FRAC>: ConvertValue<i128, FRAC>,

fn mul_assign(&mut self, rhs: i32)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<i64> for Fixed<i8, FRAC>

where i8: PromoteMul<i64> + Bounded + NumCast + Copy, i64: Copy, <i8 as PromoteMul<i64>>::Output: Bounded + NumCast + Copy, Value<i8, FRAC>: ConvertValue<i128, FRAC>,

fn mul_assign(&mut self, rhs: i64)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<i64> for Fixed<i16, FRAC>

where i16: PromoteMul<i64> + Bounded + NumCast + Copy, i64: Copy, <i16 as PromoteMul<i64>>::Output: Bounded + NumCast + Copy, Value<i16, FRAC>: ConvertValue<i128, FRAC>,

fn mul_assign(&mut self, rhs: i64)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<i64> for Fixed<i32, FRAC>

where i32: PromoteMul<i64> + Bounded + NumCast + Copy, i64: Copy, <i32 as PromoteMul<i64>>::Output: Bounded + NumCast + Copy, Value<i32, FRAC>: ConvertValue<i128, FRAC>,

fn mul_assign(&mut self, rhs: i64)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<i64> for Fixed<i64, FRAC>

where i64: PromoteMul<i64> + Bounded + NumCast + Copy, <i64 as PromoteMul<i64>>::Output: Bounded + NumCast + Copy, Value<i64, FRAC>: ConvertValue<i128, FRAC>,

fn mul_assign(&mut self, rhs: i64)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<i64> for Fixed<u8, FRAC>

where u8: PromoteMul<i64> + Bounded + NumCast + Copy, i64: Copy, <u8 as PromoteMul<i64>>::Output: Bounded + NumCast + Copy, Value<u8, FRAC>: ConvertValue<i128, FRAC>,

fn mul_assign(&mut self, rhs: i64)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<i64> for Fixed<u16, FRAC>

where u16: PromoteMul<i64> + Bounded + NumCast + Copy, i64: Copy, <u16 as PromoteMul<i64>>::Output: Bounded + NumCast + Copy, Value<u16, FRAC>: ConvertValue<i128, FRAC>,

fn mul_assign(&mut self, rhs: i64)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<i64> for Fixed<u32, FRAC>

where u32: PromoteMul<i64> + Bounded + NumCast + Copy, i64: Copy, <u32 as PromoteMul<i64>>::Output: Bounded + NumCast + Copy, Value<u32, FRAC>: ConvertValue<i128, FRAC>,

fn mul_assign(&mut self, rhs: i64)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<i64> for Fixed<u64, FRAC>

where u64: PromoteMul<i64> + Bounded + NumCast + Copy, i64: Copy, <u64 as PromoteMul<i64>>::Output: Bounded + NumCast + Copy, Value<u64, FRAC>: ConvertValue<i128, FRAC>,

fn mul_assign(&mut self, rhs: i64)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<u8> for Fixed<u8, FRAC>

where u8: PromoteMul<u8> + Bounded + NumCast + Copy, <u8 as PromoteMul<u8>>::Output: Bounded + NumCast + Copy, Value<u8, FRAC>: ConvertValue<i128, FRAC>,

fn mul_assign(&mut self, rhs: u8)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<u8> for Fixed<u16, FRAC>

where u16: PromoteMul<u8> + Bounded + NumCast + Copy, u8: Copy, <u16 as PromoteMul<u8>>::Output: Bounded + NumCast + Copy, Value<u16, FRAC>: ConvertValue<i128, FRAC>,

fn mul_assign(&mut self, rhs: u8)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<u8> for Fixed<u32, FRAC>

where u32: PromoteMul<u8> + Bounded + NumCast + Copy, u8: Copy, <u32 as PromoteMul<u8>>::Output: Bounded + NumCast + Copy, Value<u32, FRAC>: ConvertValue<i128, FRAC>,

fn mul_assign(&mut self, rhs: u8)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<u8> for Fixed<u64, FRAC>

where u64: PromoteMul<u8> + Bounded + NumCast + Copy, u8: Copy, <u64 as PromoteMul<u8>>::Output: Bounded + NumCast + Copy, Value<u64, FRAC>: ConvertValue<i128, FRAC>,

fn mul_assign(&mut self, rhs: u8)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<u8> for Fixed<i8, FRAC>

where i8: PromoteMul<u8> + Bounded + NumCast + Copy, u8: Copy, <i8 as PromoteMul<u8>>::Output: Bounded + NumCast + Copy, Value<i8, FRAC>: ConvertValue<i128, FRAC>,

fn mul_assign(&mut self, rhs: u8)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<u8> for Fixed<i16, FRAC>

where i16: PromoteMul<u8> + Bounded + NumCast + Copy, u8: Copy, <i16 as PromoteMul<u8>>::Output: Bounded + NumCast + Copy, Value<i16, FRAC>: ConvertValue<i128, FRAC>,

fn mul_assign(&mut self, rhs: u8)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<u8> for Fixed<i32, FRAC>

where i32: PromoteMul<u8> + Bounded + NumCast + Copy, u8: Copy, <i32 as PromoteMul<u8>>::Output: Bounded + NumCast + Copy, Value<i32, FRAC>: ConvertValue<i128, FRAC>,

fn mul_assign(&mut self, rhs: u8)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<u8> for Fixed<i64, FRAC>

where i64: PromoteMul<u8> + Bounded + NumCast + Copy, u8: Copy, <i64 as PromoteMul<u8>>::Output: Bounded + NumCast + Copy, Value<i64, FRAC>: ConvertValue<i128, FRAC>,

fn mul_assign(&mut self, rhs: u8)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<u16> for Fixed<u8, FRAC>

where u8: PromoteMul<u16> + Bounded + NumCast + Copy, u16: Copy, <u8 as PromoteMul<u16>>::Output: Bounded + NumCast + Copy, Value<u8, FRAC>: ConvertValue<i128, FRAC>,

fn mul_assign(&mut self, rhs: u16)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<u16> for Fixed<u16, FRAC>

where u16: PromoteMul<u16> + Bounded + NumCast + Copy, <u16 as PromoteMul<u16>>::Output: Bounded + NumCast + Copy, Value<u16, FRAC>: ConvertValue<i128, FRAC>,

fn mul_assign(&mut self, rhs: u16)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<u16> for Fixed<u32, FRAC>

where u32: PromoteMul<u16> + Bounded + NumCast + Copy, u16: Copy, <u32 as PromoteMul<u16>>::Output: Bounded + NumCast + Copy, Value<u32, FRAC>: ConvertValue<i128, FRAC>,

fn mul_assign(&mut self, rhs: u16)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<u16> for Fixed<u64, FRAC>

where u64: PromoteMul<u16> + Bounded + NumCast + Copy, u16: Copy, <u64 as PromoteMul<u16>>::Output: Bounded + NumCast + Copy, Value<u64, FRAC>: ConvertValue<i128, FRAC>,

fn mul_assign(&mut self, rhs: u16)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<u16> for Fixed<i8, FRAC>

where i8: PromoteMul<u16> + Bounded + NumCast + Copy, u16: Copy, <i8 as PromoteMul<u16>>::Output: Bounded + NumCast + Copy, Value<i8, FRAC>: ConvertValue<i128, FRAC>,

fn mul_assign(&mut self, rhs: u16)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<u16> for Fixed<i16, FRAC>

where i16: PromoteMul<u16> + Bounded + NumCast + Copy, u16: Copy, <i16 as PromoteMul<u16>>::Output: Bounded + NumCast + Copy, Value<i16, FRAC>: ConvertValue<i128, FRAC>,

fn mul_assign(&mut self, rhs: u16)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<u16> for Fixed<i32, FRAC>

where i32: PromoteMul<u16> + Bounded + NumCast + Copy, u16: Copy, <i32 as PromoteMul<u16>>::Output: Bounded + NumCast + Copy, Value<i32, FRAC>: ConvertValue<i128, FRAC>,

fn mul_assign(&mut self, rhs: u16)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<u16> for Fixed<i64, FRAC>

where i64: PromoteMul<u16> + Bounded + NumCast + Copy, u16: Copy, <i64 as PromoteMul<u16>>::Output: Bounded + NumCast + Copy, Value<i64, FRAC>: ConvertValue<i128, FRAC>,

fn mul_assign(&mut self, rhs: u16)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<u32> for Fixed<u8, FRAC>

where u8: PromoteMul<u32> + Bounded + NumCast + Copy, u32: Copy, <u8 as PromoteMul<u32>>::Output: Bounded + NumCast + Copy, Value<u8, FRAC>: ConvertValue<i128, FRAC>,

fn mul_assign(&mut self, rhs: u32)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<u32> for Fixed<u16, FRAC>

where u16: PromoteMul<u32> + Bounded + NumCast + Copy, u32: Copy, <u16 as PromoteMul<u32>>::Output: Bounded + NumCast + Copy, Value<u16, FRAC>: ConvertValue<i128, FRAC>,

fn mul_assign(&mut self, rhs: u32)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<u32> for Fixed<u32, FRAC>

where u32: PromoteMul<u32> + Bounded + NumCast + Copy, <u32 as PromoteMul<u32>>::Output: Bounded + NumCast + Copy, Value<u32, FRAC>: ConvertValue<i128, FRAC>,

fn mul_assign(&mut self, rhs: u32)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<u32> for Fixed<u64, FRAC>

where u64: PromoteMul<u32> + Bounded + NumCast + Copy, u32: Copy, <u64 as PromoteMul<u32>>::Output: Bounded + NumCast + Copy, Value<u64, FRAC>: ConvertValue<i128, FRAC>,

fn mul_assign(&mut self, rhs: u32)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<u32> for Fixed<i8, FRAC>

where i8: PromoteMul<u32> + Bounded + NumCast + Copy, u32: Copy, <i8 as PromoteMul<u32>>::Output: Bounded + NumCast + Copy, Value<i8, FRAC>: ConvertValue<i128, FRAC>,

fn mul_assign(&mut self, rhs: u32)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<u32> for Fixed<i16, FRAC>

where i16: PromoteMul<u32> + Bounded + NumCast + Copy, u32: Copy, <i16 as PromoteMul<u32>>::Output: Bounded + NumCast + Copy, Value<i16, FRAC>: ConvertValue<i128, FRAC>,

fn mul_assign(&mut self, rhs: u32)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<u32> for Fixed<i32, FRAC>

where i32: PromoteMul<u32> + Bounded + NumCast + Copy, u32: Copy, <i32 as PromoteMul<u32>>::Output: Bounded + NumCast + Copy, Value<i32, FRAC>: ConvertValue<i128, FRAC>,

fn mul_assign(&mut self, rhs: u32)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<u32> for Fixed<i64, FRAC>

where i64: PromoteMul<u32> + Bounded + NumCast + Copy, u32: Copy, <i64 as PromoteMul<u32>>::Output: Bounded + NumCast + Copy, Value<i64, FRAC>: ConvertValue<i128, FRAC>,

fn mul_assign(&mut self, rhs: u32)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<u64> for Fixed<u8, FRAC>

where u8: PromoteMul<u64> + Bounded + NumCast + Copy, u64: Copy, <u8 as PromoteMul<u64>>::Output: Bounded + NumCast + Copy, Value<u8, FRAC>: ConvertValue<i128, FRAC>,

fn mul_assign(&mut self, rhs: u64)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<u64> for Fixed<u16, FRAC>

where u16: PromoteMul<u64> + Bounded + NumCast + Copy, u64: Copy, <u16 as PromoteMul<u64>>::Output: Bounded + NumCast + Copy, Value<u16, FRAC>: ConvertValue<i128, FRAC>,

fn mul_assign(&mut self, rhs: u64)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<u64> for Fixed<u32, FRAC>

where u32: PromoteMul<u64> + Bounded + NumCast + Copy, u64: Copy, <u32 as PromoteMul<u64>>::Output: Bounded + NumCast + Copy, Value<u32, FRAC>: ConvertValue<i128, FRAC>,

fn mul_assign(&mut self, rhs: u64)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<u64> for Fixed<u64, FRAC>

where u64: PromoteMul<u64> + Bounded + NumCast + Copy, <u64 as PromoteMul<u64>>::Output: Bounded + NumCast + Copy, Value<u64, FRAC>: ConvertValue<i128, FRAC>,

fn mul_assign(&mut self, rhs: u64)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<u64> for Fixed<i8, FRAC>

where i8: PromoteMul<u64> + Bounded + NumCast + Copy, u64: Copy, <i8 as PromoteMul<u64>>::Output: Bounded + NumCast + Copy, Value<i8, FRAC>: ConvertValue<i128, FRAC>,

fn mul_assign(&mut self, rhs: u64)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<u64> for Fixed<i16, FRAC>

where i16: PromoteMul<u64> + Bounded + NumCast + Copy, u64: Copy, <i16 as PromoteMul<u64>>::Output: Bounded + NumCast + Copy, Value<i16, FRAC>: ConvertValue<i128, FRAC>,

fn mul_assign(&mut self, rhs: u64)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<u64> for Fixed<i32, FRAC>

where i32: PromoteMul<u64> + Bounded + NumCast + Copy, u64: Copy, <i32 as PromoteMul<u64>>::Output: Bounded + NumCast + Copy, Value<i32, FRAC>: ConvertValue<i128, FRAC>,

fn mul_assign(&mut self, rhs: u64)

Performs the *= operation.

impl<const FRAC: usize> MulAssign<u64> for Fixed<i64, FRAC>

where i64: PromoteMul<u64> + Bounded + NumCast + Copy, u64: Copy, <i64 as PromoteMul<u64>>::Output: Bounded + NumCast + Copy, Value<i64, FRAC>: ConvertValue<i128, FRAC>,

fn mul_assign(&mut self, rhs: u64)

Performs the *= operation.

impl<I, const FRAC: usize> Neg for Fixed<I, FRAC>

where I: Bounded + NumCast + Copy + Signed + Into<i128>,

type Output = Fixed<I, FRAC>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<I, const FRAC: usize> Ord for Fixed<I, FRAC>

where I: Into<i128> + Copy,

Note: In Rust, Ord only permits comparing Self with Self (same integer type and fractional bit count FRAC). Cross-scale and cross-type comparisons are provided via PartialOrd.

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

This method returns an [Ordering] between self and other.

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

where Self: Sized,

Compares and returns the maximum of two values.

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

where Self: Sized,

Compares and returns the minimum of two values.

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

where Self: Sized,

Restrict a value to a certain interval.

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, const F1: usize, OtherI, const F2: usize> PartialEq<Fixed<OtherI, F2>> for Fixed<I, F1>

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

fn eq(&self, other: &Fixed<OtherI, F2>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<Fixed<i8, FRAC>> for i8

where Value<i8, FRAC>: ConvertValue<i128, FRAC>, Value<i8, 0>: ConvertValue<i128, FRAC>,

fn eq(&self, other: &Fixed<i8, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<Fixed<i8, FRAC>> for i16

where Value<i8, FRAC>: ConvertValue<i128, FRAC>, Value<i16, 0>: ConvertValue<i128, FRAC>,

fn eq(&self, other: &Fixed<i8, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<Fixed<i8, FRAC>> for i32

where Value<i8, FRAC>: ConvertValue<i128, FRAC>, Value<i32, 0>: ConvertValue<i128, FRAC>,

fn eq(&self, other: &Fixed<i8, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<Fixed<i8, FRAC>> for i64

where Value<i8, FRAC>: ConvertValue<i128, FRAC>, Value<i64, 0>: ConvertValue<i128, FRAC>,

fn eq(&self, other: &Fixed<i8, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<Fixed<i8, FRAC>> for u8

where Value<i8, FRAC>: ConvertValue<i128, FRAC>, Value<u8, 0>: ConvertValue<i128, FRAC>,

fn eq(&self, other: &Fixed<i8, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<Fixed<i8, FRAC>> for u16

where Value<i8, FRAC>: ConvertValue<i128, FRAC>, Value<u16, 0>: ConvertValue<i128, FRAC>,

fn eq(&self, other: &Fixed<i8, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<Fixed<i8, FRAC>> for u32

where Value<i8, FRAC>: ConvertValue<i128, FRAC>, Value<u32, 0>: ConvertValue<i128, FRAC>,

fn eq(&self, other: &Fixed<i8, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<Fixed<i8, FRAC>> for u64

where Value<i8, FRAC>: ConvertValue<i128, FRAC>, Value<u64, 0>: ConvertValue<i128, FRAC>,

fn eq(&self, other: &Fixed<i8, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<Fixed<i16, FRAC>> for i8

where Value<i16, FRAC>: ConvertValue<i128, FRAC>, Value<i8, 0>: ConvertValue<i128, FRAC>,

fn eq(&self, other: &Fixed<i16, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<Fixed<i16, FRAC>> for i16

where Value<i16, FRAC>: ConvertValue<i128, FRAC>, Value<i16, 0>: ConvertValue<i128, FRAC>,

fn eq(&self, other: &Fixed<i16, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<Fixed<i16, FRAC>> for i32

where Value<i16, FRAC>: ConvertValue<i128, FRAC>, Value<i32, 0>: ConvertValue<i128, FRAC>,

fn eq(&self, other: &Fixed<i16, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<Fixed<i16, FRAC>> for i64

where Value<i16, FRAC>: ConvertValue<i128, FRAC>, Value<i64, 0>: ConvertValue<i128, FRAC>,

fn eq(&self, other: &Fixed<i16, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<Fixed<i16, FRAC>> for u8

where Value<i16, FRAC>: ConvertValue<i128, FRAC>, Value<u8, 0>: ConvertValue<i128, FRAC>,

fn eq(&self, other: &Fixed<i16, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<Fixed<i16, FRAC>> for u16

where Value<i16, FRAC>: ConvertValue<i128, FRAC>, Value<u16, 0>: ConvertValue<i128, FRAC>,

fn eq(&self, other: &Fixed<i16, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<Fixed<i16, FRAC>> for u32

where Value<i16, FRAC>: ConvertValue<i128, FRAC>, Value<u32, 0>: ConvertValue<i128, FRAC>,

fn eq(&self, other: &Fixed<i16, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<Fixed<i16, FRAC>> for u64

where Value<i16, FRAC>: ConvertValue<i128, FRAC>, Value<u64, 0>: ConvertValue<i128, FRAC>,

fn eq(&self, other: &Fixed<i16, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<Fixed<i32, FRAC>> for i8

where Value<i32, FRAC>: ConvertValue<i128, FRAC>, Value<i8, 0>: ConvertValue<i128, FRAC>,

fn eq(&self, other: &Fixed<i32, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<Fixed<i32, FRAC>> for i16

where Value<i32, FRAC>: ConvertValue<i128, FRAC>, Value<i16, 0>: ConvertValue<i128, FRAC>,

fn eq(&self, other: &Fixed<i32, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<Fixed<i32, FRAC>> for i32

where Value<i32, FRAC>: ConvertValue<i128, FRAC>, Value<i32, 0>: ConvertValue<i128, FRAC>,

fn eq(&self, other: &Fixed<i32, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<Fixed<i32, FRAC>> for i64

where Value<i32, FRAC>: ConvertValue<i128, FRAC>, Value<i64, 0>: ConvertValue<i128, FRAC>,

fn eq(&self, other: &Fixed<i32, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<Fixed<i32, FRAC>> for u8

where Value<i32, FRAC>: ConvertValue<i128, FRAC>, Value<u8, 0>: ConvertValue<i128, FRAC>,

fn eq(&self, other: &Fixed<i32, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<Fixed<i32, FRAC>> for u16

where Value<i32, FRAC>: ConvertValue<i128, FRAC>, Value<u16, 0>: ConvertValue<i128, FRAC>,

fn eq(&self, other: &Fixed<i32, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<Fixed<i32, FRAC>> for u32

where Value<i32, FRAC>: ConvertValue<i128, FRAC>, Value<u32, 0>: ConvertValue<i128, FRAC>,

fn eq(&self, other: &Fixed<i32, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<Fixed<i32, FRAC>> for u64

where Value<i32, FRAC>: ConvertValue<i128, FRAC>, Value<u64, 0>: ConvertValue<i128, FRAC>,

fn eq(&self, other: &Fixed<i32, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<Fixed<i64, FRAC>> for i8

where Value<i64, FRAC>: ConvertValue<i128, FRAC>, Value<i8, 0>: ConvertValue<i128, FRAC>,

fn eq(&self, other: &Fixed<i64, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<Fixed<i64, FRAC>> for i16

where Value<i64, FRAC>: ConvertValue<i128, FRAC>, Value<i16, 0>: ConvertValue<i128, FRAC>,

fn eq(&self, other: &Fixed<i64, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<Fixed<i64, FRAC>> for i32

where Value<i64, FRAC>: ConvertValue<i128, FRAC>, Value<i32, 0>: ConvertValue<i128, FRAC>,

fn eq(&self, other: &Fixed<i64, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<Fixed<i64, FRAC>> for i64

where Value<i64, FRAC>: ConvertValue<i128, FRAC>, Value<i64, 0>: ConvertValue<i128, FRAC>,

fn eq(&self, other: &Fixed<i64, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<Fixed<i64, FRAC>> for u8

where Value<i64, FRAC>: ConvertValue<i128, FRAC>, Value<u8, 0>: ConvertValue<i128, FRAC>,

fn eq(&self, other: &Fixed<i64, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<Fixed<i64, FRAC>> for u16

where Value<i64, FRAC>: ConvertValue<i128, FRAC>, Value<u16, 0>: ConvertValue<i128, FRAC>,

fn eq(&self, other: &Fixed<i64, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<Fixed<i64, FRAC>> for u32

where Value<i64, FRAC>: ConvertValue<i128, FRAC>, Value<u32, 0>: ConvertValue<i128, FRAC>,

fn eq(&self, other: &Fixed<i64, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<Fixed<i64, FRAC>> for u64

where Value<i64, FRAC>: ConvertValue<i128, FRAC>, Value<u64, 0>: ConvertValue<i128, FRAC>,

fn eq(&self, other: &Fixed<i64, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<Fixed<u8, FRAC>> for u8

where Value<u8, FRAC>: ConvertValue<i128, FRAC>, Value<u8, 0>: ConvertValue<i128, FRAC>,

fn eq(&self, other: &Fixed<u8, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<Fixed<u8, FRAC>> for u16

where Value<u8, FRAC>: ConvertValue<i128, FRAC>, Value<u16, 0>: ConvertValue<i128, FRAC>,

fn eq(&self, other: &Fixed<u8, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<Fixed<u8, FRAC>> for u32

where Value<u8, FRAC>: ConvertValue<i128, FRAC>, Value<u32, 0>: ConvertValue<i128, FRAC>,

fn eq(&self, other: &Fixed<u8, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<Fixed<u8, FRAC>> for u64

where Value<u8, FRAC>: ConvertValue<i128, FRAC>, Value<u64, 0>: ConvertValue<i128, FRAC>,

fn eq(&self, other: &Fixed<u8, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<Fixed<u8, FRAC>> for i8

where Value<u8, FRAC>: ConvertValue<i128, FRAC>, Value<i8, 0>: ConvertValue<i128, FRAC>,

fn eq(&self, other: &Fixed<u8, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<Fixed<u8, FRAC>> for i16

where Value<u8, FRAC>: ConvertValue<i128, FRAC>, Value<i16, 0>: ConvertValue<i128, FRAC>,

fn eq(&self, other: &Fixed<u8, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<Fixed<u8, FRAC>> for i32

where Value<u8, FRAC>: ConvertValue<i128, FRAC>, Value<i32, 0>: ConvertValue<i128, FRAC>,

fn eq(&self, other: &Fixed<u8, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<Fixed<u8, FRAC>> for i64

where Value<u8, FRAC>: ConvertValue<i128, FRAC>, Value<i64, 0>: ConvertValue<i128, FRAC>,

fn eq(&self, other: &Fixed<u8, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<Fixed<u16, FRAC>> for u8

where Value<u16, FRAC>: ConvertValue<i128, FRAC>, Value<u8, 0>: ConvertValue<i128, FRAC>,

fn eq(&self, other: &Fixed<u16, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<Fixed<u16, FRAC>> for u16

where Value<u16, FRAC>: ConvertValue<i128, FRAC>, Value<u16, 0>: ConvertValue<i128, FRAC>,

fn eq(&self, other: &Fixed<u16, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<Fixed<u16, FRAC>> for u32

where Value<u16, FRAC>: ConvertValue<i128, FRAC>, Value<u32, 0>: ConvertValue<i128, FRAC>,

fn eq(&self, other: &Fixed<u16, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<Fixed<u16, FRAC>> for u64

where Value<u16, FRAC>: ConvertValue<i128, FRAC>, Value<u64, 0>: ConvertValue<i128, FRAC>,

fn eq(&self, other: &Fixed<u16, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<Fixed<u16, FRAC>> for i8

where Value<u16, FRAC>: ConvertValue<i128, FRAC>, Value<i8, 0>: ConvertValue<i128, FRAC>,

fn eq(&self, other: &Fixed<u16, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<Fixed<u16, FRAC>> for i16

where Value<u16, FRAC>: ConvertValue<i128, FRAC>, Value<i16, 0>: ConvertValue<i128, FRAC>,

fn eq(&self, other: &Fixed<u16, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<Fixed<u16, FRAC>> for i32

where Value<u16, FRAC>: ConvertValue<i128, FRAC>, Value<i32, 0>: ConvertValue<i128, FRAC>,

fn eq(&self, other: &Fixed<u16, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<Fixed<u16, FRAC>> for i64

where Value<u16, FRAC>: ConvertValue<i128, FRAC>, Value<i64, 0>: ConvertValue<i128, FRAC>,

fn eq(&self, other: &Fixed<u16, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<Fixed<u32, FRAC>> for u8

where Value<u32, FRAC>: ConvertValue<i128, FRAC>, Value<u8, 0>: ConvertValue<i128, FRAC>,

fn eq(&self, other: &Fixed<u32, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<Fixed<u32, FRAC>> for u16

where Value<u32, FRAC>: ConvertValue<i128, FRAC>, Value<u16, 0>: ConvertValue<i128, FRAC>,

fn eq(&self, other: &Fixed<u32, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<Fixed<u32, FRAC>> for u32

where Value<u32, FRAC>: ConvertValue<i128, FRAC>, Value<u32, 0>: ConvertValue<i128, FRAC>,

fn eq(&self, other: &Fixed<u32, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<Fixed<u32, FRAC>> for u64

where Value<u32, FRAC>: ConvertValue<i128, FRAC>, Value<u64, 0>: ConvertValue<i128, FRAC>,

fn eq(&self, other: &Fixed<u32, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<Fixed<u32, FRAC>> for i8

where Value<u32, FRAC>: ConvertValue<i128, FRAC>, Value<i8, 0>: ConvertValue<i128, FRAC>,

fn eq(&self, other: &Fixed<u32, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<Fixed<u32, FRAC>> for i16

where Value<u32, FRAC>: ConvertValue<i128, FRAC>, Value<i16, 0>: ConvertValue<i128, FRAC>,

fn eq(&self, other: &Fixed<u32, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<Fixed<u32, FRAC>> for i32

where Value<u32, FRAC>: ConvertValue<i128, FRAC>, Value<i32, 0>: ConvertValue<i128, FRAC>,

fn eq(&self, other: &Fixed<u32, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<Fixed<u32, FRAC>> for i64

where Value<u32, FRAC>: ConvertValue<i128, FRAC>, Value<i64, 0>: ConvertValue<i128, FRAC>,

fn eq(&self, other: &Fixed<u32, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<Fixed<u64, FRAC>> for u8

where Value<u64, FRAC>: ConvertValue<i128, FRAC>, Value<u8, 0>: ConvertValue<i128, FRAC>,

fn eq(&self, other: &Fixed<u64, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<Fixed<u64, FRAC>> for u16

where Value<u64, FRAC>: ConvertValue<i128, FRAC>, Value<u16, 0>: ConvertValue<i128, FRAC>,

fn eq(&self, other: &Fixed<u64, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<Fixed<u64, FRAC>> for u32

where Value<u64, FRAC>: ConvertValue<i128, FRAC>, Value<u32, 0>: ConvertValue<i128, FRAC>,

fn eq(&self, other: &Fixed<u64, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<Fixed<u64, FRAC>> for u64

where Value<u64, FRAC>: ConvertValue<i128, FRAC>, Value<u64, 0>: ConvertValue<i128, FRAC>,

fn eq(&self, other: &Fixed<u64, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<Fixed<u64, FRAC>> for i8

where Value<u64, FRAC>: ConvertValue<i128, FRAC>, Value<i8, 0>: ConvertValue<i128, FRAC>,

fn eq(&self, other: &Fixed<u64, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<Fixed<u64, FRAC>> for i16

where Value<u64, FRAC>: ConvertValue<i128, FRAC>, Value<i16, 0>: ConvertValue<i128, FRAC>,

fn eq(&self, other: &Fixed<u64, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<Fixed<u64, FRAC>> for i32

where Value<u64, FRAC>: ConvertValue<i128, FRAC>, Value<i32, 0>: ConvertValue<i128, FRAC>,

fn eq(&self, other: &Fixed<u64, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<Fixed<u64, FRAC>> for i64

where Value<u64, FRAC>: ConvertValue<i128, FRAC>, Value<i64, 0>: ConvertValue<i128, FRAC>,

fn eq(&self, other: &Fixed<u64, FRAC>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<i8> for Fixed<i8, FRAC>

where Value<i8, FRAC>: ConvertValue<i128, FRAC>, Value<i8, 0>: ConvertValue<i128, FRAC>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<i8> for Fixed<i16, FRAC>

where Value<i16, FRAC>: ConvertValue<i128, FRAC>, Value<i8, 0>: ConvertValue<i128, FRAC>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<i8> for Fixed<i32, FRAC>

where Value<i32, FRAC>: ConvertValue<i128, FRAC>, Value<i8, 0>: ConvertValue<i128, FRAC>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<i8> for Fixed<i64, FRAC>

where Value<i64, FRAC>: ConvertValue<i128, FRAC>, Value<i8, 0>: ConvertValue<i128, FRAC>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<i8> for Fixed<u8, FRAC>

where Value<u8, FRAC>: ConvertValue<i128, FRAC>, Value<i8, 0>: ConvertValue<i128, FRAC>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<i8> for Fixed<u16, FRAC>

where Value<u16, FRAC>: ConvertValue<i128, FRAC>, Value<i8, 0>: ConvertValue<i128, FRAC>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<i8> for Fixed<u32, FRAC>

where Value<u32, FRAC>: ConvertValue<i128, FRAC>, Value<i8, 0>: ConvertValue<i128, FRAC>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<i8> for Fixed<u64, FRAC>

where Value<u64, FRAC>: ConvertValue<i128, FRAC>, Value<i8, 0>: ConvertValue<i128, FRAC>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<i16> for Fixed<i8, FRAC>

where Value<i8, FRAC>: ConvertValue<i128, FRAC>, Value<i16, 0>: ConvertValue<i128, FRAC>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<i16> for Fixed<i16, FRAC>

where Value<i16, FRAC>: ConvertValue<i128, FRAC>, Value<i16, 0>: ConvertValue<i128, FRAC>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<i16> for Fixed<i32, FRAC>

where Value<i32, FRAC>: ConvertValue<i128, FRAC>, Value<i16, 0>: ConvertValue<i128, FRAC>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<i16> for Fixed<i64, FRAC>

where Value<i64, FRAC>: ConvertValue<i128, FRAC>, Value<i16, 0>: ConvertValue<i128, FRAC>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<i16> for Fixed<u8, FRAC>

where Value<u8, FRAC>: ConvertValue<i128, FRAC>, Value<i16, 0>: ConvertValue<i128, FRAC>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<i16> for Fixed<u16, FRAC>

where Value<u16, FRAC>: ConvertValue<i128, FRAC>, Value<i16, 0>: ConvertValue<i128, FRAC>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<i16> for Fixed<u32, FRAC>

where Value<u32, FRAC>: ConvertValue<i128, FRAC>, Value<i16, 0>: ConvertValue<i128, FRAC>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<i16> for Fixed<u64, FRAC>

where Value<u64, FRAC>: ConvertValue<i128, FRAC>, Value<i16, 0>: ConvertValue<i128, FRAC>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<i32> for Fixed<i8, FRAC>

where Value<i8, FRAC>: ConvertValue<i128, FRAC>, Value<i32, 0>: ConvertValue<i128, FRAC>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<i32> for Fixed<i16, FRAC>

where Value<i16, FRAC>: ConvertValue<i128, FRAC>, Value<i32, 0>: ConvertValue<i128, FRAC>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<i32> for Fixed<i32, FRAC>

where Value<i32, FRAC>: ConvertValue<i128, FRAC>, Value<i32, 0>: ConvertValue<i128, FRAC>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<i32> for Fixed<i64, FRAC>

where Value<i64, FRAC>: ConvertValue<i128, FRAC>, Value<i32, 0>: ConvertValue<i128, FRAC>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<i32> for Fixed<u8, FRAC>

where Value<u8, FRAC>: ConvertValue<i128, FRAC>, Value<i32, 0>: ConvertValue<i128, FRAC>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<i32> for Fixed<u16, FRAC>

where Value<u16, FRAC>: ConvertValue<i128, FRAC>, Value<i32, 0>: ConvertValue<i128, FRAC>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<i32> for Fixed<u32, FRAC>

where Value<u32, FRAC>: ConvertValue<i128, FRAC>, Value<i32, 0>: ConvertValue<i128, FRAC>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<i32> for Fixed<u64, FRAC>

where Value<u64, FRAC>: ConvertValue<i128, FRAC>, Value<i32, 0>: ConvertValue<i128, FRAC>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<i64> for Fixed<i8, FRAC>

where Value<i8, FRAC>: ConvertValue<i128, FRAC>, Value<i64, 0>: ConvertValue<i128, FRAC>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<i64> for Fixed<i16, FRAC>

where Value<i16, FRAC>: ConvertValue<i128, FRAC>, Value<i64, 0>: ConvertValue<i128, FRAC>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<i64> for Fixed<i32, FRAC>

where Value<i32, FRAC>: ConvertValue<i128, FRAC>, Value<i64, 0>: ConvertValue<i128, FRAC>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<i64> for Fixed<i64, FRAC>

where Value<i64, FRAC>: ConvertValue<i128, FRAC>, Value<i64, 0>: ConvertValue<i128, FRAC>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<i64> for Fixed<u8, FRAC>

where Value<u8, FRAC>: ConvertValue<i128, FRAC>, Value<i64, 0>: ConvertValue<i128, FRAC>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<i64> for Fixed<u16, FRAC>

where Value<u16, FRAC>: ConvertValue<i128, FRAC>, Value<i64, 0>: ConvertValue<i128, FRAC>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<i64> for Fixed<u32, FRAC>

where Value<u32, FRAC>: ConvertValue<i128, FRAC>, Value<i64, 0>: ConvertValue<i128, FRAC>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<i64> for Fixed<u64, FRAC>

where Value<u64, FRAC>: ConvertValue<i128, FRAC>, Value<i64, 0>: ConvertValue<i128, FRAC>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<u8> for Fixed<u8, FRAC>

where Value<u8, FRAC>: ConvertValue<i128, FRAC>, Value<u8, 0>: ConvertValue<i128, FRAC>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<u8> for Fixed<u16, FRAC>

where Value<u16, FRAC>: ConvertValue<i128, FRAC>, Value<u8, 0>: ConvertValue<i128, FRAC>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<u8> for Fixed<u32, FRAC>

where Value<u32, FRAC>: ConvertValue<i128, FRAC>, Value<u8, 0>: ConvertValue<i128, FRAC>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<u8> for Fixed<u64, FRAC>

where Value<u64, FRAC>: ConvertValue<i128, FRAC>, Value<u8, 0>: ConvertValue<i128, FRAC>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<u8> for Fixed<i8, FRAC>

where Value<i8, FRAC>: ConvertValue<i128, FRAC>, Value<u8, 0>: ConvertValue<i128, FRAC>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<u8> for Fixed<i16, FRAC>

where Value<i16, FRAC>: ConvertValue<i128, FRAC>, Value<u8, 0>: ConvertValue<i128, FRAC>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<u8> for Fixed<i32, FRAC>

where Value<i32, FRAC>: ConvertValue<i128, FRAC>, Value<u8, 0>: ConvertValue<i128, FRAC>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<u8> for Fixed<i64, FRAC>

where Value<i64, FRAC>: ConvertValue<i128, FRAC>, Value<u8, 0>: ConvertValue<i128, FRAC>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<u16> for Fixed<u8, FRAC>

where Value<u8, FRAC>: ConvertValue<i128, FRAC>, Value<u16, 0>: ConvertValue<i128, FRAC>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<u16> for Fixed<u16, FRAC>

where Value<u16, FRAC>: ConvertValue<i128, FRAC>, Value<u16, 0>: ConvertValue<i128, FRAC>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<u16> for Fixed<u32, FRAC>

where Value<u32, FRAC>: ConvertValue<i128, FRAC>, Value<u16, 0>: ConvertValue<i128, FRAC>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<u16> for Fixed<u64, FRAC>

where Value<u64, FRAC>: ConvertValue<i128, FRAC>, Value<u16, 0>: ConvertValue<i128, FRAC>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<u16> for Fixed<i8, FRAC>

where Value<i8, FRAC>: ConvertValue<i128, FRAC>, Value<u16, 0>: ConvertValue<i128, FRAC>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<u16> for Fixed<i16, FRAC>

where Value<i16, FRAC>: ConvertValue<i128, FRAC>, Value<u16, 0>: ConvertValue<i128, FRAC>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<u16> for Fixed<i32, FRAC>

where Value<i32, FRAC>: ConvertValue<i128, FRAC>, Value<u16, 0>: ConvertValue<i128, FRAC>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<u16> for Fixed<i64, FRAC>

where Value<i64, FRAC>: ConvertValue<i128, FRAC>, Value<u16, 0>: ConvertValue<i128, FRAC>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<u32> for Fixed<u8, FRAC>

where Value<u8, FRAC>: ConvertValue<i128, FRAC>, Value<u32, 0>: ConvertValue<i128, FRAC>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<u32> for Fixed<u16, FRAC>

where Value<u16, FRAC>: ConvertValue<i128, FRAC>, Value<u32, 0>: ConvertValue<i128, FRAC>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<u32> for Fixed<u32, FRAC>

where Value<u32, FRAC>: ConvertValue<i128, FRAC>, Value<u32, 0>: ConvertValue<i128, FRAC>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<u32> for Fixed<u64, FRAC>

where Value<u64, FRAC>: ConvertValue<i128, FRAC>, Value<u32, 0>: ConvertValue<i128, FRAC>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<u32> for Fixed<i8, FRAC>

where Value<i8, FRAC>: ConvertValue<i128, FRAC>, Value<u32, 0>: ConvertValue<i128, FRAC>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<u32> for Fixed<i16, FRAC>

where Value<i16, FRAC>: ConvertValue<i128, FRAC>, Value<u32, 0>: ConvertValue<i128, FRAC>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<u32> for Fixed<i32, FRAC>

where Value<i32, FRAC>: ConvertValue<i128, FRAC>, Value<u32, 0>: ConvertValue<i128, FRAC>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<u32> for Fixed<i64, FRAC>

where Value<i64, FRAC>: ConvertValue<i128, FRAC>, Value<u32, 0>: ConvertValue<i128, FRAC>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<u64> for Fixed<u8, FRAC>

where Value<u8, FRAC>: ConvertValue<i128, FRAC>, Value<u64, 0>: ConvertValue<i128, FRAC>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<u64> for Fixed<u16, FRAC>

where Value<u16, FRAC>: ConvertValue<i128, FRAC>, Value<u64, 0>: ConvertValue<i128, FRAC>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<u64> for Fixed<u32, FRAC>

where Value<u32, FRAC>: ConvertValue<i128, FRAC>, Value<u64, 0>: ConvertValue<i128, FRAC>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<u64> for Fixed<u64, FRAC>

where Value<u64, FRAC>: ConvertValue<i128, FRAC>, Value<u64, 0>: ConvertValue<i128, FRAC>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<u64> for Fixed<i8, FRAC>

where Value<i8, FRAC>: ConvertValue<i128, FRAC>, Value<u64, 0>: ConvertValue<i128, FRAC>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<u64> for Fixed<i16, FRAC>

where Value<i16, FRAC>: ConvertValue<i128, FRAC>, Value<u64, 0>: ConvertValue<i128, FRAC>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<u64> for Fixed<i32, FRAC>

where Value<i32, FRAC>: ConvertValue<i128, FRAC>, Value<u64, 0>: ConvertValue<i128, FRAC>,

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

Equality operator ==.

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

Inequality operator !=.

impl<const FRAC: usize> PartialEq<u64> for Fixed<i64, FRAC>

where Value<i64, FRAC>: ConvertValue<i128, FRAC>, Value<u64, 0>: ConvertValue<i128, FRAC>,

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

Equality operator ==.

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

Inequality operator !=.

impl<I, const F1: usize, OtherI, const F2: usize> PartialOrd<Fixed<OtherI, F2>> for Fixed<I, F1>

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

fn partial_cmp(&self, other: &Fixed<OtherI, F2>) -> 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<Fixed<i8, FRAC>> for i8

where Value<i8, FRAC>: ConvertValue<i128, FRAC>, Value<i8, 0>: ConvertValue<i128, FRAC>,

fn partial_cmp(&self, other: &Fixed<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<Fixed<i8, FRAC>> for i16

where Value<i8, FRAC>: ConvertValue<i128, FRAC>, Value<i16, 0>: ConvertValue<i128, FRAC>,

fn partial_cmp(&self, other: &Fixed<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<Fixed<i8, FRAC>> for i32

where Value<i8, FRAC>: ConvertValue<i128, FRAC>, Value<i32, 0>: ConvertValue<i128, FRAC>,

fn partial_cmp(&self, other: &Fixed<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<Fixed<i8, FRAC>> for i64

where Value<i8, FRAC>: ConvertValue<i128, FRAC>, Value<i64, 0>: ConvertValue<i128, FRAC>,

fn partial_cmp(&self, other: &Fixed<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<Fixed<i8, FRAC>> for u8

where Value<i8, FRAC>: ConvertValue<i128, FRAC>, Value<u8, 0>: ConvertValue<i128, FRAC>,

fn partial_cmp(&self, other: &Fixed<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<Fixed<i8, FRAC>> for u16

where Value<i8, FRAC>: ConvertValue<i128, FRAC>, Value<u16, 0>: ConvertValue<i128, FRAC>,

fn partial_cmp(&self, other: &Fixed<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<Fixed<i8, FRAC>> for u32

where Value<i8, FRAC>: ConvertValue<i128, FRAC>, Value<u32, 0>: ConvertValue<i128, FRAC>,

fn partial_cmp(&self, other: &Fixed<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<Fixed<i8, FRAC>> for u64

where Value<i8, FRAC>: ConvertValue<i128, FRAC>, Value<u64, 0>: ConvertValue<i128, FRAC>,

fn partial_cmp(&self, other: &Fixed<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<Fixed<i16, FRAC>> for i8

where Value<i16, FRAC>: ConvertValue<i128, FRAC>, Value<i8, 0>: ConvertValue<i128, FRAC>,

fn partial_cmp(&self, other: &Fixed<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<Fixed<i16, FRAC>> for i16

where Value<i16, FRAC>: ConvertValue<i128, FRAC>, Value<i16, 0>: ConvertValue<i128, FRAC>,

fn partial_cmp(&self, other: &Fixed<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<Fixed<i16, FRAC>> for i32

where Value<i16, FRAC>: ConvertValue<i128, FRAC>, Value<i32, 0>: ConvertValue<i128, FRAC>,

fn partial_cmp(&self, other: &Fixed<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<Fixed<i16, FRAC>> for i64

where Value<i16, FRAC>: ConvertValue<i128, FRAC>, Value<i64, 0>: ConvertValue<i128, FRAC>,

fn partial_cmp(&self, other: &Fixed<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<Fixed<i16, FRAC>> for u8

where Value<i16, FRAC>: ConvertValue<i128, FRAC>, Value<u8, 0>: ConvertValue<i128, FRAC>,

fn partial_cmp(&self, other: &Fixed<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<Fixed<i16, FRAC>> for u16

where Value<i16, FRAC>: ConvertValue<i128, FRAC>, Value<u16, 0>: ConvertValue<i128, FRAC>,

fn partial_cmp(&self, other: &Fixed<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<Fixed<i16, FRAC>> for u32

where Value<i16, FRAC>: ConvertValue<i128, FRAC>, Value<u32, 0>: ConvertValue<i128, FRAC>,

fn partial_cmp(&self, other: &Fixed<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<Fixed<i16, FRAC>> for u64

where Value<i16, FRAC>: ConvertValue<i128, FRAC>, Value<u64, 0>: ConvertValue<i128, FRAC>,

fn partial_cmp(&self, other: &Fixed<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<Fixed<i32, FRAC>> for i8

where Value<i32, FRAC>: ConvertValue<i128, FRAC>, Value<i8, 0>: ConvertValue<i128, FRAC>,

fn partial_cmp(&self, other: &Fixed<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<Fixed<i32, FRAC>> for i16

where Value<i32, FRAC>: ConvertValue<i128, FRAC>, Value<i16, 0>: ConvertValue<i128, FRAC>,

fn partial_cmp(&self, other: &Fixed<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<Fixed<i32, FRAC>> for i32

where Value<i32, FRAC>: ConvertValue<i128, FRAC>, Value<i32, 0>: ConvertValue<i128, FRAC>,

fn partial_cmp(&self, other: &Fixed<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<Fixed<i32, FRAC>> for i64

where Value<i32, FRAC>: ConvertValue<i128, FRAC>, Value<i64, 0>: ConvertValue<i128, FRAC>,

fn partial_cmp(&self, other: &Fixed<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<Fixed<i32, FRAC>> for u8

where Value<i32, FRAC>: ConvertValue<i128, FRAC>, Value<u8, 0>: ConvertValue<i128, FRAC>,

fn partial_cmp(&self, other: &Fixed<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<Fixed<i32, FRAC>> for u16

where Value<i32, FRAC>: ConvertValue<i128, FRAC>, Value<u16, 0>: ConvertValue<i128, FRAC>,

fn partial_cmp(&self, other: &Fixed<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<Fixed<i32, FRAC>> for u32

where Value<i32, FRAC>: ConvertValue<i128, FRAC>, Value<u32, 0>: ConvertValue<i128, FRAC>,

fn partial_cmp(&self, other: &Fixed<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<Fixed<i32, FRAC>> for u64

where Value<i32, FRAC>: ConvertValue<i128, FRAC>, Value<u64, 0>: ConvertValue<i128, FRAC>,

fn partial_cmp(&self, other: &Fixed<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<Fixed<i64, FRAC>> for i8

where Value<i64, FRAC>: ConvertValue<i128, FRAC>, Value<i8, 0>: ConvertValue<i128, FRAC>,

fn partial_cmp(&self, other: &Fixed<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<Fixed<i64, FRAC>> for i16

where Value<i64, FRAC>: ConvertValue<i128, FRAC>, Value<i16, 0>: ConvertValue<i128, FRAC>,

fn partial_cmp(&self, other: &Fixed<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<Fixed<i64, FRAC>> for i32

where Value<i64, FRAC>: ConvertValue<i128, FRAC>, Value<i32, 0>: ConvertValue<i128, FRAC>,

fn partial_cmp(&self, other: &Fixed<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<Fixed<i64, FRAC>> for i64

where Value<i64, FRAC>: ConvertValue<i128, FRAC>, Value<i64, 0>: ConvertValue<i128, FRAC>,

fn partial_cmp(&self, other: &Fixed<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<Fixed<i64, FRAC>> for u8

where Value<i64, FRAC>: ConvertValue<i128, FRAC>, Value<u8, 0>: ConvertValue<i128, FRAC>,

fn partial_cmp(&self, other: &Fixed<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<Fixed<i64, FRAC>> for u16

where Value<i64, FRAC>: ConvertValue<i128, FRAC>, Value<u16, 0>: ConvertValue<i128, FRAC>,

fn partial_cmp(&self, other: &Fixed<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<Fixed<i64, FRAC>> for u32

where Value<i64, FRAC>: ConvertValue<i128, FRAC>, Value<u32, 0>: ConvertValue<i128, FRAC>,

fn partial_cmp(&self, other: &Fixed<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<Fixed<i64, FRAC>> for u64

where Value<i64, FRAC>: ConvertValue<i128, FRAC>, Value<u64, 0>: ConvertValue<i128, FRAC>,

fn partial_cmp(&self, other: &Fixed<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<Fixed<u8, FRAC>> for u8

where Value<u8, FRAC>: ConvertValue<i128, FRAC>, Value<u8, 0>: ConvertValue<i128, FRAC>,

fn partial_cmp(&self, other: &Fixed<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<Fixed<u8, FRAC>> for u16

where Value<u8, FRAC>: ConvertValue<i128, FRAC>, Value<u16, 0>: ConvertValue<i128, FRAC>,

fn partial_cmp(&self, other: &Fixed<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<Fixed<u8, FRAC>> for u32

where Value<u8, FRAC>: ConvertValue<i128, FRAC>, Value<u32, 0>: ConvertValue<i128, FRAC>,

fn partial_cmp(&self, other: &Fixed<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<Fixed<u8, FRAC>> for u64

where Value<u8, FRAC>: ConvertValue<i128, FRAC>, Value<u64, 0>: ConvertValue<i128, FRAC>,

fn partial_cmp(&self, other: &Fixed<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<Fixed<u8, FRAC>> for i8

where Value<u8, FRAC>: ConvertValue<i128, FRAC>, Value<i8, 0>: ConvertValue<i128, FRAC>,

fn partial_cmp(&self, other: &Fixed<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<Fixed<u8, FRAC>> for i16

where Value<u8, FRAC>: ConvertValue<i128, FRAC>, Value<i16, 0>: ConvertValue<i128, FRAC>,

fn partial_cmp(&self, other: &Fixed<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<Fixed<u8, FRAC>> for i32

where Value<u8, FRAC>: ConvertValue<i128, FRAC>, Value<i32, 0>: ConvertValue<i128, FRAC>,

fn partial_cmp(&self, other: &Fixed<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<Fixed<u8, FRAC>> for i64

where Value<u8, FRAC>: ConvertValue<i128, FRAC>, Value<i64, 0>: ConvertValue<i128, FRAC>,

fn partial_cmp(&self, other: &Fixed<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<Fixed<u16, FRAC>> for u8

where Value<u16, FRAC>: ConvertValue<i128, FRAC>, Value<u8, 0>: ConvertValue<i128, FRAC>,

fn partial_cmp(&self, other: &Fixed<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<Fixed<u16, FRAC>> for u16

where Value<u16, FRAC>: ConvertValue<i128, FRAC>, Value<u16, 0>: ConvertValue<i128, FRAC>,

fn partial_cmp(&self, other: &Fixed<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<Fixed<u16, FRAC>> for u32

where Value<u16, FRAC>: ConvertValue<i128, FRAC>, Value<u32, 0>: ConvertValue<i128, FRAC>,

fn partial_cmp(&self, other: &Fixed<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<Fixed<u16, FRAC>> for u64

where Value<u16, FRAC>: ConvertValue<i128, FRAC>, Value<u64, 0>: ConvertValue<i128, FRAC>,

fn partial_cmp(&self, other: &Fixed<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<Fixed<u16, FRAC>> for i8

where Value<u16, FRAC>: ConvertValue<i128, FRAC>, Value<i8, 0>: ConvertValue<i128, FRAC>,

fn partial_cmp(&self, other: &Fixed<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<Fixed<u16, FRAC>> for i16

where Value<u16, FRAC>: ConvertValue<i128, FRAC>, Value<i16, 0>: ConvertValue<i128, FRAC>,

fn partial_cmp(&self, other: &Fixed<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<Fixed<u16, FRAC>> for i32

where Value<u16, FRAC>: ConvertValue<i128, FRAC>, Value<i32, 0>: ConvertValue<i128, FRAC>,

fn partial_cmp(&self, other: &Fixed<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<Fixed<u16, FRAC>> for i64

where Value<u16, FRAC>: ConvertValue<i128, FRAC>, Value<i64, 0>: ConvertValue<i128, FRAC>,

fn partial_cmp(&self, other: &Fixed<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<Fixed<u32, FRAC>> for u8

where Value<u32, FRAC>: ConvertValue<i128, FRAC>, Value<u8, 0>: ConvertValue<i128, FRAC>,

fn partial_cmp(&self, other: &Fixed<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<Fixed<u32, FRAC>> for u16

where Value<u32, FRAC>: ConvertValue<i128, FRAC>, Value<u16, 0>: ConvertValue<i128, FRAC>,

fn partial_cmp(&self, other: &Fixed<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<Fixed<u32, FRAC>> for u32

where Value<u32, FRAC>: ConvertValue<i128, FRAC>, Value<u32, 0>: ConvertValue<i128, FRAC>,

fn partial_cmp(&self, other: &Fixed<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<Fixed<u32, FRAC>> for u64

where Value<u32, FRAC>: ConvertValue<i128, FRAC>, Value<u64, 0>: ConvertValue<i128, FRAC>,

fn partial_cmp(&self, other: &Fixed<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<Fixed<u32, FRAC>> for i8

where Value<u32, FRAC>: ConvertValue<i128, FRAC>, Value<i8, 0>: ConvertValue<i128, FRAC>,

fn partial_cmp(&self, other: &Fixed<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<Fixed<u32, FRAC>> for i16

where Value<u32, FRAC>: ConvertValue<i128, FRAC>, Value<i16, 0>: ConvertValue<i128, FRAC>,

fn partial_cmp(&self, other: &Fixed<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<Fixed<u32, FRAC>> for i32

where Value<u32, FRAC>: ConvertValue<i128, FRAC>, Value<i32, 0>: ConvertValue<i128, FRAC>,

fn partial_cmp(&self, other: &Fixed<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<Fixed<u32, FRAC>> for i64

where Value<u32, FRAC>: ConvertValue<i128, FRAC>, Value<i64, 0>: ConvertValue<i128, FRAC>,

fn partial_cmp(&self, other: &Fixed<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<Fixed<u64, FRAC>> for u8

where Value<u64, FRAC>: ConvertValue<i128, FRAC>, Value<u8, 0>: ConvertValue<i128, FRAC>,

fn partial_cmp(&self, other: &Fixed<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<Fixed<u64, FRAC>> for u16

where Value<u64, FRAC>: ConvertValue<i128, FRAC>, Value<u16, 0>: ConvertValue<i128, FRAC>,

fn partial_cmp(&self, other: &Fixed<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<Fixed<u64, FRAC>> for u32

where Value<u64, FRAC>: ConvertValue<i128, FRAC>, Value<u32, 0>: ConvertValue<i128, FRAC>,

fn partial_cmp(&self, other: &Fixed<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<Fixed<u64, FRAC>> for u64

where Value<u64, FRAC>: ConvertValue<i128, FRAC>, Value<u64, 0>: ConvertValue<i128, FRAC>,

fn partial_cmp(&self, other: &Fixed<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<Fixed<u64, FRAC>> for i8

where Value<u64, FRAC>: ConvertValue<i128, FRAC>, Value<i8, 0>: ConvertValue<i128, FRAC>,

fn partial_cmp(&self, other: &Fixed<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<Fixed<u64, FRAC>> for i16

where Value<u64, FRAC>: ConvertValue<i128, FRAC>, Value<i16, 0>: ConvertValue<i128, FRAC>,

fn partial_cmp(&self, other: &Fixed<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<Fixed<u64, FRAC>> for i32

where Value<u64, FRAC>: ConvertValue<i128, FRAC>, Value<i32, 0>: ConvertValue<i128, FRAC>,

fn partial_cmp(&self, other: &Fixed<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<Fixed<u64, FRAC>> for i64

where Value<u64, FRAC>: ConvertValue<i128, FRAC>, Value<i64, 0>: ConvertValue<i128, FRAC>,

fn partial_cmp(&self, other: &Fixed<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 Fixed<i8, FRAC>

where Value<i8, FRAC>: ConvertValue<i128, FRAC>, Value<i8, 0>: ConvertValue<i128, FRAC>,

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 Fixed<i16, FRAC>

where Value<i16, FRAC>: ConvertValue<i128, FRAC>, Value<i8, 0>: ConvertValue<i128, FRAC>,

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 Fixed<i32, FRAC>

where Value<i32, FRAC>: ConvertValue<i128, FRAC>, Value<i8, 0>: ConvertValue<i128, FRAC>,

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 Fixed<i64, FRAC>

where Value<i64, FRAC>: ConvertValue<i128, FRAC>, Value<i8, 0>: ConvertValue<i128, FRAC>,

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 Fixed<u8, FRAC>

where Value<u8, FRAC>: ConvertValue<i128, FRAC>, Value<i8, 0>: ConvertValue<i128, FRAC>,

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 Fixed<u16, FRAC>

where Value<u16, FRAC>: ConvertValue<i128, FRAC>, Value<i8, 0>: ConvertValue<i128, FRAC>,

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 Fixed<u32, FRAC>

where Value<u32, FRAC>: ConvertValue<i128, FRAC>, Value<i8, 0>: ConvertValue<i128, FRAC>,

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 Fixed<u64, FRAC>

where Value<u64, FRAC>: ConvertValue<i128, FRAC>, Value<i8, 0>: ConvertValue<i128, FRAC>,

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 Fixed<i8, FRAC>

where Value<i8, FRAC>: ConvertValue<i128, FRAC>, Value<i16, 0>: ConvertValue<i128, FRAC>,

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 Fixed<i16, FRAC>

where Value<i16, FRAC>: ConvertValue<i128, FRAC>, Value<i16, 0>: ConvertValue<i128, FRAC>,

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 Fixed<i32, FRAC>

where Value<i32, FRAC>: ConvertValue<i128, FRAC>, Value<i16, 0>: ConvertValue<i128, FRAC>,

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 Fixed<i64, FRAC>

where Value<i64, FRAC>: ConvertValue<i128, FRAC>, Value<i16, 0>: ConvertValue<i128, FRAC>,

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 Fixed<u8, FRAC>

where Value<u8, FRAC>: ConvertValue<i128, FRAC>, Value<i16, 0>: ConvertValue<i128, FRAC>,

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 Fixed<u16, FRAC>

where Value<u16, FRAC>: ConvertValue<i128, FRAC>, Value<i16, 0>: ConvertValue<i128, FRAC>,

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 Fixed<u32, FRAC>

where Value<u32, FRAC>: ConvertValue<i128, FRAC>, Value<i16, 0>: ConvertValue<i128, FRAC>,

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 Fixed<u64, FRAC>

where Value<u64, FRAC>: ConvertValue<i128, FRAC>, Value<i16, 0>: ConvertValue<i128, FRAC>,

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 Fixed<i8, FRAC>

where Value<i8, FRAC>: ConvertValue<i128, FRAC>, Value<i32, 0>: ConvertValue<i128, FRAC>,

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 Fixed<i16, FRAC>

where Value<i16, FRAC>: ConvertValue<i128, FRAC>, Value<i32, 0>: ConvertValue<i128, FRAC>,

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 Fixed<i32, FRAC>

where Value<i32, FRAC>: ConvertValue<i128, FRAC>, Value<i32, 0>: ConvertValue<i128, FRAC>,

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 Fixed<i64, FRAC>

where Value<i64, FRAC>: ConvertValue<i128, FRAC>, Value<i32, 0>: ConvertValue<i128, FRAC>,

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 Fixed<u8, FRAC>

where Value<u8, FRAC>: ConvertValue<i128, FRAC>, Value<i32, 0>: ConvertValue<i128, FRAC>,

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 Fixed<u16, FRAC>

where Value<u16, FRAC>: ConvertValue<i128, FRAC>, Value<i32, 0>: ConvertValue<i128, FRAC>,

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 Fixed<u32, FRAC>

where Value<u32, FRAC>: ConvertValue<i128, FRAC>, Value<i32, 0>: ConvertValue<i128, FRAC>,

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 Fixed<u64, FRAC>

where Value<u64, FRAC>: ConvertValue<i128, FRAC>, Value<i32, 0>: ConvertValue<i128, FRAC>,

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 Fixed<i8, FRAC>

where Value<i8, FRAC>: ConvertValue<i128, FRAC>, Value<i64, 0>: ConvertValue<i128, FRAC>,

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 Fixed<i16, FRAC>

where Value<i16, FRAC>: ConvertValue<i128, FRAC>, Value<i64, 0>: ConvertValue<i128, FRAC>,

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 Fixed<i32, FRAC>

where Value<i32, FRAC>: ConvertValue<i128, FRAC>, Value<i64, 0>: ConvertValue<i128, FRAC>,

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 Fixed<i64, FRAC>

where Value<i64, FRAC>: ConvertValue<i128, FRAC>, Value<i64, 0>: ConvertValue<i128, FRAC>,

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 Fixed<u8, FRAC>

where Value<u8, FRAC>: ConvertValue<i128, FRAC>, Value<i64, 0>: ConvertValue<i128, FRAC>,

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 Fixed<u16, FRAC>

where Value<u16, FRAC>: ConvertValue<i128, FRAC>, Value<i64, 0>: ConvertValue<i128, FRAC>,

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 Fixed<u32, FRAC>

where Value<u32, FRAC>: ConvertValue<i128, FRAC>, Value<i64, 0>: ConvertValue<i128, FRAC>,

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 Fixed<u64, FRAC>

where Value<u64, FRAC>: ConvertValue<i128, FRAC>, Value<i64, 0>: ConvertValue<i128, FRAC>,

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 Fixed<u8, FRAC>

where Value<u8, FRAC>: ConvertValue<i128, FRAC>, Value<u8, 0>: ConvertValue<i128, FRAC>,

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 Fixed<u16, FRAC>

where Value<u16, FRAC>: ConvertValue<i128, FRAC>, Value<u8, 0>: ConvertValue<i128, FRAC>,

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 Fixed<u32, FRAC>

where Value<u32, FRAC>: ConvertValue<i128, FRAC>, Value<u8, 0>: ConvertValue<i128, FRAC>,

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 Fixed<u64, FRAC>

where Value<u64, FRAC>: ConvertValue<i128, FRAC>, Value<u8, 0>: ConvertValue<i128, FRAC>,

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 Fixed<i8, FRAC>

where Value<i8, FRAC>: ConvertValue<i128, FRAC>, Value<u8, 0>: ConvertValue<i128, FRAC>,

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 Fixed<i16, FRAC>

where Value<i16, FRAC>: ConvertValue<i128, FRAC>, Value<u8, 0>: ConvertValue<i128, FRAC>,

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 Fixed<i32, FRAC>

where Value<i32, FRAC>: ConvertValue<i128, FRAC>, Value<u8, 0>: ConvertValue<i128, FRAC>,

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 Fixed<i64, FRAC>

where Value<i64, FRAC>: ConvertValue<i128, FRAC>, Value<u8, 0>: ConvertValue<i128, FRAC>,

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 Fixed<u8, FRAC>

where Value<u8, FRAC>: ConvertValue<i128, FRAC>, Value<u16, 0>: ConvertValue<i128, FRAC>,

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 Fixed<u16, FRAC>

where Value<u16, FRAC>: ConvertValue<i128, FRAC>, Value<u16, 0>: ConvertValue<i128, FRAC>,

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 Fixed<u32, FRAC>

where Value<u32, FRAC>: ConvertValue<i128, FRAC>, Value<u16, 0>: ConvertValue<i128, FRAC>,

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 Fixed<u64, FRAC>

where Value<u64, FRAC>: ConvertValue<i128, FRAC>, Value<u16, 0>: ConvertValue<i128, FRAC>,

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 Fixed<i8, FRAC>

where Value<i8, FRAC>: ConvertValue<i128, FRAC>, Value<u16, 0>: ConvertValue<i128, FRAC>,

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 Fixed<i16, FRAC>

where Value<i16, FRAC>: ConvertValue<i128, FRAC>, Value<u16, 0>: ConvertValue<i128, FRAC>,

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 Fixed<i32, FRAC>

where Value<i32, FRAC>: ConvertValue<i128, FRAC>, Value<u16, 0>: ConvertValue<i128, FRAC>,

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 Fixed<i64, FRAC>

where Value<i64, FRAC>: ConvertValue<i128, FRAC>, Value<u16, 0>: ConvertValue<i128, FRAC>,

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 Fixed<u8, FRAC>

where Value<u8, FRAC>: ConvertValue<i128, FRAC>, Value<u32, 0>: ConvertValue<i128, FRAC>,

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 Fixed<u16, FRAC>

where Value<u16, FRAC>: ConvertValue<i128, FRAC>, Value<u32, 0>: ConvertValue<i128, FRAC>,

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 Fixed<u32, FRAC>

where Value<u32, FRAC>: ConvertValue<i128, FRAC>, Value<u32, 0>: ConvertValue<i128, FRAC>,

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 Fixed<u64, FRAC>

where Value<u64, FRAC>: ConvertValue<i128, FRAC>, Value<u32, 0>: ConvertValue<i128, FRAC>,

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 Fixed<i8, FRAC>

where Value<i8, FRAC>: ConvertValue<i128, FRAC>, Value<u32, 0>: ConvertValue<i128, FRAC>,

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 Fixed<i16, FRAC>

where Value<i16, FRAC>: ConvertValue<i128, FRAC>, Value<u32, 0>: ConvertValue<i128, FRAC>,

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 Fixed<i32, FRAC>

where Value<i32, FRAC>: ConvertValue<i128, FRAC>, Value<u32, 0>: ConvertValue<i128, FRAC>,

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 Fixed<i64, FRAC>

where Value<i64, FRAC>: ConvertValue<i128, FRAC>, Value<u32, 0>: ConvertValue<i128, FRAC>,

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 Fixed<u8, FRAC>

where Value<u8, FRAC>: ConvertValue<i128, FRAC>, Value<u64, 0>: ConvertValue<i128, FRAC>,

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 Fixed<u16, FRAC>

where Value<u16, FRAC>: ConvertValue<i128, FRAC>, Value<u64, 0>: ConvertValue<i128, FRAC>,

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 Fixed<u32, FRAC>

where Value<u32, FRAC>: ConvertValue<i128, FRAC>, Value<u64, 0>: ConvertValue<i128, FRAC>,

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 Fixed<u64, FRAC>

where Value<u64, FRAC>: ConvertValue<i128, FRAC>, Value<u64, 0>: ConvertValue<i128, FRAC>,

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 Fixed<i8, FRAC>

where Value<i8, FRAC>: ConvertValue<i128, FRAC>, Value<u64, 0>: ConvertValue<i128, FRAC>,

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 Fixed<i16, FRAC>

where Value<i16, FRAC>: ConvertValue<i128, FRAC>, Value<u64, 0>: ConvertValue<i128, FRAC>,

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 Fixed<i32, FRAC>

where Value<i32, FRAC>: ConvertValue<i128, FRAC>, Value<u64, 0>: ConvertValue<i128, FRAC>,

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 Fixed<i64, FRAC>

where Value<i64, FRAC>: ConvertValue<i128, FRAC>, Value<u64, 0>: ConvertValue<i128, FRAC>,

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<T, const FRAC: usize, U, const FRAC_R: usize> Sub<Fixed<U, FRAC_R>> for Fixed<T, FRAC>

where T: PromoteAddSub<U> + Copy, U: Copy, T::Output: Bounded + NumCast + Copy, Value<T, FRAC>: ConvertValue<i128, FRAC>, Value<U, FRAC_R>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the - operator.

fn sub(self, rhs: Fixed<U, FRAC_R>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<Fixed<i8, FRAC>> for i8

where i8: PromoteAddSub<i8> + Copy, <i8 as PromoteAddSub<i8>>::Output: Bounded + NumCast + Copy, Value<i8, FRAC>: ConvertValue<i128, FRAC>, Value<i8, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the - operator.

fn sub(self, rhs: Fixed<i8, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<Fixed<i8, FRAC>> for i16

where i8: PromoteAddSub<i16> + Copy, i16: Copy, <i8 as PromoteAddSub<i16>>::Output: Bounded + NumCast + Copy, Value<i8, FRAC>: ConvertValue<i128, FRAC>, Value<i16, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the - operator.

fn sub(self, rhs: Fixed<i8, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<Fixed<i8, FRAC>> for i32

where i8: PromoteAddSub<i32> + Copy, i32: Copy, <i8 as PromoteAddSub<i32>>::Output: Bounded + NumCast + Copy, Value<i8, FRAC>: ConvertValue<i128, FRAC>, Value<i32, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the - operator.

fn sub(self, rhs: Fixed<i8, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<Fixed<i8, FRAC>> for i64

where i8: PromoteAddSub<i64> + Copy, i64: Copy, <i8 as PromoteAddSub<i64>>::Output: Bounded + NumCast + Copy, Value<i8, FRAC>: ConvertValue<i128, FRAC>, Value<i64, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the - operator.

fn sub(self, rhs: Fixed<i8, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<Fixed<i8, FRAC>> for u8

where i8: PromoteAddSub<u8> + Copy, u8: Copy, <i8 as PromoteAddSub<u8>>::Output: Bounded + NumCast + Copy, Value<i8, FRAC>: ConvertValue<i128, FRAC>, Value<u8, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the - operator.

fn sub(self, rhs: Fixed<i8, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<Fixed<i8, FRAC>> for u16

where i8: PromoteAddSub<u16> + Copy, u16: Copy, <i8 as PromoteAddSub<u16>>::Output: Bounded + NumCast + Copy, Value<i8, FRAC>: ConvertValue<i128, FRAC>, Value<u16, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the - operator.

fn sub(self, rhs: Fixed<i8, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<Fixed<i8, FRAC>> for u32

where i8: PromoteAddSub<u32> + Copy, u32: Copy, <i8 as PromoteAddSub<u32>>::Output: Bounded + NumCast + Copy, Value<i8, FRAC>: ConvertValue<i128, FRAC>, Value<u32, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the - operator.

fn sub(self, rhs: Fixed<i8, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<Fixed<i8, FRAC>> for u64

where i8: PromoteAddSub<u64> + Copy, u64: Copy, <i8 as PromoteAddSub<u64>>::Output: Bounded + NumCast + Copy, Value<i8, FRAC>: ConvertValue<i128, FRAC>, Value<u64, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the - operator.

fn sub(self, rhs: Fixed<i8, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<Fixed<i16, FRAC>> for i8

where i16: PromoteAddSub<i8> + Copy, i8: Copy, <i16 as PromoteAddSub<i8>>::Output: Bounded + NumCast + Copy, Value<i16, FRAC>: ConvertValue<i128, FRAC>, Value<i8, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the - operator.

fn sub(self, rhs: Fixed<i16, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<Fixed<i16, FRAC>> for i16

where i16: PromoteAddSub<i16> + Copy, <i16 as PromoteAddSub<i16>>::Output: Bounded + NumCast + Copy, Value<i16, FRAC>: ConvertValue<i128, FRAC>, Value<i16, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the - operator.

fn sub(self, rhs: Fixed<i16, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<Fixed<i16, FRAC>> for i32

where i16: PromoteAddSub<i32> + Copy, i32: Copy, <i16 as PromoteAddSub<i32>>::Output: Bounded + NumCast + Copy, Value<i16, FRAC>: ConvertValue<i128, FRAC>, Value<i32, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the - operator.

fn sub(self, rhs: Fixed<i16, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<Fixed<i16, FRAC>> for i64

where i16: PromoteAddSub<i64> + Copy, i64: Copy, <i16 as PromoteAddSub<i64>>::Output: Bounded + NumCast + Copy, Value<i16, FRAC>: ConvertValue<i128, FRAC>, Value<i64, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the - operator.

fn sub(self, rhs: Fixed<i16, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<Fixed<i16, FRAC>> for u8

where i16: PromoteAddSub<u8> + Copy, u8: Copy, <i16 as PromoteAddSub<u8>>::Output: Bounded + NumCast + Copy, Value<i16, FRAC>: ConvertValue<i128, FRAC>, Value<u8, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the - operator.

fn sub(self, rhs: Fixed<i16, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<Fixed<i16, FRAC>> for u16

where i16: PromoteAddSub<u16> + Copy, u16: Copy, <i16 as PromoteAddSub<u16>>::Output: Bounded + NumCast + Copy, Value<i16, FRAC>: ConvertValue<i128, FRAC>, Value<u16, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the - operator.

fn sub(self, rhs: Fixed<i16, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<Fixed<i16, FRAC>> for u32

where i16: PromoteAddSub<u32> + Copy, u32: Copy, <i16 as PromoteAddSub<u32>>::Output: Bounded + NumCast + Copy, Value<i16, FRAC>: ConvertValue<i128, FRAC>, Value<u32, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the - operator.

fn sub(self, rhs: Fixed<i16, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<Fixed<i16, FRAC>> for u64

where i16: PromoteAddSub<u64> + Copy, u64: Copy, <i16 as PromoteAddSub<u64>>::Output: Bounded + NumCast + Copy, Value<i16, FRAC>: ConvertValue<i128, FRAC>, Value<u64, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the - operator.

fn sub(self, rhs: Fixed<i16, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<Fixed<i32, FRAC>> for i8

where i32: PromoteAddSub<i8> + Copy, i8: Copy, <i32 as PromoteAddSub<i8>>::Output: Bounded + NumCast + Copy, Value<i32, FRAC>: ConvertValue<i128, FRAC>, Value<i8, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the - operator.

fn sub(self, rhs: Fixed<i32, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<Fixed<i32, FRAC>> for i16

where i32: PromoteAddSub<i16> + Copy, i16: Copy, <i32 as PromoteAddSub<i16>>::Output: Bounded + NumCast + Copy, Value<i32, FRAC>: ConvertValue<i128, FRAC>, Value<i16, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the - operator.

fn sub(self, rhs: Fixed<i32, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<Fixed<i32, FRAC>> for i32

where i32: PromoteAddSub<i32> + Copy, <i32 as PromoteAddSub<i32>>::Output: Bounded + NumCast + Copy, Value<i32, FRAC>: ConvertValue<i128, FRAC>, Value<i32, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the - operator.

fn sub(self, rhs: Fixed<i32, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<Fixed<i32, FRAC>> for i64

where i32: PromoteAddSub<i64> + Copy, i64: Copy, <i32 as PromoteAddSub<i64>>::Output: Bounded + NumCast + Copy, Value<i32, FRAC>: ConvertValue<i128, FRAC>, Value<i64, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the - operator.

fn sub(self, rhs: Fixed<i32, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<Fixed<i32, FRAC>> for u8

where i32: PromoteAddSub<u8> + Copy, u8: Copy, <i32 as PromoteAddSub<u8>>::Output: Bounded + NumCast + Copy, Value<i32, FRAC>: ConvertValue<i128, FRAC>, Value<u8, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the - operator.

fn sub(self, rhs: Fixed<i32, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<Fixed<i32, FRAC>> for u16

where i32: PromoteAddSub<u16> + Copy, u16: Copy, <i32 as PromoteAddSub<u16>>::Output: Bounded + NumCast + Copy, Value<i32, FRAC>: ConvertValue<i128, FRAC>, Value<u16, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the - operator.

fn sub(self, rhs: Fixed<i32, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<Fixed<i32, FRAC>> for u32

where i32: PromoteAddSub<u32> + Copy, u32: Copy, <i32 as PromoteAddSub<u32>>::Output: Bounded + NumCast + Copy, Value<i32, FRAC>: ConvertValue<i128, FRAC>, Value<u32, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the - operator.

fn sub(self, rhs: Fixed<i32, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<Fixed<i32, FRAC>> for u64

where i32: PromoteAddSub<u64> + Copy, u64: Copy, <i32 as PromoteAddSub<u64>>::Output: Bounded + NumCast + Copy, Value<i32, FRAC>: ConvertValue<i128, FRAC>, Value<u64, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the - operator.

fn sub(self, rhs: Fixed<i32, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<Fixed<i64, FRAC>> for i8

where i64: PromoteAddSub<i8> + Copy, i8: Copy, <i64 as PromoteAddSub<i8>>::Output: Bounded + NumCast + Copy, Value<i64, FRAC>: ConvertValue<i128, FRAC>, Value<i8, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the - operator.

fn sub(self, rhs: Fixed<i64, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<Fixed<i64, FRAC>> for i16

where i64: PromoteAddSub<i16> + Copy, i16: Copy, <i64 as PromoteAddSub<i16>>::Output: Bounded + NumCast + Copy, Value<i64, FRAC>: ConvertValue<i128, FRAC>, Value<i16, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the - operator.

fn sub(self, rhs: Fixed<i64, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<Fixed<i64, FRAC>> for i32

where i64: PromoteAddSub<i32> + Copy, i32: Copy, <i64 as PromoteAddSub<i32>>::Output: Bounded + NumCast + Copy, Value<i64, FRAC>: ConvertValue<i128, FRAC>, Value<i32, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the - operator.

fn sub(self, rhs: Fixed<i64, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<Fixed<i64, FRAC>> for i64

where i64: PromoteAddSub<i64> + Copy, <i64 as PromoteAddSub<i64>>::Output: Bounded + NumCast + Copy, Value<i64, FRAC>: ConvertValue<i128, FRAC>, Value<i64, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the - operator.

fn sub(self, rhs: Fixed<i64, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<Fixed<i64, FRAC>> for u8

where i64: PromoteAddSub<u8> + Copy, u8: Copy, <i64 as PromoteAddSub<u8>>::Output: Bounded + NumCast + Copy, Value<i64, FRAC>: ConvertValue<i128, FRAC>, Value<u8, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the - operator.

fn sub(self, rhs: Fixed<i64, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<Fixed<i64, FRAC>> for u16

where i64: PromoteAddSub<u16> + Copy, u16: Copy, <i64 as PromoteAddSub<u16>>::Output: Bounded + NumCast + Copy, Value<i64, FRAC>: ConvertValue<i128, FRAC>, Value<u16, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the - operator.

fn sub(self, rhs: Fixed<i64, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<Fixed<i64, FRAC>> for u32

where i64: PromoteAddSub<u32> + Copy, u32: Copy, <i64 as PromoteAddSub<u32>>::Output: Bounded + NumCast + Copy, Value<i64, FRAC>: ConvertValue<i128, FRAC>, Value<u32, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the - operator.

fn sub(self, rhs: Fixed<i64, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<Fixed<i64, FRAC>> for u64

where i64: PromoteAddSub<u64> + Copy, u64: Copy, <i64 as PromoteAddSub<u64>>::Output: Bounded + NumCast + Copy, Value<i64, FRAC>: ConvertValue<i128, FRAC>, Value<u64, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the - operator.

fn sub(self, rhs: Fixed<i64, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<Fixed<u8, FRAC>> for u8

where u8: PromoteAddSub<u8> + Copy, <u8 as PromoteAddSub<u8>>::Output: Bounded + NumCast + Copy, Value<u8, FRAC>: ConvertValue<i128, FRAC>, Value<u8, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the - operator.

fn sub(self, rhs: Fixed<u8, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<Fixed<u8, FRAC>> for u16

where u8: PromoteAddSub<u16> + Copy, u16: Copy, <u8 as PromoteAddSub<u16>>::Output: Bounded + NumCast + Copy, Value<u8, FRAC>: ConvertValue<i128, FRAC>, Value<u16, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the - operator.

fn sub(self, rhs: Fixed<u8, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<Fixed<u8, FRAC>> for u32

where u8: PromoteAddSub<u32> + Copy, u32: Copy, <u8 as PromoteAddSub<u32>>::Output: Bounded + NumCast + Copy, Value<u8, FRAC>: ConvertValue<i128, FRAC>, Value<u32, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the - operator.

fn sub(self, rhs: Fixed<u8, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<Fixed<u8, FRAC>> for u64

where u8: PromoteAddSub<u64> + Copy, u64: Copy, <u8 as PromoteAddSub<u64>>::Output: Bounded + NumCast + Copy, Value<u8, FRAC>: ConvertValue<i128, FRAC>, Value<u64, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the - operator.

fn sub(self, rhs: Fixed<u8, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<Fixed<u8, FRAC>> for i8

where u8: PromoteAddSub<i8> + Copy, i8: Copy, <u8 as PromoteAddSub<i8>>::Output: Bounded + NumCast + Copy, Value<u8, FRAC>: ConvertValue<i128, FRAC>, Value<i8, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the - operator.

fn sub(self, rhs: Fixed<u8, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<Fixed<u8, FRAC>> for i16

where u8: PromoteAddSub<i16> + Copy, i16: Copy, <u8 as PromoteAddSub<i16>>::Output: Bounded + NumCast + Copy, Value<u8, FRAC>: ConvertValue<i128, FRAC>, Value<i16, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the - operator.

fn sub(self, rhs: Fixed<u8, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<Fixed<u8, FRAC>> for i32

where u8: PromoteAddSub<i32> + Copy, i32: Copy, <u8 as PromoteAddSub<i32>>::Output: Bounded + NumCast + Copy, Value<u8, FRAC>: ConvertValue<i128, FRAC>, Value<i32, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the - operator.

fn sub(self, rhs: Fixed<u8, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<Fixed<u8, FRAC>> for i64

where u8: PromoteAddSub<i64> + Copy, i64: Copy, <u8 as PromoteAddSub<i64>>::Output: Bounded + NumCast + Copy, Value<u8, FRAC>: ConvertValue<i128, FRAC>, Value<i64, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the - operator.

fn sub(self, rhs: Fixed<u8, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<Fixed<u16, FRAC>> for u8

where u16: PromoteAddSub<u8> + Copy, u8: Copy, <u16 as PromoteAddSub<u8>>::Output: Bounded + NumCast + Copy, Value<u16, FRAC>: ConvertValue<i128, FRAC>, Value<u8, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the - operator.

fn sub(self, rhs: Fixed<u16, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<Fixed<u16, FRAC>> for u16

where u16: PromoteAddSub<u16> + Copy, <u16 as PromoteAddSub<u16>>::Output: Bounded + NumCast + Copy, Value<u16, FRAC>: ConvertValue<i128, FRAC>, Value<u16, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the - operator.

fn sub(self, rhs: Fixed<u16, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<Fixed<u16, FRAC>> for u32

where u16: PromoteAddSub<u32> + Copy, u32: Copy, <u16 as PromoteAddSub<u32>>::Output: Bounded + NumCast + Copy, Value<u16, FRAC>: ConvertValue<i128, FRAC>, Value<u32, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the - operator.

fn sub(self, rhs: Fixed<u16, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<Fixed<u16, FRAC>> for u64

where u16: PromoteAddSub<u64> + Copy, u64: Copy, <u16 as PromoteAddSub<u64>>::Output: Bounded + NumCast + Copy, Value<u16, FRAC>: ConvertValue<i128, FRAC>, Value<u64, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the - operator.

fn sub(self, rhs: Fixed<u16, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<Fixed<u16, FRAC>> for i8

where u16: PromoteAddSub<i8> + Copy, i8: Copy, <u16 as PromoteAddSub<i8>>::Output: Bounded + NumCast + Copy, Value<u16, FRAC>: ConvertValue<i128, FRAC>, Value<i8, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the - operator.

fn sub(self, rhs: Fixed<u16, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<Fixed<u16, FRAC>> for i16

where u16: PromoteAddSub<i16> + Copy, i16: Copy, <u16 as PromoteAddSub<i16>>::Output: Bounded + NumCast + Copy, Value<u16, FRAC>: ConvertValue<i128, FRAC>, Value<i16, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the - operator.

fn sub(self, rhs: Fixed<u16, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<Fixed<u16, FRAC>> for i32

where u16: PromoteAddSub<i32> + Copy, i32: Copy, <u16 as PromoteAddSub<i32>>::Output: Bounded + NumCast + Copy, Value<u16, FRAC>: ConvertValue<i128, FRAC>, Value<i32, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the - operator.

fn sub(self, rhs: Fixed<u16, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<Fixed<u16, FRAC>> for i64

where u16: PromoteAddSub<i64> + Copy, i64: Copy, <u16 as PromoteAddSub<i64>>::Output: Bounded + NumCast + Copy, Value<u16, FRAC>: ConvertValue<i128, FRAC>, Value<i64, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the - operator.

fn sub(self, rhs: Fixed<u16, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<Fixed<u32, FRAC>> for u8

where u32: PromoteAddSub<u8> + Copy, u8: Copy, <u32 as PromoteAddSub<u8>>::Output: Bounded + NumCast + Copy, Value<u32, FRAC>: ConvertValue<i128, FRAC>, Value<u8, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the - operator.

fn sub(self, rhs: Fixed<u32, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<Fixed<u32, FRAC>> for u16

where u32: PromoteAddSub<u16> + Copy, u16: Copy, <u32 as PromoteAddSub<u16>>::Output: Bounded + NumCast + Copy, Value<u32, FRAC>: ConvertValue<i128, FRAC>, Value<u16, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the - operator.

fn sub(self, rhs: Fixed<u32, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<Fixed<u32, FRAC>> for u32

where u32: PromoteAddSub<u32> + Copy, <u32 as PromoteAddSub<u32>>::Output: Bounded + NumCast + Copy, Value<u32, FRAC>: ConvertValue<i128, FRAC>, Value<u32, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the - operator.

fn sub(self, rhs: Fixed<u32, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<Fixed<u32, FRAC>> for u64

where u32: PromoteAddSub<u64> + Copy, u64: Copy, <u32 as PromoteAddSub<u64>>::Output: Bounded + NumCast + Copy, Value<u32, FRAC>: ConvertValue<i128, FRAC>, Value<u64, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the - operator.

fn sub(self, rhs: Fixed<u32, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<Fixed<u32, FRAC>> for i8

where u32: PromoteAddSub<i8> + Copy, i8: Copy, <u32 as PromoteAddSub<i8>>::Output: Bounded + NumCast + Copy, Value<u32, FRAC>: ConvertValue<i128, FRAC>, Value<i8, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the - operator.

fn sub(self, rhs: Fixed<u32, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<Fixed<u32, FRAC>> for i16

where u32: PromoteAddSub<i16> + Copy, i16: Copy, <u32 as PromoteAddSub<i16>>::Output: Bounded + NumCast + Copy, Value<u32, FRAC>: ConvertValue<i128, FRAC>, Value<i16, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the - operator.

fn sub(self, rhs: Fixed<u32, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<Fixed<u32, FRAC>> for i32

where u32: PromoteAddSub<i32> + Copy, i32: Copy, <u32 as PromoteAddSub<i32>>::Output: Bounded + NumCast + Copy, Value<u32, FRAC>: ConvertValue<i128, FRAC>, Value<i32, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the - operator.

fn sub(self, rhs: Fixed<u32, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<Fixed<u32, FRAC>> for i64

where u32: PromoteAddSub<i64> + Copy, i64: Copy, <u32 as PromoteAddSub<i64>>::Output: Bounded + NumCast + Copy, Value<u32, FRAC>: ConvertValue<i128, FRAC>, Value<i64, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the - operator.

fn sub(self, rhs: Fixed<u32, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<Fixed<u64, FRAC>> for u8

where u64: PromoteAddSub<u8> + Copy, u8: Copy, <u64 as PromoteAddSub<u8>>::Output: Bounded + NumCast + Copy, Value<u64, FRAC>: ConvertValue<i128, FRAC>, Value<u8, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the - operator.

fn sub(self, rhs: Fixed<u64, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<Fixed<u64, FRAC>> for u16

where u64: PromoteAddSub<u16> + Copy, u16: Copy, <u64 as PromoteAddSub<u16>>::Output: Bounded + NumCast + Copy, Value<u64, FRAC>: ConvertValue<i128, FRAC>, Value<u16, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the - operator.

fn sub(self, rhs: Fixed<u64, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<Fixed<u64, FRAC>> for u32

where u64: PromoteAddSub<u32> + Copy, u32: Copy, <u64 as PromoteAddSub<u32>>::Output: Bounded + NumCast + Copy, Value<u64, FRAC>: ConvertValue<i128, FRAC>, Value<u32, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the - operator.

fn sub(self, rhs: Fixed<u64, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<Fixed<u64, FRAC>> for u64

where u64: PromoteAddSub<u64> + Copy, <u64 as PromoteAddSub<u64>>::Output: Bounded + NumCast + Copy, Value<u64, FRAC>: ConvertValue<i128, FRAC>, Value<u64, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the - operator.

fn sub(self, rhs: Fixed<u64, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<Fixed<u64, FRAC>> for i8

where u64: PromoteAddSub<i8> + Copy, i8: Copy, <u64 as PromoteAddSub<i8>>::Output: Bounded + NumCast + Copy, Value<u64, FRAC>: ConvertValue<i128, FRAC>, Value<i8, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the - operator.

fn sub(self, rhs: Fixed<u64, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<Fixed<u64, FRAC>> for i16

where u64: PromoteAddSub<i16> + Copy, i16: Copy, <u64 as PromoteAddSub<i16>>::Output: Bounded + NumCast + Copy, Value<u64, FRAC>: ConvertValue<i128, FRAC>, Value<i16, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the - operator.

fn sub(self, rhs: Fixed<u64, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<Fixed<u64, FRAC>> for i32

where u64: PromoteAddSub<i32> + Copy, i32: Copy, <u64 as PromoteAddSub<i32>>::Output: Bounded + NumCast + Copy, Value<u64, FRAC>: ConvertValue<i128, FRAC>, Value<i32, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the - operator.

fn sub(self, rhs: Fixed<u64, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<Fixed<u64, FRAC>> for i64

where u64: PromoteAddSub<i64> + Copy, i64: Copy, <u64 as PromoteAddSub<i64>>::Output: Bounded + NumCast + Copy, Value<u64, FRAC>: ConvertValue<i128, FRAC>, Value<i64, 0>: ConvertValue<i128, FRAC>,

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

The resulting type after applying the - operator.

fn sub(self, rhs: Fixed<u64, FRAC>) -> Self::Output

Performs the - operation.

impl<const FRAC: usize> Sub<i8> for Fixed<i8, FRAC>

where i8: PromoteAddSub<i8> + Copy, <i8 as PromoteAddSub<i8>>::Output: Bounded + NumCast + Copy, Value<i8, FRAC>: ConvertValue<i128, FRAC>, Value<i8, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<i16, FRAC>

where i16: PromoteAddSub<i8> + Copy, i8: Copy, <i16 as PromoteAddSub<i8>>::Output: Bounded + NumCast + Copy, Value<i16, FRAC>: ConvertValue<i128, FRAC>, Value<i8, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<i32, FRAC>

where i32: PromoteAddSub<i8> + Copy, i8: Copy, <i32 as PromoteAddSub<i8>>::Output: Bounded + NumCast + Copy, Value<i32, FRAC>: ConvertValue<i128, FRAC>, Value<i8, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<i64, FRAC>

where i64: PromoteAddSub<i8> + Copy, i8: Copy, <i64 as PromoteAddSub<i8>>::Output: Bounded + NumCast + Copy, Value<i64, FRAC>: ConvertValue<i128, FRAC>, Value<i8, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u8, FRAC>

where u8: PromoteAddSub<i8> + Copy, i8: Copy, <u8 as PromoteAddSub<i8>>::Output: Bounded + NumCast + Copy, Value<u8, FRAC>: ConvertValue<i128, FRAC>, Value<i8, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u16, FRAC>

where u16: PromoteAddSub<i8> + Copy, i8: Copy, <u16 as PromoteAddSub<i8>>::Output: Bounded + NumCast + Copy, Value<u16, FRAC>: ConvertValue<i128, FRAC>, Value<i8, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u32, FRAC>

where u32: PromoteAddSub<i8> + Copy, i8: Copy, <u32 as PromoteAddSub<i8>>::Output: Bounded + NumCast + Copy, Value<u32, FRAC>: ConvertValue<i128, FRAC>, Value<i8, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u64, FRAC>

where u64: PromoteAddSub<i8> + Copy, i8: Copy, <u64 as PromoteAddSub<i8>>::Output: Bounded + NumCast + Copy, Value<u64, FRAC>: ConvertValue<i128, FRAC>, Value<i8, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<i8, FRAC>

where i8: PromoteAddSub<i16> + Copy, i16: Copy, <i8 as PromoteAddSub<i16>>::Output: Bounded + NumCast + Copy, Value<i8, FRAC>: ConvertValue<i128, FRAC>, Value<i16, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<i16, FRAC>

where i16: PromoteAddSub<i16> + Copy, <i16 as PromoteAddSub<i16>>::Output: Bounded + NumCast + Copy, Value<i16, FRAC>: ConvertValue<i128, FRAC>, Value<i16, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<i32, FRAC>

where i32: PromoteAddSub<i16> + Copy, i16: Copy, <i32 as PromoteAddSub<i16>>::Output: Bounded + NumCast + Copy, Value<i32, FRAC>: ConvertValue<i128, FRAC>, Value<i16, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<i64, FRAC>

where i64: PromoteAddSub<i16> + Copy, i16: Copy, <i64 as PromoteAddSub<i16>>::Output: Bounded + NumCast + Copy, Value<i64, FRAC>: ConvertValue<i128, FRAC>, Value<i16, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u8, FRAC>

where u8: PromoteAddSub<i16> + Copy, i16: Copy, <u8 as PromoteAddSub<i16>>::Output: Bounded + NumCast + Copy, Value<u8, FRAC>: ConvertValue<i128, FRAC>, Value<i16, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u16, FRAC>

where u16: PromoteAddSub<i16> + Copy, i16: Copy, <u16 as PromoteAddSub<i16>>::Output: Bounded + NumCast + Copy, Value<u16, FRAC>: ConvertValue<i128, FRAC>, Value<i16, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u32, FRAC>

where u32: PromoteAddSub<i16> + Copy, i16: Copy, <u32 as PromoteAddSub<i16>>::Output: Bounded + NumCast + Copy, Value<u32, FRAC>: ConvertValue<i128, FRAC>, Value<i16, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u64, FRAC>

where u64: PromoteAddSub<i16> + Copy, i16: Copy, <u64 as PromoteAddSub<i16>>::Output: Bounded + NumCast + Copy, Value<u64, FRAC>: ConvertValue<i128, FRAC>, Value<i16, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<i8, FRAC>

where i8: PromoteAddSub<i32> + Copy, i32: Copy, <i8 as PromoteAddSub<i32>>::Output: Bounded + NumCast + Copy, Value<i8, FRAC>: ConvertValue<i128, FRAC>, Value<i32, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<i16, FRAC>

where i16: PromoteAddSub<i32> + Copy, i32: Copy, <i16 as PromoteAddSub<i32>>::Output: Bounded + NumCast + Copy, Value<i16, FRAC>: ConvertValue<i128, FRAC>, Value<i32, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<i32, FRAC>

where i32: PromoteAddSub<i32> + Copy, <i32 as PromoteAddSub<i32>>::Output: Bounded + NumCast + Copy, Value<i32, FRAC>: ConvertValue<i128, FRAC>, Value<i32, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<i64, FRAC>

where i64: PromoteAddSub<i32> + Copy, i32: Copy, <i64 as PromoteAddSub<i32>>::Output: Bounded + NumCast + Copy, Value<i64, FRAC>: ConvertValue<i128, FRAC>, Value<i32, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u8, FRAC>

where u8: PromoteAddSub<i32> + Copy, i32: Copy, <u8 as PromoteAddSub<i32>>::Output: Bounded + NumCast + Copy, Value<u8, FRAC>: ConvertValue<i128, FRAC>, Value<i32, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u16, FRAC>

where u16: PromoteAddSub<i32> + Copy, i32: Copy, <u16 as PromoteAddSub<i32>>::Output: Bounded + NumCast + Copy, Value<u16, FRAC>: ConvertValue<i128, FRAC>, Value<i32, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u32, FRAC>

where u32: PromoteAddSub<i32> + Copy, i32: Copy, <u32 as PromoteAddSub<i32>>::Output: Bounded + NumCast + Copy, Value<u32, FRAC>: ConvertValue<i128, FRAC>, Value<i32, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u64, FRAC>

where u64: PromoteAddSub<i32> + Copy, i32: Copy, <u64 as PromoteAddSub<i32>>::Output: Bounded + NumCast + Copy, Value<u64, FRAC>: ConvertValue<i128, FRAC>, Value<i32, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<i8, FRAC>

where i8: PromoteAddSub<i64> + Copy, i64: Copy, <i8 as PromoteAddSub<i64>>::Output: Bounded + NumCast + Copy, Value<i8, FRAC>: ConvertValue<i128, FRAC>, Value<i64, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<i16, FRAC>

where i16: PromoteAddSub<i64> + Copy, i64: Copy, <i16 as PromoteAddSub<i64>>::Output: Bounded + NumCast + Copy, Value<i16, FRAC>: ConvertValue<i128, FRAC>, Value<i64, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<i32, FRAC>

where i32: PromoteAddSub<i64> + Copy, i64: Copy, <i32 as PromoteAddSub<i64>>::Output: Bounded + NumCast + Copy, Value<i32, FRAC>: ConvertValue<i128, FRAC>, Value<i64, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<i64, FRAC>

where i64: PromoteAddSub<i64> + Copy, <i64 as PromoteAddSub<i64>>::Output: Bounded + NumCast + Copy, Value<i64, FRAC>: ConvertValue<i128, FRAC>, Value<i64, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u8, FRAC>

where u8: PromoteAddSub<i64> + Copy, i64: Copy, <u8 as PromoteAddSub<i64>>::Output: Bounded + NumCast + Copy, Value<u8, FRAC>: ConvertValue<i128, FRAC>, Value<i64, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u16, FRAC>

where u16: PromoteAddSub<i64> + Copy, i64: Copy, <u16 as PromoteAddSub<i64>>::Output: Bounded + NumCast + Copy, Value<u16, FRAC>: ConvertValue<i128, FRAC>, Value<i64, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u32, FRAC>

where u32: PromoteAddSub<i64> + Copy, i64: Copy, <u32 as PromoteAddSub<i64>>::Output: Bounded + NumCast + Copy, Value<u32, FRAC>: ConvertValue<i128, FRAC>, Value<i64, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u64, FRAC>

where u64: PromoteAddSub<i64> + Copy, i64: Copy, <u64 as PromoteAddSub<i64>>::Output: Bounded + NumCast + Copy, Value<u64, FRAC>: ConvertValue<i128, FRAC>, Value<i64, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u8, FRAC>

where u8: PromoteAddSub<u8> + Copy, <u8 as PromoteAddSub<u8>>::Output: Bounded + NumCast + Copy, Value<u8, FRAC>: ConvertValue<i128, FRAC>, Value<u8, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u16, FRAC>

where u16: PromoteAddSub<u8> + Copy, u8: Copy, <u16 as PromoteAddSub<u8>>::Output: Bounded + NumCast + Copy, Value<u16, FRAC>: ConvertValue<i128, FRAC>, Value<u8, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u32, FRAC>

where u32: PromoteAddSub<u8> + Copy, u8: Copy, <u32 as PromoteAddSub<u8>>::Output: Bounded + NumCast + Copy, Value<u32, FRAC>: ConvertValue<i128, FRAC>, Value<u8, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u64, FRAC>

where u64: PromoteAddSub<u8> + Copy, u8: Copy, <u64 as PromoteAddSub<u8>>::Output: Bounded + NumCast + Copy, Value<u64, FRAC>: ConvertValue<i128, FRAC>, Value<u8, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<i8, FRAC>

where i8: PromoteAddSub<u8> + Copy, u8: Copy, <i8 as PromoteAddSub<u8>>::Output: Bounded + NumCast + Copy, Value<i8, FRAC>: ConvertValue<i128, FRAC>, Value<u8, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<i16, FRAC>

where i16: PromoteAddSub<u8> + Copy, u8: Copy, <i16 as PromoteAddSub<u8>>::Output: Bounded + NumCast + Copy, Value<i16, FRAC>: ConvertValue<i128, FRAC>, Value<u8, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<i32, FRAC>

where i32: PromoteAddSub<u8> + Copy, u8: Copy, <i32 as PromoteAddSub<u8>>::Output: Bounded + NumCast + Copy, Value<i32, FRAC>: ConvertValue<i128, FRAC>, Value<u8, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<i64, FRAC>

where i64: PromoteAddSub<u8> + Copy, u8: Copy, <i64 as PromoteAddSub<u8>>::Output: Bounded + NumCast + Copy, Value<i64, FRAC>: ConvertValue<i128, FRAC>, Value<u8, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u8, FRAC>

where u8: PromoteAddSub<u16> + Copy, u16: Copy, <u8 as PromoteAddSub<u16>>::Output: Bounded + NumCast + Copy, Value<u8, FRAC>: ConvertValue<i128, FRAC>, Value<u16, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u16, FRAC>

where u16: PromoteAddSub<u16> + Copy, <u16 as PromoteAddSub<u16>>::Output: Bounded + NumCast + Copy, Value<u16, FRAC>: ConvertValue<i128, FRAC>, Value<u16, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u32, FRAC>

where u32: PromoteAddSub<u16> + Copy, u16: Copy, <u32 as PromoteAddSub<u16>>::Output: Bounded + NumCast + Copy, Value<u32, FRAC>: ConvertValue<i128, FRAC>, Value<u16, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u64, FRAC>

where u64: PromoteAddSub<u16> + Copy, u16: Copy, <u64 as PromoteAddSub<u16>>::Output: Bounded + NumCast + Copy, Value<u64, FRAC>: ConvertValue<i128, FRAC>, Value<u16, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<i8, FRAC>

where i8: PromoteAddSub<u16> + Copy, u16: Copy, <i8 as PromoteAddSub<u16>>::Output: Bounded + NumCast + Copy, Value<i8, FRAC>: ConvertValue<i128, FRAC>, Value<u16, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<i16, FRAC>

where i16: PromoteAddSub<u16> + Copy, u16: Copy, <i16 as PromoteAddSub<u16>>::Output: Bounded + NumCast + Copy, Value<i16, FRAC>: ConvertValue<i128, FRAC>, Value<u16, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<i32, FRAC>

where i32: PromoteAddSub<u16> + Copy, u16: Copy, <i32 as PromoteAddSub<u16>>::Output: Bounded + NumCast + Copy, Value<i32, FRAC>: ConvertValue<i128, FRAC>, Value<u16, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<i64, FRAC>

where i64: PromoteAddSub<u16> + Copy, u16: Copy, <i64 as PromoteAddSub<u16>>::Output: Bounded + NumCast + Copy, Value<i64, FRAC>: ConvertValue<i128, FRAC>, Value<u16, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u8, FRAC>

where u8: PromoteAddSub<u32> + Copy, u32: Copy, <u8 as PromoteAddSub<u32>>::Output: Bounded + NumCast + Copy, Value<u8, FRAC>: ConvertValue<i128, FRAC>, Value<u32, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u16, FRAC>

where u16: PromoteAddSub<u32> + Copy, u32: Copy, <u16 as PromoteAddSub<u32>>::Output: Bounded + NumCast + Copy, Value<u16, FRAC>: ConvertValue<i128, FRAC>, Value<u32, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u32, FRAC>

where u32: PromoteAddSub<u32> + Copy, <u32 as PromoteAddSub<u32>>::Output: Bounded + NumCast + Copy, Value<u32, FRAC>: ConvertValue<i128, FRAC>, Value<u32, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u64, FRAC>

where u64: PromoteAddSub<u32> + Copy, u32: Copy, <u64 as PromoteAddSub<u32>>::Output: Bounded + NumCast + Copy, Value<u64, FRAC>: ConvertValue<i128, FRAC>, Value<u32, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<i8, FRAC>

where i8: PromoteAddSub<u32> + Copy, u32: Copy, <i8 as PromoteAddSub<u32>>::Output: Bounded + NumCast + Copy, Value<i8, FRAC>: ConvertValue<i128, FRAC>, Value<u32, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<i16, FRAC>

where i16: PromoteAddSub<u32> + Copy, u32: Copy, <i16 as PromoteAddSub<u32>>::Output: Bounded + NumCast + Copy, Value<i16, FRAC>: ConvertValue<i128, FRAC>, Value<u32, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<i32, FRAC>

where i32: PromoteAddSub<u32> + Copy, u32: Copy, <i32 as PromoteAddSub<u32>>::Output: Bounded + NumCast + Copy, Value<i32, FRAC>: ConvertValue<i128, FRAC>, Value<u32, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<i64, FRAC>

where i64: PromoteAddSub<u32> + Copy, u32: Copy, <i64 as PromoteAddSub<u32>>::Output: Bounded + NumCast + Copy, Value<i64, FRAC>: ConvertValue<i128, FRAC>, Value<u32, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u8, FRAC>

where u8: PromoteAddSub<u64> + Copy, u64: Copy, <u8 as PromoteAddSub<u64>>::Output: Bounded + NumCast + Copy, Value<u8, FRAC>: ConvertValue<i128, FRAC>, Value<u64, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u16, FRAC>

where u16: PromoteAddSub<u64> + Copy, u64: Copy, <u16 as PromoteAddSub<u64>>::Output: Bounded + NumCast + Copy, Value<u16, FRAC>: ConvertValue<i128, FRAC>, Value<u64, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u32, FRAC>

where u32: PromoteAddSub<u64> + Copy, u64: Copy, <u32 as PromoteAddSub<u64>>::Output: Bounded + NumCast + Copy, Value<u32, FRAC>: ConvertValue<i128, FRAC>, Value<u64, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<u64, FRAC>

where u64: PromoteAddSub<u64> + Copy, <u64 as PromoteAddSub<u64>>::Output: Bounded + NumCast + Copy, Value<u64, FRAC>: ConvertValue<i128, FRAC>, Value<u64, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<i8, FRAC>

where i8: PromoteAddSub<u64> + Copy, u64: Copy, <i8 as PromoteAddSub<u64>>::Output: Bounded + NumCast + Copy, Value<i8, FRAC>: ConvertValue<i128, FRAC>, Value<u64, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<i16, FRAC>

where i16: PromoteAddSub<u64> + Copy, u64: Copy, <i16 as PromoteAddSub<u64>>::Output: Bounded + NumCast + Copy, Value<i16, FRAC>: ConvertValue<i128, FRAC>, Value<u64, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<i32, FRAC>

where i32: PromoteAddSub<u64> + Copy, u64: Copy, <i32 as PromoteAddSub<u64>>::Output: Bounded + NumCast + Copy, Value<i32, FRAC>: ConvertValue<i128, FRAC>, Value<u64, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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 Fixed<i64, FRAC>

where i64: PromoteAddSub<u64> + Copy, u64: Copy, <i64 as PromoteAddSub<u64>>::Output: Bounded + NumCast + Copy, Value<i64, FRAC>: ConvertValue<i128, FRAC>, Value<u64, 0>: ConvertValue<i128, FRAC>,

type Output = Fixed<<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<Fixed<U, FRAC_R>> for Fixed<I, FRAC>

where I: PromoteAddSub<U> + Copy + Bounded + NumCast + TryFrom<I::Output>, U: Copy, I::Output: Bounded + NumCast + Copy + PartialOrd + Zero, Value<I, FRAC>: ConvertValue<i128, FRAC>, Value<U, FRAC_R>: ConvertValue<i128, FRAC>,

fn sub_assign(&mut self, rhs: Fixed<U, FRAC_R>)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<i8> for Fixed<i8, FRAC>

where i8: PromoteAddSub<i8> + Bounded + NumCast + Copy, <i8 as PromoteAddSub<i8>>::Output: Bounded + NumCast + Copy, Value<i8, FRAC>: ConvertValue<i128, FRAC>, Value<i8, 0>: ConvertValue<i128, FRAC>,

fn sub_assign(&mut self, rhs: i8)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<i8> for Fixed<i16, FRAC>

where i16: PromoteAddSub<i8> + Bounded + NumCast + Copy, i8: Copy, <i16 as PromoteAddSub<i8>>::Output: Bounded + NumCast + Copy, Value<i16, FRAC>: ConvertValue<i128, FRAC>, Value<i8, 0>: ConvertValue<i128, FRAC>,

fn sub_assign(&mut self, rhs: i8)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<i8> for Fixed<i32, FRAC>

where i32: PromoteAddSub<i8> + Bounded + NumCast + Copy, i8: Copy, <i32 as PromoteAddSub<i8>>::Output: Bounded + NumCast + Copy, Value<i32, FRAC>: ConvertValue<i128, FRAC>, Value<i8, 0>: ConvertValue<i128, FRAC>,

fn sub_assign(&mut self, rhs: i8)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<i8> for Fixed<i64, FRAC>

where i64: PromoteAddSub<i8> + Bounded + NumCast + Copy, i8: Copy, <i64 as PromoteAddSub<i8>>::Output: Bounded + NumCast + Copy, Value<i64, FRAC>: ConvertValue<i128, FRAC>, Value<i8, 0>: ConvertValue<i128, FRAC>,

fn sub_assign(&mut self, rhs: i8)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<i8> for Fixed<u8, FRAC>

where u8: PromoteAddSub<i8> + Bounded + NumCast + Copy, i8: Copy, <u8 as PromoteAddSub<i8>>::Output: Bounded + NumCast + Copy, Value<u8, FRAC>: ConvertValue<i128, FRAC>, Value<i8, 0>: ConvertValue<i128, FRAC>,

fn sub_assign(&mut self, rhs: i8)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<i8> for Fixed<u16, FRAC>

where u16: PromoteAddSub<i8> + Bounded + NumCast + Copy, i8: Copy, <u16 as PromoteAddSub<i8>>::Output: Bounded + NumCast + Copy, Value<u16, FRAC>: ConvertValue<i128, FRAC>, Value<i8, 0>: ConvertValue<i128, FRAC>,

fn sub_assign(&mut self, rhs: i8)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<i8> for Fixed<u32, FRAC>

where u32: PromoteAddSub<i8> + Bounded + NumCast + Copy, i8: Copy, <u32 as PromoteAddSub<i8>>::Output: Bounded + NumCast + Copy, Value<u32, FRAC>: ConvertValue<i128, FRAC>, Value<i8, 0>: ConvertValue<i128, FRAC>,

fn sub_assign(&mut self, rhs: i8)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<i8> for Fixed<u64, FRAC>

where u64: PromoteAddSub<i8> + Bounded + NumCast + Copy, i8: Copy, <u64 as PromoteAddSub<i8>>::Output: Bounded + NumCast + Copy, Value<u64, FRAC>: ConvertValue<i128, FRAC>, Value<i8, 0>: ConvertValue<i128, FRAC>,

fn sub_assign(&mut self, rhs: i8)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<i16> for Fixed<i8, FRAC>

where i8: PromoteAddSub<i16> + Bounded + NumCast + Copy, i16: Copy, <i8 as PromoteAddSub<i16>>::Output: Bounded + NumCast + Copy, Value<i8, FRAC>: ConvertValue<i128, FRAC>, Value<i16, 0>: ConvertValue<i128, FRAC>,

fn sub_assign(&mut self, rhs: i16)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<i16> for Fixed<i16, FRAC>

where i16: PromoteAddSub<i16> + Bounded + NumCast + Copy, <i16 as PromoteAddSub<i16>>::Output: Bounded + NumCast + Copy, Value<i16, FRAC>: ConvertValue<i128, FRAC>, Value<i16, 0>: ConvertValue<i128, FRAC>,

fn sub_assign(&mut self, rhs: i16)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<i16> for Fixed<i32, FRAC>

where i32: PromoteAddSub<i16> + Bounded + NumCast + Copy, i16: Copy, <i32 as PromoteAddSub<i16>>::Output: Bounded + NumCast + Copy, Value<i32, FRAC>: ConvertValue<i128, FRAC>, Value<i16, 0>: ConvertValue<i128, FRAC>,

fn sub_assign(&mut self, rhs: i16)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<i16> for Fixed<i64, FRAC>

where i64: PromoteAddSub<i16> + Bounded + NumCast + Copy, i16: Copy, <i64 as PromoteAddSub<i16>>::Output: Bounded + NumCast + Copy, Value<i64, FRAC>: ConvertValue<i128, FRAC>, Value<i16, 0>: ConvertValue<i128, FRAC>,

fn sub_assign(&mut self, rhs: i16)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<i16> for Fixed<u8, FRAC>

where u8: PromoteAddSub<i16> + Bounded + NumCast + Copy, i16: Copy, <u8 as PromoteAddSub<i16>>::Output: Bounded + NumCast + Copy, Value<u8, FRAC>: ConvertValue<i128, FRAC>, Value<i16, 0>: ConvertValue<i128, FRAC>,

fn sub_assign(&mut self, rhs: i16)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<i16> for Fixed<u16, FRAC>

where u16: PromoteAddSub<i16> + Bounded + NumCast + Copy, i16: Copy, <u16 as PromoteAddSub<i16>>::Output: Bounded + NumCast + Copy, Value<u16, FRAC>: ConvertValue<i128, FRAC>, Value<i16, 0>: ConvertValue<i128, FRAC>,

fn sub_assign(&mut self, rhs: i16)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<i16> for Fixed<u32, FRAC>

where u32: PromoteAddSub<i16> + Bounded + NumCast + Copy, i16: Copy, <u32 as PromoteAddSub<i16>>::Output: Bounded + NumCast + Copy, Value<u32, FRAC>: ConvertValue<i128, FRAC>, Value<i16, 0>: ConvertValue<i128, FRAC>,

fn sub_assign(&mut self, rhs: i16)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<i16> for Fixed<u64, FRAC>

where u64: PromoteAddSub<i16> + Bounded + NumCast + Copy, i16: Copy, <u64 as PromoteAddSub<i16>>::Output: Bounded + NumCast + Copy, Value<u64, FRAC>: ConvertValue<i128, FRAC>, Value<i16, 0>: ConvertValue<i128, FRAC>,

fn sub_assign(&mut self, rhs: i16)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<i32> for Fixed<i8, FRAC>

where i8: PromoteAddSub<i32> + Bounded + NumCast + Copy, i32: Copy, <i8 as PromoteAddSub<i32>>::Output: Bounded + NumCast + Copy, Value<i8, FRAC>: ConvertValue<i128, FRAC>, Value<i32, 0>: ConvertValue<i128, FRAC>,

fn sub_assign(&mut self, rhs: i32)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<i32> for Fixed<i16, FRAC>

where i16: PromoteAddSub<i32> + Bounded + NumCast + Copy, i32: Copy, <i16 as PromoteAddSub<i32>>::Output: Bounded + NumCast + Copy, Value<i16, FRAC>: ConvertValue<i128, FRAC>, Value<i32, 0>: ConvertValue<i128, FRAC>,

fn sub_assign(&mut self, rhs: i32)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<i32> for Fixed<i32, FRAC>

where i32: PromoteAddSub<i32> + Bounded + NumCast + Copy, <i32 as PromoteAddSub<i32>>::Output: Bounded + NumCast + Copy, Value<i32, FRAC>: ConvertValue<i128, FRAC>, Value<i32, 0>: ConvertValue<i128, FRAC>,

fn sub_assign(&mut self, rhs: i32)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<i32> for Fixed<i64, FRAC>

where i64: PromoteAddSub<i32> + Bounded + NumCast + Copy, i32: Copy, <i64 as PromoteAddSub<i32>>::Output: Bounded + NumCast + Copy, Value<i64, FRAC>: ConvertValue<i128, FRAC>, Value<i32, 0>: ConvertValue<i128, FRAC>,

fn sub_assign(&mut self, rhs: i32)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<i32> for Fixed<u8, FRAC>

where u8: PromoteAddSub<i32> + Bounded + NumCast + Copy, i32: Copy, <u8 as PromoteAddSub<i32>>::Output: Bounded + NumCast + Copy, Value<u8, FRAC>: ConvertValue<i128, FRAC>, Value<i32, 0>: ConvertValue<i128, FRAC>,

fn sub_assign(&mut self, rhs: i32)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<i32> for Fixed<u16, FRAC>

where u16: PromoteAddSub<i32> + Bounded + NumCast + Copy, i32: Copy, <u16 as PromoteAddSub<i32>>::Output: Bounded + NumCast + Copy, Value<u16, FRAC>: ConvertValue<i128, FRAC>, Value<i32, 0>: ConvertValue<i128, FRAC>,

fn sub_assign(&mut self, rhs: i32)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<i32> for Fixed<u32, FRAC>

where u32: PromoteAddSub<i32> + Bounded + NumCast + Copy, i32: Copy, <u32 as PromoteAddSub<i32>>::Output: Bounded + NumCast + Copy, Value<u32, FRAC>: ConvertValue<i128, FRAC>, Value<i32, 0>: ConvertValue<i128, FRAC>,

fn sub_assign(&mut self, rhs: i32)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<i32> for Fixed<u64, FRAC>

where u64: PromoteAddSub<i32> + Bounded + NumCast + Copy, i32: Copy, <u64 as PromoteAddSub<i32>>::Output: Bounded + NumCast + Copy, Value<u64, FRAC>: ConvertValue<i128, FRAC>, Value<i32, 0>: ConvertValue<i128, FRAC>,

fn sub_assign(&mut self, rhs: i32)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<i64> for Fixed<i8, FRAC>

where i8: PromoteAddSub<i64> + Bounded + NumCast + Copy, i64: Copy, <i8 as PromoteAddSub<i64>>::Output: Bounded + NumCast + Copy, Value<i8, FRAC>: ConvertValue<i128, FRAC>, Value<i64, 0>: ConvertValue<i128, FRAC>,

fn sub_assign(&mut self, rhs: i64)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<i64> for Fixed<i16, FRAC>

where i16: PromoteAddSub<i64> + Bounded + NumCast + Copy, i64: Copy, <i16 as PromoteAddSub<i64>>::Output: Bounded + NumCast + Copy, Value<i16, FRAC>: ConvertValue<i128, FRAC>, Value<i64, 0>: ConvertValue<i128, FRAC>,

fn sub_assign(&mut self, rhs: i64)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<i64> for Fixed<i32, FRAC>

where i32: PromoteAddSub<i64> + Bounded + NumCast + Copy, i64: Copy, <i32 as PromoteAddSub<i64>>::Output: Bounded + NumCast + Copy, Value<i32, FRAC>: ConvertValue<i128, FRAC>, Value<i64, 0>: ConvertValue<i128, FRAC>,

fn sub_assign(&mut self, rhs: i64)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<i64> for Fixed<i64, FRAC>

where i64: PromoteAddSub<i64> + Bounded + NumCast + Copy, <i64 as PromoteAddSub<i64>>::Output: Bounded + NumCast + Copy, Value<i64, FRAC>: ConvertValue<i128, FRAC>, Value<i64, 0>: ConvertValue<i128, FRAC>,

fn sub_assign(&mut self, rhs: i64)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<i64> for Fixed<u8, FRAC>

where u8: PromoteAddSub<i64> + Bounded + NumCast + Copy, i64: Copy, <u8 as PromoteAddSub<i64>>::Output: Bounded + NumCast + Copy, Value<u8, FRAC>: ConvertValue<i128, FRAC>, Value<i64, 0>: ConvertValue<i128, FRAC>,

fn sub_assign(&mut self, rhs: i64)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<i64> for Fixed<u16, FRAC>

where u16: PromoteAddSub<i64> + Bounded + NumCast + Copy, i64: Copy, <u16 as PromoteAddSub<i64>>::Output: Bounded + NumCast + Copy, Value<u16, FRAC>: ConvertValue<i128, FRAC>, Value<i64, 0>: ConvertValue<i128, FRAC>,

fn sub_assign(&mut self, rhs: i64)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<i64> for Fixed<u32, FRAC>

where u32: PromoteAddSub<i64> + Bounded + NumCast + Copy, i64: Copy, <u32 as PromoteAddSub<i64>>::Output: Bounded + NumCast + Copy, Value<u32, FRAC>: ConvertValue<i128, FRAC>, Value<i64, 0>: ConvertValue<i128, FRAC>,

fn sub_assign(&mut self, rhs: i64)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<i64> for Fixed<u64, FRAC>

where u64: PromoteAddSub<i64> + Bounded + NumCast + Copy, i64: Copy, <u64 as PromoteAddSub<i64>>::Output: Bounded + NumCast + Copy, Value<u64, FRAC>: ConvertValue<i128, FRAC>, Value<i64, 0>: ConvertValue<i128, FRAC>,

fn sub_assign(&mut self, rhs: i64)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<u8> for Fixed<u8, FRAC>

where u8: PromoteAddSub<u8> + Bounded + NumCast + Copy, <u8 as PromoteAddSub<u8>>::Output: Bounded + NumCast + Copy, Value<u8, FRAC>: ConvertValue<i128, FRAC>, Value<u8, 0>: ConvertValue<i128, FRAC>,

fn sub_assign(&mut self, rhs: u8)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<u8> for Fixed<u16, FRAC>

where u16: PromoteAddSub<u8> + Bounded + NumCast + Copy, u8: Copy, <u16 as PromoteAddSub<u8>>::Output: Bounded + NumCast + Copy, Value<u16, FRAC>: ConvertValue<i128, FRAC>, Value<u8, 0>: ConvertValue<i128, FRAC>,

fn sub_assign(&mut self, rhs: u8)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<u8> for Fixed<u32, FRAC>

where u32: PromoteAddSub<u8> + Bounded + NumCast + Copy, u8: Copy, <u32 as PromoteAddSub<u8>>::Output: Bounded + NumCast + Copy, Value<u32, FRAC>: ConvertValue<i128, FRAC>, Value<u8, 0>: ConvertValue<i128, FRAC>,

fn sub_assign(&mut self, rhs: u8)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<u8> for Fixed<u64, FRAC>

where u64: PromoteAddSub<u8> + Bounded + NumCast + Copy, u8: Copy, <u64 as PromoteAddSub<u8>>::Output: Bounded + NumCast + Copy, Value<u64, FRAC>: ConvertValue<i128, FRAC>, Value<u8, 0>: ConvertValue<i128, FRAC>,

fn sub_assign(&mut self, rhs: u8)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<u8> for Fixed<i8, FRAC>

where i8: PromoteAddSub<u8> + Bounded + NumCast + Copy, u8: Copy, <i8 as PromoteAddSub<u8>>::Output: Bounded + NumCast + Copy, Value<i8, FRAC>: ConvertValue<i128, FRAC>, Value<u8, 0>: ConvertValue<i128, FRAC>,

fn sub_assign(&mut self, rhs: u8)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<u8> for Fixed<i16, FRAC>

where i16: PromoteAddSub<u8> + Bounded + NumCast + Copy, u8: Copy, <i16 as PromoteAddSub<u8>>::Output: Bounded + NumCast + Copy, Value<i16, FRAC>: ConvertValue<i128, FRAC>, Value<u8, 0>: ConvertValue<i128, FRAC>,

fn sub_assign(&mut self, rhs: u8)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<u8> for Fixed<i32, FRAC>

where i32: PromoteAddSub<u8> + Bounded + NumCast + Copy, u8: Copy, <i32 as PromoteAddSub<u8>>::Output: Bounded + NumCast + Copy, Value<i32, FRAC>: ConvertValue<i128, FRAC>, Value<u8, 0>: ConvertValue<i128, FRAC>,

fn sub_assign(&mut self, rhs: u8)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<u8> for Fixed<i64, FRAC>

where i64: PromoteAddSub<u8> + Bounded + NumCast + Copy, u8: Copy, <i64 as PromoteAddSub<u8>>::Output: Bounded + NumCast + Copy, Value<i64, FRAC>: ConvertValue<i128, FRAC>, Value<u8, 0>: ConvertValue<i128, FRAC>,

fn sub_assign(&mut self, rhs: u8)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<u16> for Fixed<u8, FRAC>

where u8: PromoteAddSub<u16> + Bounded + NumCast + Copy, u16: Copy, <u8 as PromoteAddSub<u16>>::Output: Bounded + NumCast + Copy, Value<u8, FRAC>: ConvertValue<i128, FRAC>, Value<u16, 0>: ConvertValue<i128, FRAC>,

fn sub_assign(&mut self, rhs: u16)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<u16> for Fixed<u16, FRAC>

where u16: PromoteAddSub<u16> + Bounded + NumCast + Copy, <u16 as PromoteAddSub<u16>>::Output: Bounded + NumCast + Copy, Value<u16, FRAC>: ConvertValue<i128, FRAC>, Value<u16, 0>: ConvertValue<i128, FRAC>,

fn sub_assign(&mut self, rhs: u16)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<u16> for Fixed<u32, FRAC>

where u32: PromoteAddSub<u16> + Bounded + NumCast + Copy, u16: Copy, <u32 as PromoteAddSub<u16>>::Output: Bounded + NumCast + Copy, Value<u32, FRAC>: ConvertValue<i128, FRAC>, Value<u16, 0>: ConvertValue<i128, FRAC>,

fn sub_assign(&mut self, rhs: u16)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<u16> for Fixed<u64, FRAC>

where u64: PromoteAddSub<u16> + Bounded + NumCast + Copy, u16: Copy, <u64 as PromoteAddSub<u16>>::Output: Bounded + NumCast + Copy, Value<u64, FRAC>: ConvertValue<i128, FRAC>, Value<u16, 0>: ConvertValue<i128, FRAC>,

fn sub_assign(&mut self, rhs: u16)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<u16> for Fixed<i8, FRAC>

where i8: PromoteAddSub<u16> + Bounded + NumCast + Copy, u16: Copy, <i8 as PromoteAddSub<u16>>::Output: Bounded + NumCast + Copy, Value<i8, FRAC>: ConvertValue<i128, FRAC>, Value<u16, 0>: ConvertValue<i128, FRAC>,

fn sub_assign(&mut self, rhs: u16)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<u16> for Fixed<i16, FRAC>

where i16: PromoteAddSub<u16> + Bounded + NumCast + Copy, u16: Copy, <i16 as PromoteAddSub<u16>>::Output: Bounded + NumCast + Copy, Value<i16, FRAC>: ConvertValue<i128, FRAC>, Value<u16, 0>: ConvertValue<i128, FRAC>,

fn sub_assign(&mut self, rhs: u16)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<u16> for Fixed<i32, FRAC>

where i32: PromoteAddSub<u16> + Bounded + NumCast + Copy, u16: Copy, <i32 as PromoteAddSub<u16>>::Output: Bounded + NumCast + Copy, Value<i32, FRAC>: ConvertValue<i128, FRAC>, Value<u16, 0>: ConvertValue<i128, FRAC>,

fn sub_assign(&mut self, rhs: u16)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<u16> for Fixed<i64, FRAC>

where i64: PromoteAddSub<u16> + Bounded + NumCast + Copy, u16: Copy, <i64 as PromoteAddSub<u16>>::Output: Bounded + NumCast + Copy, Value<i64, FRAC>: ConvertValue<i128, FRAC>, Value<u16, 0>: ConvertValue<i128, FRAC>,

fn sub_assign(&mut self, rhs: u16)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<u32> for Fixed<u8, FRAC>

where u8: PromoteAddSub<u32> + Bounded + NumCast + Copy, u32: Copy, <u8 as PromoteAddSub<u32>>::Output: Bounded + NumCast + Copy, Value<u8, FRAC>: ConvertValue<i128, FRAC>, Value<u32, 0>: ConvertValue<i128, FRAC>,

fn sub_assign(&mut self, rhs: u32)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<u32> for Fixed<u16, FRAC>

where u16: PromoteAddSub<u32> + Bounded + NumCast + Copy, u32: Copy, <u16 as PromoteAddSub<u32>>::Output: Bounded + NumCast + Copy, Value<u16, FRAC>: ConvertValue<i128, FRAC>, Value<u32, 0>: ConvertValue<i128, FRAC>,

fn sub_assign(&mut self, rhs: u32)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<u32> for Fixed<u32, FRAC>

where u32: PromoteAddSub<u32> + Bounded + NumCast + Copy, <u32 as PromoteAddSub<u32>>::Output: Bounded + NumCast + Copy, Value<u32, FRAC>: ConvertValue<i128, FRAC>, Value<u32, 0>: ConvertValue<i128, FRAC>,

fn sub_assign(&mut self, rhs: u32)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<u32> for Fixed<u64, FRAC>

where u64: PromoteAddSub<u32> + Bounded + NumCast + Copy, u32: Copy, <u64 as PromoteAddSub<u32>>::Output: Bounded + NumCast + Copy, Value<u64, FRAC>: ConvertValue<i128, FRAC>, Value<u32, 0>: ConvertValue<i128, FRAC>,

fn sub_assign(&mut self, rhs: u32)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<u32> for Fixed<i8, FRAC>

where i8: PromoteAddSub<u32> + Bounded + NumCast + Copy, u32: Copy, <i8 as PromoteAddSub<u32>>::Output: Bounded + NumCast + Copy, Value<i8, FRAC>: ConvertValue<i128, FRAC>, Value<u32, 0>: ConvertValue<i128, FRAC>,

fn sub_assign(&mut self, rhs: u32)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<u32> for Fixed<i16, FRAC>

where i16: PromoteAddSub<u32> + Bounded + NumCast + Copy, u32: Copy, <i16 as PromoteAddSub<u32>>::Output: Bounded + NumCast + Copy, Value<i16, FRAC>: ConvertValue<i128, FRAC>, Value<u32, 0>: ConvertValue<i128, FRAC>,

fn sub_assign(&mut self, rhs: u32)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<u32> for Fixed<i32, FRAC>

where i32: PromoteAddSub<u32> + Bounded + NumCast + Copy, u32: Copy, <i32 as PromoteAddSub<u32>>::Output: Bounded + NumCast + Copy, Value<i32, FRAC>: ConvertValue<i128, FRAC>, Value<u32, 0>: ConvertValue<i128, FRAC>,

fn sub_assign(&mut self, rhs: u32)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<u32> for Fixed<i64, FRAC>

where i64: PromoteAddSub<u32> + Bounded + NumCast + Copy, u32: Copy, <i64 as PromoteAddSub<u32>>::Output: Bounded + NumCast + Copy, Value<i64, FRAC>: ConvertValue<i128, FRAC>, Value<u32, 0>: ConvertValue<i128, FRAC>,

fn sub_assign(&mut self, rhs: u32)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<u64> for Fixed<u8, FRAC>

where u8: PromoteAddSub<u64> + Bounded + NumCast + Copy, u64: Copy, <u8 as PromoteAddSub<u64>>::Output: Bounded + NumCast + Copy, Value<u8, FRAC>: ConvertValue<i128, FRAC>, Value<u64, 0>: ConvertValue<i128, FRAC>,

fn sub_assign(&mut self, rhs: u64)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<u64> for Fixed<u16, FRAC>

where u16: PromoteAddSub<u64> + Bounded + NumCast + Copy, u64: Copy, <u16 as PromoteAddSub<u64>>::Output: Bounded + NumCast + Copy, Value<u16, FRAC>: ConvertValue<i128, FRAC>, Value<u64, 0>: ConvertValue<i128, FRAC>,

fn sub_assign(&mut self, rhs: u64)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<u64> for Fixed<u32, FRAC>

where u32: PromoteAddSub<u64> + Bounded + NumCast + Copy, u64: Copy, <u32 as PromoteAddSub<u64>>::Output: Bounded + NumCast + Copy, Value<u32, FRAC>: ConvertValue<i128, FRAC>, Value<u64, 0>: ConvertValue<i128, FRAC>,

fn sub_assign(&mut self, rhs: u64)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<u64> for Fixed<u64, FRAC>

where u64: PromoteAddSub<u64> + Bounded + NumCast + Copy, <u64 as PromoteAddSub<u64>>::Output: Bounded + NumCast + Copy, Value<u64, FRAC>: ConvertValue<i128, FRAC>, Value<u64, 0>: ConvertValue<i128, FRAC>,

fn sub_assign(&mut self, rhs: u64)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<u64> for Fixed<i8, FRAC>

where i8: PromoteAddSub<u64> + Bounded + NumCast + Copy, u64: Copy, <i8 as PromoteAddSub<u64>>::Output: Bounded + NumCast + Copy, Value<i8, FRAC>: ConvertValue<i128, FRAC>, Value<u64, 0>: ConvertValue<i128, FRAC>,

fn sub_assign(&mut self, rhs: u64)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<u64> for Fixed<i16, FRAC>

where i16: PromoteAddSub<u64> + Bounded + NumCast + Copy, u64: Copy, <i16 as PromoteAddSub<u64>>::Output: Bounded + NumCast + Copy, Value<i16, FRAC>: ConvertValue<i128, FRAC>, Value<u64, 0>: ConvertValue<i128, FRAC>,

fn sub_assign(&mut self, rhs: u64)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<u64> for Fixed<i32, FRAC>

where i32: PromoteAddSub<u64> + Bounded + NumCast + Copy, u64: Copy, <i32 as PromoteAddSub<u64>>::Output: Bounded + NumCast + Copy, Value<i32, FRAC>: ConvertValue<i128, FRAC>, Value<u64, 0>: ConvertValue<i128, FRAC>,

fn sub_assign(&mut self, rhs: u64)

Performs the -= operation.

impl<const FRAC: usize> SubAssign<u64> for Fixed<i64, FRAC>

where i64: PromoteAddSub<u64> + Bounded + NumCast + Copy, u64: Copy, <i64 as PromoteAddSub<u64>>::Output: Bounded + NumCast + Copy, Value<i64, FRAC>: ConvertValue<i128, FRAC>, Value<u64, 0>: ConvertValue<i128, FRAC>,

fn sub_assign(&mut self, rhs: u64)

Performs the -= operation.