Struct fixed::Wrapping

#[repr(transparent)]
pub struct Wrapping<F>(pub F)
 where
    F: Fixed;

Provides intentionally wrapped arithmetic on fixed-point numbers.

The underlying value can be retrieved through the .0 index.

Examples

use fixed::Wrapping;
type Fix = fixed::types::I16F16;
let max = Wrapping(Fix::max_value());
let delta = Wrapping(Fix::from_bits(1));
assert_eq!(Fix::min_value(), (max + delta).0);

Methods

impl<F: Fixed> Wrapping<F>

pub fn ceil(self) -> Wrapping<F>

Wrapping ceil. Rounds to the next integer towards +∞, wrapping on overflow.

Examples

use fixed::Wrapping;
type Fix = fixed::types::I16F16;
let two_half = Wrapping(Fix::from_int(5) / 2);
assert_eq!(two_half.ceil(), Wrapping(Fix::from_int(3)));
assert_eq!(Wrapping(Fix::max_value()).ceil(), Wrapping(Fix::min_value()));

pub fn floor(self) -> Wrapping<F>

Wrapping floor. Rounds to the next integer towards −∞, wrapping on overflow.

Overflow can only occur for signed numbers with zero integer bits.

Examples

use fixed::Wrapping;
type Fix = fixed::types::I16F16;
let two_half = Wrapping(Fix::from_int(5) / 2);
assert_eq!(two_half.floor(), Wrapping(Fix::from_int(2)));
type AllFrac = fixed::types::I0F32;
assert_eq!(Wrapping(AllFrac::min_value()).floor(), Wrapping(AllFrac::from_int(0)));

pub fn round(self) -> Wrapping<F>

Wrapping round. Rounds to the next integer to the nearest, with ties rounded away from zero, and wrapping on overflow.

Examples

use fixed::Wrapping;
type Fix = fixed::types::I16F16;
let two_half = Wrapping(Fix::from_int(5) / 2);
assert_eq!(two_half.round(), Wrapping(Fix::from_int(3)));
assert_eq!((-two_half).round(), Wrapping(Fix::from_int(-3)));
assert_eq!(Wrapping(Fix::max_value()).round(), Wrapping(Fix::min_value()));

pub fn abs(self) -> Wrapping<F>

Wrapping absolute value. Returns the absolute value, wrapping on overflow.

Overflow can only occur for signed numbers when trying to find the absolute value of the minimum value.

Examples

use fixed::Wrapping;
type Fix = fixed::types::I16F16;
assert_eq!(Wrapping(Fix::from_int(-5)).abs(), Wrapping(Fix::from_int(5)));
assert_eq!(Wrapping(Fix::min_value()).abs(), Wrapping(Fix::min_value()));

Trait Implementations

impl<F> Clone for Wrapping<F> where
    F: Fixed, 

fn clone(&self) -> Wrapping<F>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<F> Display for Wrapping<F> where
    F: Fixed, 

fn fmt(&self, f: &mut Formatter) -> FmtResult

Formats the value using the given formatter.

impl<F> Debug for Wrapping<F> where
    F: Fixed, 

fn fmt(&self, f: &mut Formatter) -> FmtResult

Formats the value using the given formatter.

impl<F> PartialEq<Wrapping<F>> for Wrapping<F> where
    F: Fixed, 

fn eq(&self, other: &Wrapping<F>) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]

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

This method tests for !=.

impl<F> Eq for Wrapping<F> where
    F: Fixed, 

impl<F> Ord for Wrapping<F> where
    F: Fixed, 

fn cmp(&self, other: &Wrapping<F>) -> Ordering

This method returns an Ordering between self and other.

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

Compares and returns the maximum of two values.

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

Compares and returns the minimum of two values.

impl<F> PartialOrd<Wrapping<F>> for Wrapping<F> where
    F: Fixed, 

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

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

fn lt(&self, other: &Wrapping<F>) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Wrapping<F>) -> bool

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

fn gt(&self, other: &Wrapping<F>) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Wrapping<F>) -> bool

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

impl<F> From<F> for Wrapping<F> where
    F: Fixed, 

fn from(src: F) -> Wrapping<F>

Performs the conversion.

impl<F> Hash for Wrapping<F> where
    F: Fixed, 

fn hash<H>(&self, state: &mut H) where
    H: Hasher, 

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given [Hasher].

impl<F> Copy for Wrapping<F> where
    F: Fixed, 

impl<Frac> Add<Wrapping<FixedI8<Frac>>> for Wrapping<FixedI8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

type Output = Wrapping<FixedI8<Frac>>

The resulting type after applying the + operator.

fn add(self, other: Wrapping<FixedI8<Frac>>) -> Wrapping<FixedI8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

Performs the + operation.

impl<'a, Frac> Add<Wrapping<FixedI8<Frac>>> for &'a Wrapping<FixedI8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

type Output = Wrapping<FixedI8<Frac>>

The resulting type after applying the + operator.

fn add(self, other: Wrapping<FixedI8<Frac>>) -> Wrapping<FixedI8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

Performs the + operation.

impl<'a, Frac> Add<&'a Wrapping<FixedI8<Frac>>> for Wrapping<FixedI8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

type Output = Wrapping<FixedI8<Frac>>

The resulting type after applying the + operator.

fn add(self, other: &Wrapping<FixedI8<Frac>>) -> Wrapping<FixedI8<Frac>>

Performs the + operation.

impl<'a, 'b, Frac> Add<&'a Wrapping<FixedI8<Frac>>> for &'b Wrapping<FixedI8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

type Output = Wrapping<FixedI8<Frac>>

The resulting type after applying the + operator.

fn add(self, other: &Wrapping<FixedI8<Frac>>) -> Wrapping<FixedI8<Frac>>

Performs the + operation.

impl<Frac> Add<Wrapping<FixedI16<Frac>>> for Wrapping<FixedI16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

type Output = Wrapping<FixedI16<Frac>>

The resulting type after applying the + operator.

fn add(self, other: Wrapping<FixedI16<Frac>>) -> Wrapping<FixedI16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

Performs the + operation.

impl<'a, Frac> Add<Wrapping<FixedI16<Frac>>> for &'a Wrapping<FixedI16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

type Output = Wrapping<FixedI16<Frac>>

The resulting type after applying the + operator.

fn add(self, other: Wrapping<FixedI16<Frac>>) -> Wrapping<FixedI16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

Performs the + operation.

impl<'a, Frac> Add<&'a Wrapping<FixedI16<Frac>>> for Wrapping<FixedI16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

type Output = Wrapping<FixedI16<Frac>>

The resulting type after applying the + operator.

fn add(self, other: &Wrapping<FixedI16<Frac>>) -> Wrapping<FixedI16<Frac>>

Performs the + operation.

impl<'a, 'b, Frac> Add<&'a Wrapping<FixedI16<Frac>>> for &'b Wrapping<FixedI16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

type Output = Wrapping<FixedI16<Frac>>

The resulting type after applying the + operator.

fn add(self, other: &Wrapping<FixedI16<Frac>>) -> Wrapping<FixedI16<Frac>>

Performs the + operation.

impl<Frac> Add<Wrapping<FixedI32<Frac>>> for Wrapping<FixedI32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

type Output = Wrapping<FixedI32<Frac>>

The resulting type after applying the + operator.

fn add(self, other: Wrapping<FixedI32<Frac>>) -> Wrapping<FixedI32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

Performs the + operation.

impl<'a, Frac> Add<Wrapping<FixedI32<Frac>>> for &'a Wrapping<FixedI32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

type Output = Wrapping<FixedI32<Frac>>

The resulting type after applying the + operator.

fn add(self, other: Wrapping<FixedI32<Frac>>) -> Wrapping<FixedI32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

Performs the + operation.

impl<'a, Frac> Add<&'a Wrapping<FixedI32<Frac>>> for Wrapping<FixedI32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

type Output = Wrapping<FixedI32<Frac>>

The resulting type after applying the + operator.

fn add(self, other: &Wrapping<FixedI32<Frac>>) -> Wrapping<FixedI32<Frac>>

Performs the + operation.

impl<'a, 'b, Frac> Add<&'a Wrapping<FixedI32<Frac>>> for &'b Wrapping<FixedI32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

type Output = Wrapping<FixedI32<Frac>>

The resulting type after applying the + operator.

fn add(self, other: &Wrapping<FixedI32<Frac>>) -> Wrapping<FixedI32<Frac>>

Performs the + operation.

impl<Frac> Add<Wrapping<FixedI64<Frac>>> for Wrapping<FixedI64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

type Output = Wrapping<FixedI64<Frac>>

The resulting type after applying the + operator.

fn add(self, other: Wrapping<FixedI64<Frac>>) -> Wrapping<FixedI64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

Performs the + operation.

impl<'a, Frac> Add<Wrapping<FixedI64<Frac>>> for &'a Wrapping<FixedI64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

type Output = Wrapping<FixedI64<Frac>>

The resulting type after applying the + operator.

fn add(self, other: Wrapping<FixedI64<Frac>>) -> Wrapping<FixedI64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

Performs the + operation.

impl<'a, Frac> Add<&'a Wrapping<FixedI64<Frac>>> for Wrapping<FixedI64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

type Output = Wrapping<FixedI64<Frac>>

The resulting type after applying the + operator.

fn add(self, other: &Wrapping<FixedI64<Frac>>) -> Wrapping<FixedI64<Frac>>

Performs the + operation.

impl<'a, 'b, Frac> Add<&'a Wrapping<FixedI64<Frac>>> for &'b Wrapping<FixedI64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

type Output = Wrapping<FixedI64<Frac>>

The resulting type after applying the + operator.

fn add(self, other: &Wrapping<FixedI64<Frac>>) -> Wrapping<FixedI64<Frac>>

Performs the + operation.

impl<Frac> Add<Wrapping<FixedI128<Frac>>> for Wrapping<FixedI128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

type Output = Wrapping<FixedI128<Frac>>

The resulting type after applying the + operator.

fn add(self, other: Wrapping<FixedI128<Frac>>) -> Wrapping<FixedI128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

Performs the + operation.

impl<'a, Frac> Add<Wrapping<FixedI128<Frac>>> for &'a Wrapping<FixedI128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

type Output = Wrapping<FixedI128<Frac>>

The resulting type after applying the + operator.

fn add(self, other: Wrapping<FixedI128<Frac>>) -> Wrapping<FixedI128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

Performs the + operation.

impl<'a, Frac> Add<&'a Wrapping<FixedI128<Frac>>> for Wrapping<FixedI128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

type Output = Wrapping<FixedI128<Frac>>

The resulting type after applying the + operator.

fn add(self, other: &Wrapping<FixedI128<Frac>>) -> Wrapping<FixedI128<Frac>>

Performs the + operation.

impl<'a, 'b, Frac> Add<&'a Wrapping<FixedI128<Frac>>> for &'b Wrapping<FixedI128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

type Output = Wrapping<FixedI128<Frac>>

The resulting type after applying the + operator.

fn add(self, other: &Wrapping<FixedI128<Frac>>) -> Wrapping<FixedI128<Frac>>

Performs the + operation.

impl<Frac> Add<Wrapping<FixedU8<Frac>>> for Wrapping<FixedU8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

type Output = Wrapping<FixedU8<Frac>>

The resulting type after applying the + operator.

fn add(self, other: Wrapping<FixedU8<Frac>>) -> Wrapping<FixedU8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

Performs the + operation.

impl<'a, Frac> Add<Wrapping<FixedU8<Frac>>> for &'a Wrapping<FixedU8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

type Output = Wrapping<FixedU8<Frac>>

The resulting type after applying the + operator.

fn add(self, other: Wrapping<FixedU8<Frac>>) -> Wrapping<FixedU8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

Performs the + operation.

impl<'a, Frac> Add<&'a Wrapping<FixedU8<Frac>>> for Wrapping<FixedU8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

type Output = Wrapping<FixedU8<Frac>>

The resulting type after applying the + operator.

fn add(self, other: &Wrapping<FixedU8<Frac>>) -> Wrapping<FixedU8<Frac>>

Performs the + operation.

impl<'a, 'b, Frac> Add<&'a Wrapping<FixedU8<Frac>>> for &'b Wrapping<FixedU8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

type Output = Wrapping<FixedU8<Frac>>

The resulting type after applying the + operator.

fn add(self, other: &Wrapping<FixedU8<Frac>>) -> Wrapping<FixedU8<Frac>>

Performs the + operation.

impl<Frac> Add<Wrapping<FixedU16<Frac>>> for Wrapping<FixedU16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

type Output = Wrapping<FixedU16<Frac>>

The resulting type after applying the + operator.

fn add(self, other: Wrapping<FixedU16<Frac>>) -> Wrapping<FixedU16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

Performs the + operation.

impl<'a, Frac> Add<Wrapping<FixedU16<Frac>>> for &'a Wrapping<FixedU16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

type Output = Wrapping<FixedU16<Frac>>

The resulting type after applying the + operator.

fn add(self, other: Wrapping<FixedU16<Frac>>) -> Wrapping<FixedU16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

Performs the + operation.

impl<'a, Frac> Add<&'a Wrapping<FixedU16<Frac>>> for Wrapping<FixedU16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

type Output = Wrapping<FixedU16<Frac>>

The resulting type after applying the + operator.

fn add(self, other: &Wrapping<FixedU16<Frac>>) -> Wrapping<FixedU16<Frac>>

Performs the + operation.

impl<'a, 'b, Frac> Add<&'a Wrapping<FixedU16<Frac>>> for &'b Wrapping<FixedU16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

type Output = Wrapping<FixedU16<Frac>>

The resulting type after applying the + operator.

fn add(self, other: &Wrapping<FixedU16<Frac>>) -> Wrapping<FixedU16<Frac>>

Performs the + operation.

impl<Frac> Add<Wrapping<FixedU32<Frac>>> for Wrapping<FixedU32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

type Output = Wrapping<FixedU32<Frac>>

The resulting type after applying the + operator.

fn add(self, other: Wrapping<FixedU32<Frac>>) -> Wrapping<FixedU32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

Performs the + operation.

impl<'a, Frac> Add<Wrapping<FixedU32<Frac>>> for &'a Wrapping<FixedU32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

type Output = Wrapping<FixedU32<Frac>>

The resulting type after applying the + operator.

fn add(self, other: Wrapping<FixedU32<Frac>>) -> Wrapping<FixedU32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

Performs the + operation.

impl<'a, Frac> Add<&'a Wrapping<FixedU32<Frac>>> for Wrapping<FixedU32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

type Output = Wrapping<FixedU32<Frac>>

The resulting type after applying the + operator.

fn add(self, other: &Wrapping<FixedU32<Frac>>) -> Wrapping<FixedU32<Frac>>

Performs the + operation.

impl<'a, 'b, Frac> Add<&'a Wrapping<FixedU32<Frac>>> for &'b Wrapping<FixedU32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

type Output = Wrapping<FixedU32<Frac>>

The resulting type after applying the + operator.

fn add(self, other: &Wrapping<FixedU32<Frac>>) -> Wrapping<FixedU32<Frac>>

Performs the + operation.

impl<Frac> Add<Wrapping<FixedU64<Frac>>> for Wrapping<FixedU64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

type Output = Wrapping<FixedU64<Frac>>

The resulting type after applying the + operator.

fn add(self, other: Wrapping<FixedU64<Frac>>) -> Wrapping<FixedU64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

Performs the + operation.

impl<'a, Frac> Add<Wrapping<FixedU64<Frac>>> for &'a Wrapping<FixedU64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

type Output = Wrapping<FixedU64<Frac>>

The resulting type after applying the + operator.

fn add(self, other: Wrapping<FixedU64<Frac>>) -> Wrapping<FixedU64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

Performs the + operation.

impl<'a, Frac> Add<&'a Wrapping<FixedU64<Frac>>> for Wrapping<FixedU64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

type Output = Wrapping<FixedU64<Frac>>

The resulting type after applying the + operator.

fn add(self, other: &Wrapping<FixedU64<Frac>>) -> Wrapping<FixedU64<Frac>>

Performs the + operation.

impl<'a, 'b, Frac> Add<&'a Wrapping<FixedU64<Frac>>> for &'b Wrapping<FixedU64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

type Output = Wrapping<FixedU64<Frac>>

The resulting type after applying the + operator.

fn add(self, other: &Wrapping<FixedU64<Frac>>) -> Wrapping<FixedU64<Frac>>

Performs the + operation.

impl<Frac> Add<Wrapping<FixedU128<Frac>>> for Wrapping<FixedU128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

type Output = Wrapping<FixedU128<Frac>>

The resulting type after applying the + operator.

fn add(self, other: Wrapping<FixedU128<Frac>>) -> Wrapping<FixedU128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

Performs the + operation.

impl<'a, Frac> Add<Wrapping<FixedU128<Frac>>> for &'a Wrapping<FixedU128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

type Output = Wrapping<FixedU128<Frac>>

The resulting type after applying the + operator.

fn add(self, other: Wrapping<FixedU128<Frac>>) -> Wrapping<FixedU128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

Performs the + operation.

impl<'a, Frac> Add<&'a Wrapping<FixedU128<Frac>>> for Wrapping<FixedU128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

type Output = Wrapping<FixedU128<Frac>>

The resulting type after applying the + operator.

fn add(self, other: &Wrapping<FixedU128<Frac>>) -> Wrapping<FixedU128<Frac>>

Performs the + operation.

impl<'a, 'b, Frac> Add<&'a Wrapping<FixedU128<Frac>>> for &'b Wrapping<FixedU128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

type Output = Wrapping<FixedU128<Frac>>

The resulting type after applying the + operator.

fn add(self, other: &Wrapping<FixedU128<Frac>>) -> Wrapping<FixedU128<Frac>>

Performs the + operation.

impl<Frac> Sub<Wrapping<FixedI8<Frac>>> for Wrapping<FixedI8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

type Output = Wrapping<FixedI8<Frac>>

The resulting type after applying the - operator.

fn sub(self, other: Wrapping<FixedI8<Frac>>) -> Wrapping<FixedI8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

Performs the - operation.

impl<'a, Frac> Sub<Wrapping<FixedI8<Frac>>> for &'a Wrapping<FixedI8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

type Output = Wrapping<FixedI8<Frac>>

The resulting type after applying the - operator.

fn sub(self, other: Wrapping<FixedI8<Frac>>) -> Wrapping<FixedI8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

Performs the - operation.

impl<'a, Frac> Sub<&'a Wrapping<FixedI8<Frac>>> for Wrapping<FixedI8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

type Output = Wrapping<FixedI8<Frac>>

The resulting type after applying the - operator.

fn sub(self, other: &Wrapping<FixedI8<Frac>>) -> Wrapping<FixedI8<Frac>>

Performs the - operation.

impl<'a, 'b, Frac> Sub<&'a Wrapping<FixedI8<Frac>>> for &'b Wrapping<FixedI8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

type Output = Wrapping<FixedI8<Frac>>

The resulting type after applying the - operator.

fn sub(self, other: &Wrapping<FixedI8<Frac>>) -> Wrapping<FixedI8<Frac>>

Performs the - operation.

impl<Frac> Sub<Wrapping<FixedI16<Frac>>> for Wrapping<FixedI16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

type Output = Wrapping<FixedI16<Frac>>

The resulting type after applying the - operator.

fn sub(self, other: Wrapping<FixedI16<Frac>>) -> Wrapping<FixedI16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

Performs the - operation.

impl<'a, Frac> Sub<Wrapping<FixedI16<Frac>>> for &'a Wrapping<FixedI16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

type Output = Wrapping<FixedI16<Frac>>

The resulting type after applying the - operator.

fn sub(self, other: Wrapping<FixedI16<Frac>>) -> Wrapping<FixedI16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

Performs the - operation.

impl<'a, Frac> Sub<&'a Wrapping<FixedI16<Frac>>> for Wrapping<FixedI16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

type Output = Wrapping<FixedI16<Frac>>

The resulting type after applying the - operator.

fn sub(self, other: &Wrapping<FixedI16<Frac>>) -> Wrapping<FixedI16<Frac>>

Performs the - operation.

impl<'a, 'b, Frac> Sub<&'a Wrapping<FixedI16<Frac>>> for &'b Wrapping<FixedI16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

type Output = Wrapping<FixedI16<Frac>>

The resulting type after applying the - operator.

fn sub(self, other: &Wrapping<FixedI16<Frac>>) -> Wrapping<FixedI16<Frac>>

Performs the - operation.

impl<Frac> Sub<Wrapping<FixedI32<Frac>>> for Wrapping<FixedI32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

type Output = Wrapping<FixedI32<Frac>>

The resulting type after applying the - operator.

fn sub(self, other: Wrapping<FixedI32<Frac>>) -> Wrapping<FixedI32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

Performs the - operation.

impl<'a, Frac> Sub<Wrapping<FixedI32<Frac>>> for &'a Wrapping<FixedI32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

type Output = Wrapping<FixedI32<Frac>>

The resulting type after applying the - operator.

fn sub(self, other: Wrapping<FixedI32<Frac>>) -> Wrapping<FixedI32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

Performs the - operation.

impl<'a, Frac> Sub<&'a Wrapping<FixedI32<Frac>>> for Wrapping<FixedI32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

type Output = Wrapping<FixedI32<Frac>>

The resulting type after applying the - operator.

fn sub(self, other: &Wrapping<FixedI32<Frac>>) -> Wrapping<FixedI32<Frac>>

Performs the - operation.

impl<'a, 'b, Frac> Sub<&'a Wrapping<FixedI32<Frac>>> for &'b Wrapping<FixedI32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

type Output = Wrapping<FixedI32<Frac>>

The resulting type after applying the - operator.

fn sub(self, other: &Wrapping<FixedI32<Frac>>) -> Wrapping<FixedI32<Frac>>

Performs the - operation.

impl<Frac> Sub<Wrapping<FixedI64<Frac>>> for Wrapping<FixedI64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

type Output = Wrapping<FixedI64<Frac>>

The resulting type after applying the - operator.

fn sub(self, other: Wrapping<FixedI64<Frac>>) -> Wrapping<FixedI64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

Performs the - operation.

impl<'a, Frac> Sub<Wrapping<FixedI64<Frac>>> for &'a Wrapping<FixedI64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

type Output = Wrapping<FixedI64<Frac>>

The resulting type after applying the - operator.

fn sub(self, other: Wrapping<FixedI64<Frac>>) -> Wrapping<FixedI64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

Performs the - operation.

impl<'a, Frac> Sub<&'a Wrapping<FixedI64<Frac>>> for Wrapping<FixedI64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

type Output = Wrapping<FixedI64<Frac>>

The resulting type after applying the - operator.

fn sub(self, other: &Wrapping<FixedI64<Frac>>) -> Wrapping<FixedI64<Frac>>

Performs the - operation.

impl<'a, 'b, Frac> Sub<&'a Wrapping<FixedI64<Frac>>> for &'b Wrapping<FixedI64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

type Output = Wrapping<FixedI64<Frac>>

The resulting type after applying the - operator.

fn sub(self, other: &Wrapping<FixedI64<Frac>>) -> Wrapping<FixedI64<Frac>>

Performs the - operation.

impl<Frac> Sub<Wrapping<FixedI128<Frac>>> for Wrapping<FixedI128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

type Output = Wrapping<FixedI128<Frac>>

The resulting type after applying the - operator.

fn sub(self, other: Wrapping<FixedI128<Frac>>) -> Wrapping<FixedI128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

Performs the - operation.

impl<'a, Frac> Sub<Wrapping<FixedI128<Frac>>> for &'a Wrapping<FixedI128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

type Output = Wrapping<FixedI128<Frac>>

The resulting type after applying the - operator.

fn sub(self, other: Wrapping<FixedI128<Frac>>) -> Wrapping<FixedI128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

Performs the - operation.

impl<'a, Frac> Sub<&'a Wrapping<FixedI128<Frac>>> for Wrapping<FixedI128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

type Output = Wrapping<FixedI128<Frac>>

The resulting type after applying the - operator.

fn sub(self, other: &Wrapping<FixedI128<Frac>>) -> Wrapping<FixedI128<Frac>>

Performs the - operation.

impl<'a, 'b, Frac> Sub<&'a Wrapping<FixedI128<Frac>>> for &'b Wrapping<FixedI128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

type Output = Wrapping<FixedI128<Frac>>

The resulting type after applying the - operator.

fn sub(self, other: &Wrapping<FixedI128<Frac>>) -> Wrapping<FixedI128<Frac>>

Performs the - operation.

impl<Frac> Sub<Wrapping<FixedU8<Frac>>> for Wrapping<FixedU8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

type Output = Wrapping<FixedU8<Frac>>

The resulting type after applying the - operator.

fn sub(self, other: Wrapping<FixedU8<Frac>>) -> Wrapping<FixedU8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

Performs the - operation.

impl<'a, Frac> Sub<Wrapping<FixedU8<Frac>>> for &'a Wrapping<FixedU8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

type Output = Wrapping<FixedU8<Frac>>

The resulting type after applying the - operator.

fn sub(self, other: Wrapping<FixedU8<Frac>>) -> Wrapping<FixedU8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

Performs the - operation.

impl<'a, Frac> Sub<&'a Wrapping<FixedU8<Frac>>> for Wrapping<FixedU8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

type Output = Wrapping<FixedU8<Frac>>

The resulting type after applying the - operator.

fn sub(self, other: &Wrapping<FixedU8<Frac>>) -> Wrapping<FixedU8<Frac>>

Performs the - operation.

impl<'a, 'b, Frac> Sub<&'a Wrapping<FixedU8<Frac>>> for &'b Wrapping<FixedU8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

type Output = Wrapping<FixedU8<Frac>>

The resulting type after applying the - operator.

fn sub(self, other: &Wrapping<FixedU8<Frac>>) -> Wrapping<FixedU8<Frac>>

Performs the - operation.

impl<Frac> Sub<Wrapping<FixedU16<Frac>>> for Wrapping<FixedU16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

type Output = Wrapping<FixedU16<Frac>>

The resulting type after applying the - operator.

fn sub(self, other: Wrapping<FixedU16<Frac>>) -> Wrapping<FixedU16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

Performs the - operation.

impl<'a, Frac> Sub<Wrapping<FixedU16<Frac>>> for &'a Wrapping<FixedU16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

type Output = Wrapping<FixedU16<Frac>>

The resulting type after applying the - operator.

fn sub(self, other: Wrapping<FixedU16<Frac>>) -> Wrapping<FixedU16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

Performs the - operation.

impl<'a, Frac> Sub<&'a Wrapping<FixedU16<Frac>>> for Wrapping<FixedU16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

type Output = Wrapping<FixedU16<Frac>>

The resulting type after applying the - operator.

fn sub(self, other: &Wrapping<FixedU16<Frac>>) -> Wrapping<FixedU16<Frac>>

Performs the - operation.

impl<'a, 'b, Frac> Sub<&'a Wrapping<FixedU16<Frac>>> for &'b Wrapping<FixedU16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

type Output = Wrapping<FixedU16<Frac>>

The resulting type after applying the - operator.

fn sub(self, other: &Wrapping<FixedU16<Frac>>) -> Wrapping<FixedU16<Frac>>

Performs the - operation.

impl<Frac> Sub<Wrapping<FixedU32<Frac>>> for Wrapping<FixedU32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

type Output = Wrapping<FixedU32<Frac>>

The resulting type after applying the - operator.

fn sub(self, other: Wrapping<FixedU32<Frac>>) -> Wrapping<FixedU32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

Performs the - operation.

impl<'a, Frac> Sub<Wrapping<FixedU32<Frac>>> for &'a Wrapping<FixedU32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

type Output = Wrapping<FixedU32<Frac>>

The resulting type after applying the - operator.

fn sub(self, other: Wrapping<FixedU32<Frac>>) -> Wrapping<FixedU32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

Performs the - operation.

impl<'a, Frac> Sub<&'a Wrapping<FixedU32<Frac>>> for Wrapping<FixedU32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

type Output = Wrapping<FixedU32<Frac>>

The resulting type after applying the - operator.

fn sub(self, other: &Wrapping<FixedU32<Frac>>) -> Wrapping<FixedU32<Frac>>

Performs the - operation.

impl<'a, 'b, Frac> Sub<&'a Wrapping<FixedU32<Frac>>> for &'b Wrapping<FixedU32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

type Output = Wrapping<FixedU32<Frac>>

The resulting type after applying the - operator.

fn sub(self, other: &Wrapping<FixedU32<Frac>>) -> Wrapping<FixedU32<Frac>>

Performs the - operation.

impl<Frac> Sub<Wrapping<FixedU64<Frac>>> for Wrapping<FixedU64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

type Output = Wrapping<FixedU64<Frac>>

The resulting type after applying the - operator.

fn sub(self, other: Wrapping<FixedU64<Frac>>) -> Wrapping<FixedU64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

Performs the - operation.

impl<'a, Frac> Sub<Wrapping<FixedU64<Frac>>> for &'a Wrapping<FixedU64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

type Output = Wrapping<FixedU64<Frac>>

The resulting type after applying the - operator.

fn sub(self, other: Wrapping<FixedU64<Frac>>) -> Wrapping<FixedU64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

Performs the - operation.

impl<'a, Frac> Sub<&'a Wrapping<FixedU64<Frac>>> for Wrapping<FixedU64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

type Output = Wrapping<FixedU64<Frac>>

The resulting type after applying the - operator.

fn sub(self, other: &Wrapping<FixedU64<Frac>>) -> Wrapping<FixedU64<Frac>>

Performs the - operation.

impl<'a, 'b, Frac> Sub<&'a Wrapping<FixedU64<Frac>>> for &'b Wrapping<FixedU64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

type Output = Wrapping<FixedU64<Frac>>

The resulting type after applying the - operator.

fn sub(self, other: &Wrapping<FixedU64<Frac>>) -> Wrapping<FixedU64<Frac>>

Performs the - operation.

impl<Frac> Sub<Wrapping<FixedU128<Frac>>> for Wrapping<FixedU128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

type Output = Wrapping<FixedU128<Frac>>

The resulting type after applying the - operator.

fn sub(self, other: Wrapping<FixedU128<Frac>>) -> Wrapping<FixedU128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

Performs the - operation.

impl<'a, Frac> Sub<Wrapping<FixedU128<Frac>>> for &'a Wrapping<FixedU128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

type Output = Wrapping<FixedU128<Frac>>

The resulting type after applying the - operator.

fn sub(self, other: Wrapping<FixedU128<Frac>>) -> Wrapping<FixedU128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

Performs the - operation.

impl<'a, Frac> Sub<&'a Wrapping<FixedU128<Frac>>> for Wrapping<FixedU128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

type Output = Wrapping<FixedU128<Frac>>

The resulting type after applying the - operator.

fn sub(self, other: &Wrapping<FixedU128<Frac>>) -> Wrapping<FixedU128<Frac>>

Performs the - operation.

impl<'a, 'b, Frac> Sub<&'a Wrapping<FixedU128<Frac>>> for &'b Wrapping<FixedU128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

type Output = Wrapping<FixedU128<Frac>>

The resulting type after applying the - operator.

fn sub(self, other: &Wrapping<FixedU128<Frac>>) -> Wrapping<FixedU128<Frac>>

Performs the - operation.

impl<Frac> Mul<Wrapping<FixedI8<Frac>>> for Wrapping<FixedI8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

type Output = Wrapping<FixedI8<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: Wrapping<FixedI8<Frac>>) -> Wrapping<FixedI8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

Performs the * operation.

impl<'a, Frac> Mul<Wrapping<FixedI8<Frac>>> for &'a Wrapping<FixedI8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

type Output = Wrapping<FixedI8<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: Wrapping<FixedI8<Frac>>) -> Wrapping<FixedI8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

Performs the * operation.

impl<'a, Frac> Mul<&'a Wrapping<FixedI8<Frac>>> for Wrapping<FixedI8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

type Output = Wrapping<FixedI8<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: &Wrapping<FixedI8<Frac>>) -> Wrapping<FixedI8<Frac>>

Performs the * operation.

impl<'a, 'b, Frac> Mul<&'a Wrapping<FixedI8<Frac>>> for &'b Wrapping<FixedI8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

type Output = Wrapping<FixedI8<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: &Wrapping<FixedI8<Frac>>) -> Wrapping<FixedI8<Frac>>

Performs the * operation.

impl<Frac> Mul<i8> for Wrapping<FixedI8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

type Output = Wrapping<FixedI8<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: i8) -> Wrapping<FixedI8<Frac>>

Performs the * operation.

impl<'a, Frac> Mul<i8> for &'a Wrapping<FixedI8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

type Output = Wrapping<FixedI8<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: i8) -> Wrapping<FixedI8<Frac>>

Performs the * operation.

impl<'a, Frac> Mul<&'a i8> for Wrapping<FixedI8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

type Output = Wrapping<FixedI8<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: &i8) -> Wrapping<FixedI8<Frac>>

Performs the * operation.

impl<'a, 'b, Frac> Mul<&'a i8> for &'b Wrapping<FixedI8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

type Output = Wrapping<FixedI8<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: &i8) -> Wrapping<FixedI8<Frac>>

Performs the * operation.

impl<Frac> Mul<Wrapping<FixedI16<Frac>>> for Wrapping<FixedI16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

type Output = Wrapping<FixedI16<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: Wrapping<FixedI16<Frac>>) -> Wrapping<FixedI16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

Performs the * operation.

impl<'a, Frac> Mul<Wrapping<FixedI16<Frac>>> for &'a Wrapping<FixedI16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

type Output = Wrapping<FixedI16<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: Wrapping<FixedI16<Frac>>) -> Wrapping<FixedI16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

Performs the * operation.

impl<'a, Frac> Mul<&'a Wrapping<FixedI16<Frac>>> for Wrapping<FixedI16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

type Output = Wrapping<FixedI16<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: &Wrapping<FixedI16<Frac>>) -> Wrapping<FixedI16<Frac>>

Performs the * operation.

impl<'a, 'b, Frac> Mul<&'a Wrapping<FixedI16<Frac>>> for &'b Wrapping<FixedI16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

type Output = Wrapping<FixedI16<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: &Wrapping<FixedI16<Frac>>) -> Wrapping<FixedI16<Frac>>

Performs the * operation.

impl<Frac> Mul<i16> for Wrapping<FixedI16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

type Output = Wrapping<FixedI16<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: i16) -> Wrapping<FixedI16<Frac>>

Performs the * operation.

impl<'a, Frac> Mul<i16> for &'a Wrapping<FixedI16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

type Output = Wrapping<FixedI16<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: i16) -> Wrapping<FixedI16<Frac>>

Performs the * operation.

impl<'a, Frac> Mul<&'a i16> for Wrapping<FixedI16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

type Output = Wrapping<FixedI16<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: &i16) -> Wrapping<FixedI16<Frac>>

Performs the * operation.

impl<'a, 'b, Frac> Mul<&'a i16> for &'b Wrapping<FixedI16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

type Output = Wrapping<FixedI16<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: &i16) -> Wrapping<FixedI16<Frac>>

Performs the * operation.

impl<Frac> Mul<Wrapping<FixedI32<Frac>>> for Wrapping<FixedI32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

type Output = Wrapping<FixedI32<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: Wrapping<FixedI32<Frac>>) -> Wrapping<FixedI32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

Performs the * operation.

impl<'a, Frac> Mul<Wrapping<FixedI32<Frac>>> for &'a Wrapping<FixedI32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

type Output = Wrapping<FixedI32<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: Wrapping<FixedI32<Frac>>) -> Wrapping<FixedI32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

Performs the * operation.

impl<'a, Frac> Mul<&'a Wrapping<FixedI32<Frac>>> for Wrapping<FixedI32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

type Output = Wrapping<FixedI32<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: &Wrapping<FixedI32<Frac>>) -> Wrapping<FixedI32<Frac>>

Performs the * operation.

impl<'a, 'b, Frac> Mul<&'a Wrapping<FixedI32<Frac>>> for &'b Wrapping<FixedI32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

type Output = Wrapping<FixedI32<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: &Wrapping<FixedI32<Frac>>) -> Wrapping<FixedI32<Frac>>

Performs the * operation.

impl<Frac> Mul<i32> for Wrapping<FixedI32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

type Output = Wrapping<FixedI32<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: i32) -> Wrapping<FixedI32<Frac>>

Performs the * operation.

impl<'a, Frac> Mul<i32> for &'a Wrapping<FixedI32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

type Output = Wrapping<FixedI32<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: i32) -> Wrapping<FixedI32<Frac>>

Performs the * operation.

impl<'a, Frac> Mul<&'a i32> for Wrapping<FixedI32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

type Output = Wrapping<FixedI32<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: &i32) -> Wrapping<FixedI32<Frac>>

Performs the * operation.

impl<'a, 'b, Frac> Mul<&'a i32> for &'b Wrapping<FixedI32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

type Output = Wrapping<FixedI32<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: &i32) -> Wrapping<FixedI32<Frac>>

Performs the * operation.

impl<Frac> Mul<Wrapping<FixedI64<Frac>>> for Wrapping<FixedI64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

type Output = Wrapping<FixedI64<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: Wrapping<FixedI64<Frac>>) -> Wrapping<FixedI64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

Performs the * operation.

impl<'a, Frac> Mul<Wrapping<FixedI64<Frac>>> for &'a Wrapping<FixedI64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

type Output = Wrapping<FixedI64<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: Wrapping<FixedI64<Frac>>) -> Wrapping<FixedI64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

Performs the * operation.

impl<'a, Frac> Mul<&'a Wrapping<FixedI64<Frac>>> for Wrapping<FixedI64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

type Output = Wrapping<FixedI64<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: &Wrapping<FixedI64<Frac>>) -> Wrapping<FixedI64<Frac>>

Performs the * operation.

impl<'a, 'b, Frac> Mul<&'a Wrapping<FixedI64<Frac>>> for &'b Wrapping<FixedI64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

type Output = Wrapping<FixedI64<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: &Wrapping<FixedI64<Frac>>) -> Wrapping<FixedI64<Frac>>

Performs the * operation.

impl<Frac> Mul<i64> for Wrapping<FixedI64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

type Output = Wrapping<FixedI64<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: i64) -> Wrapping<FixedI64<Frac>>

Performs the * operation.

impl<'a, Frac> Mul<i64> for &'a Wrapping<FixedI64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

type Output = Wrapping<FixedI64<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: i64) -> Wrapping<FixedI64<Frac>>

Performs the * operation.

impl<'a, Frac> Mul<&'a i64> for Wrapping<FixedI64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

type Output = Wrapping<FixedI64<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: &i64) -> Wrapping<FixedI64<Frac>>

Performs the * operation.

impl<'a, 'b, Frac> Mul<&'a i64> for &'b Wrapping<FixedI64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

type Output = Wrapping<FixedI64<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: &i64) -> Wrapping<FixedI64<Frac>>

Performs the * operation.

impl<Frac> Mul<Wrapping<FixedI128<Frac>>> for Wrapping<FixedI128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

type Output = Wrapping<FixedI128<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: Wrapping<FixedI128<Frac>>) -> Wrapping<FixedI128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

Performs the * operation.

impl<'a, Frac> Mul<Wrapping<FixedI128<Frac>>> for &'a Wrapping<FixedI128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

type Output = Wrapping<FixedI128<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: Wrapping<FixedI128<Frac>>) -> Wrapping<FixedI128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

Performs the * operation.

impl<'a, Frac> Mul<&'a Wrapping<FixedI128<Frac>>> for Wrapping<FixedI128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

type Output = Wrapping<FixedI128<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: &Wrapping<FixedI128<Frac>>) -> Wrapping<FixedI128<Frac>>

Performs the * operation.

impl<'a, 'b, Frac> Mul<&'a Wrapping<FixedI128<Frac>>> for &'b Wrapping<FixedI128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

type Output = Wrapping<FixedI128<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: &Wrapping<FixedI128<Frac>>) -> Wrapping<FixedI128<Frac>>

Performs the * operation.

impl<Frac> Mul<i128> for Wrapping<FixedI128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

type Output = Wrapping<FixedI128<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: i128) -> Wrapping<FixedI128<Frac>>

Performs the * operation.

impl<'a, Frac> Mul<i128> for &'a Wrapping<FixedI128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

type Output = Wrapping<FixedI128<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: i128) -> Wrapping<FixedI128<Frac>>

Performs the * operation.

impl<'a, Frac> Mul<&'a i128> for Wrapping<FixedI128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

type Output = Wrapping<FixedI128<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: &i128) -> Wrapping<FixedI128<Frac>>

Performs the * operation.

impl<'a, 'b, Frac> Mul<&'a i128> for &'b Wrapping<FixedI128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

type Output = Wrapping<FixedI128<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: &i128) -> Wrapping<FixedI128<Frac>>

Performs the * operation.

impl<Frac> Mul<Wrapping<FixedU8<Frac>>> for Wrapping<FixedU8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

type Output = Wrapping<FixedU8<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: Wrapping<FixedU8<Frac>>) -> Wrapping<FixedU8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

Performs the * operation.

impl<'a, Frac> Mul<Wrapping<FixedU8<Frac>>> for &'a Wrapping<FixedU8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

type Output = Wrapping<FixedU8<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: Wrapping<FixedU8<Frac>>) -> Wrapping<FixedU8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

Performs the * operation.

impl<'a, Frac> Mul<&'a Wrapping<FixedU8<Frac>>> for Wrapping<FixedU8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

type Output = Wrapping<FixedU8<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: &Wrapping<FixedU8<Frac>>) -> Wrapping<FixedU8<Frac>>

Performs the * operation.

impl<'a, 'b, Frac> Mul<&'a Wrapping<FixedU8<Frac>>> for &'b Wrapping<FixedU8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

type Output = Wrapping<FixedU8<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: &Wrapping<FixedU8<Frac>>) -> Wrapping<FixedU8<Frac>>

Performs the * operation.

impl<Frac> Mul<u8> for Wrapping<FixedU8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

type Output = Wrapping<FixedU8<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: u8) -> Wrapping<FixedU8<Frac>>

Performs the * operation.

impl<'a, Frac> Mul<u8> for &'a Wrapping<FixedU8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

type Output = Wrapping<FixedU8<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: u8) -> Wrapping<FixedU8<Frac>>

Performs the * operation.

impl<'a, Frac> Mul<&'a u8> for Wrapping<FixedU8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

type Output = Wrapping<FixedU8<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: &u8) -> Wrapping<FixedU8<Frac>>

Performs the * operation.

impl<'a, 'b, Frac> Mul<&'a u8> for &'b Wrapping<FixedU8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

type Output = Wrapping<FixedU8<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: &u8) -> Wrapping<FixedU8<Frac>>

Performs the * operation.

impl<Frac> Mul<Wrapping<FixedU16<Frac>>> for Wrapping<FixedU16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

type Output = Wrapping<FixedU16<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: Wrapping<FixedU16<Frac>>) -> Wrapping<FixedU16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

Performs the * operation.

impl<'a, Frac> Mul<Wrapping<FixedU16<Frac>>> for &'a Wrapping<FixedU16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

type Output = Wrapping<FixedU16<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: Wrapping<FixedU16<Frac>>) -> Wrapping<FixedU16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

Performs the * operation.

impl<'a, Frac> Mul<&'a Wrapping<FixedU16<Frac>>> for Wrapping<FixedU16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

type Output = Wrapping<FixedU16<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: &Wrapping<FixedU16<Frac>>) -> Wrapping<FixedU16<Frac>>

Performs the * operation.

impl<'a, 'b, Frac> Mul<&'a Wrapping<FixedU16<Frac>>> for &'b Wrapping<FixedU16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

type Output = Wrapping<FixedU16<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: &Wrapping<FixedU16<Frac>>) -> Wrapping<FixedU16<Frac>>

Performs the * operation.

impl<Frac> Mul<u16> for Wrapping<FixedU16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

type Output = Wrapping<FixedU16<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: u16) -> Wrapping<FixedU16<Frac>>

Performs the * operation.

impl<'a, Frac> Mul<u16> for &'a Wrapping<FixedU16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

type Output = Wrapping<FixedU16<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: u16) -> Wrapping<FixedU16<Frac>>

Performs the * operation.

impl<'a, Frac> Mul<&'a u16> for Wrapping<FixedU16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

type Output = Wrapping<FixedU16<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: &u16) -> Wrapping<FixedU16<Frac>>

Performs the * operation.

impl<'a, 'b, Frac> Mul<&'a u16> for &'b Wrapping<FixedU16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

type Output = Wrapping<FixedU16<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: &u16) -> Wrapping<FixedU16<Frac>>

Performs the * operation.

impl<Frac> Mul<Wrapping<FixedU32<Frac>>> for Wrapping<FixedU32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

type Output = Wrapping<FixedU32<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: Wrapping<FixedU32<Frac>>) -> Wrapping<FixedU32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

Performs the * operation.

impl<'a, Frac> Mul<Wrapping<FixedU32<Frac>>> for &'a Wrapping<FixedU32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

type Output = Wrapping<FixedU32<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: Wrapping<FixedU32<Frac>>) -> Wrapping<FixedU32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

Performs the * operation.

impl<'a, Frac> Mul<&'a Wrapping<FixedU32<Frac>>> for Wrapping<FixedU32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

type Output = Wrapping<FixedU32<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: &Wrapping<FixedU32<Frac>>) -> Wrapping<FixedU32<Frac>>

Performs the * operation.

impl<'a, 'b, Frac> Mul<&'a Wrapping<FixedU32<Frac>>> for &'b Wrapping<FixedU32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

type Output = Wrapping<FixedU32<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: &Wrapping<FixedU32<Frac>>) -> Wrapping<FixedU32<Frac>>

Performs the * operation.

impl<Frac> Mul<u32> for Wrapping<FixedU32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

type Output = Wrapping<FixedU32<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: u32) -> Wrapping<FixedU32<Frac>>

Performs the * operation.

impl<'a, Frac> Mul<u32> for &'a Wrapping<FixedU32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

type Output = Wrapping<FixedU32<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: u32) -> Wrapping<FixedU32<Frac>>

Performs the * operation.

impl<'a, Frac> Mul<&'a u32> for Wrapping<FixedU32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

type Output = Wrapping<FixedU32<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: &u32) -> Wrapping<FixedU32<Frac>>

Performs the * operation.

impl<'a, 'b, Frac> Mul<&'a u32> for &'b Wrapping<FixedU32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

type Output = Wrapping<FixedU32<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: &u32) -> Wrapping<FixedU32<Frac>>

Performs the * operation.

impl<Frac> Mul<Wrapping<FixedU64<Frac>>> for Wrapping<FixedU64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

type Output = Wrapping<FixedU64<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: Wrapping<FixedU64<Frac>>) -> Wrapping<FixedU64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

Performs the * operation.

impl<'a, Frac> Mul<Wrapping<FixedU64<Frac>>> for &'a Wrapping<FixedU64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

type Output = Wrapping<FixedU64<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: Wrapping<FixedU64<Frac>>) -> Wrapping<FixedU64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

Performs the * operation.

impl<'a, Frac> Mul<&'a Wrapping<FixedU64<Frac>>> for Wrapping<FixedU64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

type Output = Wrapping<FixedU64<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: &Wrapping<FixedU64<Frac>>) -> Wrapping<FixedU64<Frac>>

Performs the * operation.

impl<'a, 'b, Frac> Mul<&'a Wrapping<FixedU64<Frac>>> for &'b Wrapping<FixedU64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

type Output = Wrapping<FixedU64<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: &Wrapping<FixedU64<Frac>>) -> Wrapping<FixedU64<Frac>>

Performs the * operation.

impl<Frac> Mul<u64> for Wrapping<FixedU64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

type Output = Wrapping<FixedU64<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: u64) -> Wrapping<FixedU64<Frac>>

Performs the * operation.

impl<'a, Frac> Mul<u64> for &'a Wrapping<FixedU64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

type Output = Wrapping<FixedU64<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: u64) -> Wrapping<FixedU64<Frac>>

Performs the * operation.

impl<'a, Frac> Mul<&'a u64> for Wrapping<FixedU64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

type Output = Wrapping<FixedU64<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: &u64) -> Wrapping<FixedU64<Frac>>

Performs the * operation.

impl<'a, 'b, Frac> Mul<&'a u64> for &'b Wrapping<FixedU64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

type Output = Wrapping<FixedU64<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: &u64) -> Wrapping<FixedU64<Frac>>

Performs the * operation.

impl<Frac> Mul<Wrapping<FixedU128<Frac>>> for Wrapping<FixedU128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

type Output = Wrapping<FixedU128<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: Wrapping<FixedU128<Frac>>) -> Wrapping<FixedU128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

Performs the * operation.

impl<'a, Frac> Mul<Wrapping<FixedU128<Frac>>> for &'a Wrapping<FixedU128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

type Output = Wrapping<FixedU128<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: Wrapping<FixedU128<Frac>>) -> Wrapping<FixedU128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

Performs the * operation.

impl<'a, Frac> Mul<&'a Wrapping<FixedU128<Frac>>> for Wrapping<FixedU128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

type Output = Wrapping<FixedU128<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: &Wrapping<FixedU128<Frac>>) -> Wrapping<FixedU128<Frac>>

Performs the * operation.

impl<'a, 'b, Frac> Mul<&'a Wrapping<FixedU128<Frac>>> for &'b Wrapping<FixedU128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

type Output = Wrapping<FixedU128<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: &Wrapping<FixedU128<Frac>>) -> Wrapping<FixedU128<Frac>>

Performs the * operation.

impl<Frac> Mul<u128> for Wrapping<FixedU128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

type Output = Wrapping<FixedU128<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: u128) -> Wrapping<FixedU128<Frac>>

Performs the * operation.

impl<'a, Frac> Mul<u128> for &'a Wrapping<FixedU128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

type Output = Wrapping<FixedU128<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: u128) -> Wrapping<FixedU128<Frac>>

Performs the * operation.

impl<'a, Frac> Mul<&'a u128> for Wrapping<FixedU128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

type Output = Wrapping<FixedU128<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: &u128) -> Wrapping<FixedU128<Frac>>

Performs the * operation.

impl<'a, 'b, Frac> Mul<&'a u128> for &'b Wrapping<FixedU128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

type Output = Wrapping<FixedU128<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: &u128) -> Wrapping<FixedU128<Frac>>

Performs the * operation.

impl<Frac> Div<Wrapping<FixedI8<Frac>>> for Wrapping<FixedI8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

type Output = Wrapping<FixedI8<Frac>>

The resulting type after applying the / operator.

fn div(self, other: Wrapping<FixedI8<Frac>>) -> Wrapping<FixedI8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

Performs the / operation.

impl<'a, Frac> Div<Wrapping<FixedI8<Frac>>> for &'a Wrapping<FixedI8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

type Output = Wrapping<FixedI8<Frac>>

The resulting type after applying the / operator.

fn div(self, other: Wrapping<FixedI8<Frac>>) -> Wrapping<FixedI8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

Performs the / operation.

impl<'a, Frac> Div<&'a Wrapping<FixedI8<Frac>>> for Wrapping<FixedI8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

type Output = Wrapping<FixedI8<Frac>>

The resulting type after applying the / operator.

fn div(self, other: &Wrapping<FixedI8<Frac>>) -> Wrapping<FixedI8<Frac>>

Performs the / operation.

impl<'a, 'b, Frac> Div<&'a Wrapping<FixedI8<Frac>>> for &'b Wrapping<FixedI8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

type Output = Wrapping<FixedI8<Frac>>

The resulting type after applying the / operator.

fn div(self, other: &Wrapping<FixedI8<Frac>>) -> Wrapping<FixedI8<Frac>>

Performs the / operation.

impl<Frac> Div<i8> for Wrapping<FixedI8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

type Output = Wrapping<FixedI8<Frac>>

The resulting type after applying the / operator.

fn div(self, other: i8) -> Wrapping<FixedI8<Frac>>

Performs the / operation.

impl<'a, Frac> Div<i8> for &'a Wrapping<FixedI8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

type Output = Wrapping<FixedI8<Frac>>

The resulting type after applying the / operator.

fn div(self, other: i8) -> Wrapping<FixedI8<Frac>>

Performs the / operation.

impl<'a, Frac> Div<&'a i8> for Wrapping<FixedI8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

type Output = Wrapping<FixedI8<Frac>>

The resulting type after applying the / operator.

fn div(self, other: &i8) -> Wrapping<FixedI8<Frac>>

Performs the / operation.

impl<'a, 'b, Frac> Div<&'a i8> for &'b Wrapping<FixedI8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

type Output = Wrapping<FixedI8<Frac>>

The resulting type after applying the / operator.

fn div(self, other: &i8) -> Wrapping<FixedI8<Frac>>

Performs the / operation.

impl<Frac> Div<Wrapping<FixedI16<Frac>>> for Wrapping<FixedI16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

type Output = Wrapping<FixedI16<Frac>>

The resulting type after applying the / operator.

fn div(self, other: Wrapping<FixedI16<Frac>>) -> Wrapping<FixedI16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

Performs the / operation.

impl<'a, Frac> Div<Wrapping<FixedI16<Frac>>> for &'a Wrapping<FixedI16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

type Output = Wrapping<FixedI16<Frac>>

The resulting type after applying the / operator.

fn div(self, other: Wrapping<FixedI16<Frac>>) -> Wrapping<FixedI16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

Performs the / operation.

impl<'a, Frac> Div<&'a Wrapping<FixedI16<Frac>>> for Wrapping<FixedI16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

type Output = Wrapping<FixedI16<Frac>>

The resulting type after applying the / operator.

fn div(self, other: &Wrapping<FixedI16<Frac>>) -> Wrapping<FixedI16<Frac>>

Performs the / operation.

impl<'a, 'b, Frac> Div<&'a Wrapping<FixedI16<Frac>>> for &'b Wrapping<FixedI16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

type Output = Wrapping<FixedI16<Frac>>

The resulting type after applying the / operator.

fn div(self, other: &Wrapping<FixedI16<Frac>>) -> Wrapping<FixedI16<Frac>>

Performs the / operation.

impl<Frac> Div<i16> for Wrapping<FixedI16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

type Output = Wrapping<FixedI16<Frac>>

The resulting type after applying the / operator.

fn div(self, other: i16) -> Wrapping<FixedI16<Frac>>

Performs the / operation.

impl<'a, Frac> Div<i16> for &'a Wrapping<FixedI16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

type Output = Wrapping<FixedI16<Frac>>

The resulting type after applying the / operator.

fn div(self, other: i16) -> Wrapping<FixedI16<Frac>>

Performs the / operation.

impl<'a, Frac> Div<&'a i16> for Wrapping<FixedI16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

type Output = Wrapping<FixedI16<Frac>>

The resulting type after applying the / operator.

fn div(self, other: &i16) -> Wrapping<FixedI16<Frac>>

Performs the / operation.

impl<'a, 'b, Frac> Div<&'a i16> for &'b Wrapping<FixedI16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

type Output = Wrapping<FixedI16<Frac>>

The resulting type after applying the / operator.

fn div(self, other: &i16) -> Wrapping<FixedI16<Frac>>

Performs the / operation.

impl<Frac> Div<Wrapping<FixedI32<Frac>>> for Wrapping<FixedI32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

type Output = Wrapping<FixedI32<Frac>>

The resulting type after applying the / operator.

fn div(self, other: Wrapping<FixedI32<Frac>>) -> Wrapping<FixedI32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

Performs the / operation.

impl<'a, Frac> Div<Wrapping<FixedI32<Frac>>> for &'a Wrapping<FixedI32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

type Output = Wrapping<FixedI32<Frac>>

The resulting type after applying the / operator.

fn div(self, other: Wrapping<FixedI32<Frac>>) -> Wrapping<FixedI32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

Performs the / operation.

impl<'a, Frac> Div<&'a Wrapping<FixedI32<Frac>>> for Wrapping<FixedI32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

type Output = Wrapping<FixedI32<Frac>>

The resulting type after applying the / operator.

fn div(self, other: &Wrapping<FixedI32<Frac>>) -> Wrapping<FixedI32<Frac>>

Performs the / operation.

impl<'a, 'b, Frac> Div<&'a Wrapping<FixedI32<Frac>>> for &'b Wrapping<FixedI32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

type Output = Wrapping<FixedI32<Frac>>

The resulting type after applying the / operator.

fn div(self, other: &Wrapping<FixedI32<Frac>>) -> Wrapping<FixedI32<Frac>>

Performs the / operation.

impl<Frac> Div<i32> for Wrapping<FixedI32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

type Output = Wrapping<FixedI32<Frac>>

The resulting type after applying the / operator.

fn div(self, other: i32) -> Wrapping<FixedI32<Frac>>

Performs the / operation.

impl<'a, Frac> Div<i32> for &'a Wrapping<FixedI32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

type Output = Wrapping<FixedI32<Frac>>

The resulting type after applying the / operator.

fn div(self, other: i32) -> Wrapping<FixedI32<Frac>>

Performs the / operation.

impl<'a, Frac> Div<&'a i32> for Wrapping<FixedI32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

type Output = Wrapping<FixedI32<Frac>>

The resulting type after applying the / operator.

fn div(self, other: &i32) -> Wrapping<FixedI32<Frac>>

Performs the / operation.

impl<'a, 'b, Frac> Div<&'a i32> for &'b Wrapping<FixedI32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

type Output = Wrapping<FixedI32<Frac>>

The resulting type after applying the / operator.

fn div(self, other: &i32) -> Wrapping<FixedI32<Frac>>

Performs the / operation.

impl<Frac> Div<Wrapping<FixedI64<Frac>>> for Wrapping<FixedI64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

type Output = Wrapping<FixedI64<Frac>>

The resulting type after applying the / operator.

fn div(self, other: Wrapping<FixedI64<Frac>>) -> Wrapping<FixedI64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

Performs the / operation.

impl<'a, Frac> Div<Wrapping<FixedI64<Frac>>> for &'a Wrapping<FixedI64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

type Output = Wrapping<FixedI64<Frac>>

The resulting type after applying the / operator.

fn div(self, other: Wrapping<FixedI64<Frac>>) -> Wrapping<FixedI64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

Performs the / operation.

impl<'a, Frac> Div<&'a Wrapping<FixedI64<Frac>>> for Wrapping<FixedI64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

type Output = Wrapping<FixedI64<Frac>>

The resulting type after applying the / operator.

fn div(self, other: &Wrapping<FixedI64<Frac>>) -> Wrapping<FixedI64<Frac>>

Performs the / operation.

impl<'a, 'b, Frac> Div<&'a Wrapping<FixedI64<Frac>>> for &'b Wrapping<FixedI64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

type Output = Wrapping<FixedI64<Frac>>

The resulting type after applying the / operator.

fn div(self, other: &Wrapping<FixedI64<Frac>>) -> Wrapping<FixedI64<Frac>>

Performs the / operation.

impl<Frac> Div<i64> for Wrapping<FixedI64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

type Output = Wrapping<FixedI64<Frac>>

The resulting type after applying the / operator.

fn div(self, other: i64) -> Wrapping<FixedI64<Frac>>

Performs the / operation.

impl<'a, Frac> Div<i64> for &'a Wrapping<FixedI64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

type Output = Wrapping<FixedI64<Frac>>

The resulting type after applying the / operator.

fn div(self, other: i64) -> Wrapping<FixedI64<Frac>>

Performs the / operation.

impl<'a, Frac> Div<&'a i64> for Wrapping<FixedI64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

type Output = Wrapping<FixedI64<Frac>>

The resulting type after applying the / operator.

fn div(self, other: &i64) -> Wrapping<FixedI64<Frac>>

Performs the / operation.

impl<'a, 'b, Frac> Div<&'a i64> for &'b Wrapping<FixedI64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

type Output = Wrapping<FixedI64<Frac>>

The resulting type after applying the / operator.

fn div(self, other: &i64) -> Wrapping<FixedI64<Frac>>

Performs the / operation.

impl<Frac> Div<Wrapping<FixedI128<Frac>>> for Wrapping<FixedI128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

type Output = Wrapping<FixedI128<Frac>>

The resulting type after applying the / operator.

fn div(self, other: Wrapping<FixedI128<Frac>>) -> Wrapping<FixedI128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

Performs the / operation.

impl<'a, Frac> Div<Wrapping<FixedI128<Frac>>> for &'a Wrapping<FixedI128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

type Output = Wrapping<FixedI128<Frac>>

The resulting type after applying the / operator.

fn div(self, other: Wrapping<FixedI128<Frac>>) -> Wrapping<FixedI128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

Performs the / operation.

impl<'a, Frac> Div<&'a Wrapping<FixedI128<Frac>>> for Wrapping<FixedI128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

type Output = Wrapping<FixedI128<Frac>>

The resulting type after applying the / operator.

fn div(self, other: &Wrapping<FixedI128<Frac>>) -> Wrapping<FixedI128<Frac>>

Performs the / operation.

impl<'a, 'b, Frac> Div<&'a Wrapping<FixedI128<Frac>>> for &'b Wrapping<FixedI128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

type Output = Wrapping<FixedI128<Frac>>

The resulting type after applying the / operator.

fn div(self, other: &Wrapping<FixedI128<Frac>>) -> Wrapping<FixedI128<Frac>>

Performs the / operation.

impl<Frac> Div<i128> for Wrapping<FixedI128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

type Output = Wrapping<FixedI128<Frac>>

The resulting type after applying the / operator.

fn div(self, other: i128) -> Wrapping<FixedI128<Frac>>

Performs the / operation.

impl<'a, Frac> Div<i128> for &'a Wrapping<FixedI128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

type Output = Wrapping<FixedI128<Frac>>

The resulting type after applying the / operator.

fn div(self, other: i128) -> Wrapping<FixedI128<Frac>>

Performs the / operation.

impl<'a, Frac> Div<&'a i128> for Wrapping<FixedI128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

type Output = Wrapping<FixedI128<Frac>>

The resulting type after applying the / operator.

fn div(self, other: &i128) -> Wrapping<FixedI128<Frac>>

Performs the / operation.

impl<'a, 'b, Frac> Div<&'a i128> for &'b Wrapping<FixedI128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

type Output = Wrapping<FixedI128<Frac>>

The resulting type after applying the / operator.

fn div(self, other: &i128) -> Wrapping<FixedI128<Frac>>

Performs the / operation.

impl<Frac> Div<Wrapping<FixedU8<Frac>>> for Wrapping<FixedU8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

type Output = Wrapping<FixedU8<Frac>>

The resulting type after applying the / operator.

fn div(self, other: Wrapping<FixedU8<Frac>>) -> Wrapping<FixedU8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

Performs the / operation.

impl<'a, Frac> Div<Wrapping<FixedU8<Frac>>> for &'a Wrapping<FixedU8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

type Output = Wrapping<FixedU8<Frac>>

The resulting type after applying the / operator.

fn div(self, other: Wrapping<FixedU8<Frac>>) -> Wrapping<FixedU8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

Performs the / operation.

impl<'a, Frac> Div<&'a Wrapping<FixedU8<Frac>>> for Wrapping<FixedU8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

type Output = Wrapping<FixedU8<Frac>>

The resulting type after applying the / operator.

fn div(self, other: &Wrapping<FixedU8<Frac>>) -> Wrapping<FixedU8<Frac>>

Performs the / operation.

impl<'a, 'b, Frac> Div<&'a Wrapping<FixedU8<Frac>>> for &'b Wrapping<FixedU8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

type Output = Wrapping<FixedU8<Frac>>

The resulting type after applying the / operator.

fn div(self, other: &Wrapping<FixedU8<Frac>>) -> Wrapping<FixedU8<Frac>>

Performs the / operation.

impl<Frac> Div<u8> for Wrapping<FixedU8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

type Output = Wrapping<FixedU8<Frac>>

The resulting type after applying the / operator.

fn div(self, other: u8) -> Wrapping<FixedU8<Frac>>

Performs the / operation.

impl<'a, Frac> Div<u8> for &'a Wrapping<FixedU8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

type Output = Wrapping<FixedU8<Frac>>

The resulting type after applying the / operator.

fn div(self, other: u8) -> Wrapping<FixedU8<Frac>>

Performs the / operation.

impl<'a, Frac> Div<&'a u8> for Wrapping<FixedU8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

type Output = Wrapping<FixedU8<Frac>>

The resulting type after applying the / operator.

fn div(self, other: &u8) -> Wrapping<FixedU8<Frac>>

Performs the / operation.

impl<'a, 'b, Frac> Div<&'a u8> for &'b Wrapping<FixedU8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

type Output = Wrapping<FixedU8<Frac>>

The resulting type after applying the / operator.

fn div(self, other: &u8) -> Wrapping<FixedU8<Frac>>

Performs the / operation.

impl<Frac> Div<Wrapping<FixedU16<Frac>>> for Wrapping<FixedU16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

type Output = Wrapping<FixedU16<Frac>>

The resulting type after applying the / operator.

fn div(self, other: Wrapping<FixedU16<Frac>>) -> Wrapping<FixedU16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

Performs the / operation.

impl<'a, Frac> Div<Wrapping<FixedU16<Frac>>> for &'a Wrapping<FixedU16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

type Output = Wrapping<FixedU16<Frac>>

The resulting type after applying the / operator.

fn div(self, other: Wrapping<FixedU16<Frac>>) -> Wrapping<FixedU16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

Performs the / operation.

impl<'a, Frac> Div<&'a Wrapping<FixedU16<Frac>>> for Wrapping<FixedU16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

type Output = Wrapping<FixedU16<Frac>>

The resulting type after applying the / operator.

fn div(self, other: &Wrapping<FixedU16<Frac>>) -> Wrapping<FixedU16<Frac>>

Performs the / operation.

impl<'a, 'b, Frac> Div<&'a Wrapping<FixedU16<Frac>>> for &'b Wrapping<FixedU16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

type Output = Wrapping<FixedU16<Frac>>

The resulting type after applying the / operator.

fn div(self, other: &Wrapping<FixedU16<Frac>>) -> Wrapping<FixedU16<Frac>>

Performs the / operation.

impl<Frac> Div<u16> for Wrapping<FixedU16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

type Output = Wrapping<FixedU16<Frac>>

The resulting type after applying the / operator.

fn div(self, other: u16) -> Wrapping<FixedU16<Frac>>

Performs the / operation.

impl<'a, Frac> Div<u16> for &'a Wrapping<FixedU16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

type Output = Wrapping<FixedU16<Frac>>

The resulting type after applying the / operator.

fn div(self, other: u16) -> Wrapping<FixedU16<Frac>>

Performs the / operation.

impl<'a, Frac> Div<&'a u16> for Wrapping<FixedU16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

type Output = Wrapping<FixedU16<Frac>>

The resulting type after applying the / operator.

fn div(self, other: &u16) -> Wrapping<FixedU16<Frac>>

Performs the / operation.

impl<'a, 'b, Frac> Div<&'a u16> for &'b Wrapping<FixedU16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

type Output = Wrapping<FixedU16<Frac>>

The resulting type after applying the / operator.

fn div(self, other: &u16) -> Wrapping<FixedU16<Frac>>

Performs the / operation.

impl<Frac> Div<Wrapping<FixedU32<Frac>>> for Wrapping<FixedU32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

type Output = Wrapping<FixedU32<Frac>>

The resulting type after applying the / operator.

fn div(self, other: Wrapping<FixedU32<Frac>>) -> Wrapping<FixedU32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

Performs the / operation.

impl<'a, Frac> Div<Wrapping<FixedU32<Frac>>> for &'a Wrapping<FixedU32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

type Output = Wrapping<FixedU32<Frac>>

The resulting type after applying the / operator.

fn div(self, other: Wrapping<FixedU32<Frac>>) -> Wrapping<FixedU32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

Performs the / operation.

impl<'a, Frac> Div<&'a Wrapping<FixedU32<Frac>>> for Wrapping<FixedU32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

type Output = Wrapping<FixedU32<Frac>>

The resulting type after applying the / operator.

fn div(self, other: &Wrapping<FixedU32<Frac>>) -> Wrapping<FixedU32<Frac>>

Performs the / operation.

impl<'a, 'b, Frac> Div<&'a Wrapping<FixedU32<Frac>>> for &'b Wrapping<FixedU32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

type Output = Wrapping<FixedU32<Frac>>

The resulting type after applying the / operator.

fn div(self, other: &Wrapping<FixedU32<Frac>>) -> Wrapping<FixedU32<Frac>>

Performs the / operation.

impl<Frac> Div<u32> for Wrapping<FixedU32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

type Output = Wrapping<FixedU32<Frac>>

The resulting type after applying the / operator.

fn div(self, other: u32) -> Wrapping<FixedU32<Frac>>

Performs the / operation.

impl<'a, Frac> Div<u32> for &'a Wrapping<FixedU32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

type Output = Wrapping<FixedU32<Frac>>

The resulting type after applying the / operator.

fn div(self, other: u32) -> Wrapping<FixedU32<Frac>>

Performs the / operation.

impl<'a, Frac> Div<&'a u32> for Wrapping<FixedU32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

type Output = Wrapping<FixedU32<Frac>>

The resulting type after applying the / operator.

fn div(self, other: &u32) -> Wrapping<FixedU32<Frac>>

Performs the / operation.

impl<'a, 'b, Frac> Div<&'a u32> for &'b Wrapping<FixedU32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

type Output = Wrapping<FixedU32<Frac>>

The resulting type after applying the / operator.

fn div(self, other: &u32) -> Wrapping<FixedU32<Frac>>

Performs the / operation.

impl<Frac> Div<Wrapping<FixedU64<Frac>>> for Wrapping<FixedU64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

type Output = Wrapping<FixedU64<Frac>>

The resulting type after applying the / operator.

fn div(self, other: Wrapping<FixedU64<Frac>>) -> Wrapping<FixedU64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

Performs the / operation.

impl<'a, Frac> Div<Wrapping<FixedU64<Frac>>> for &'a Wrapping<FixedU64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

type Output = Wrapping<FixedU64<Frac>>

The resulting type after applying the / operator.

fn div(self, other: Wrapping<FixedU64<Frac>>) -> Wrapping<FixedU64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

Performs the / operation.

impl<'a, Frac> Div<&'a Wrapping<FixedU64<Frac>>> for Wrapping<FixedU64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

type Output = Wrapping<FixedU64<Frac>>

The resulting type after applying the / operator.

fn div(self, other: &Wrapping<FixedU64<Frac>>) -> Wrapping<FixedU64<Frac>>

Performs the / operation.

impl<'a, 'b, Frac> Div<&'a Wrapping<FixedU64<Frac>>> for &'b Wrapping<FixedU64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

type Output = Wrapping<FixedU64<Frac>>

The resulting type after applying the / operator.

fn div(self, other: &Wrapping<FixedU64<Frac>>) -> Wrapping<FixedU64<Frac>>

Performs the / operation.

impl<Frac> Div<u64> for Wrapping<FixedU64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

type Output = Wrapping<FixedU64<Frac>>

The resulting type after applying the / operator.

fn div(self, other: u64) -> Wrapping<FixedU64<Frac>>

Performs the / operation.

impl<'a, Frac> Div<u64> for &'a Wrapping<FixedU64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

type Output = Wrapping<FixedU64<Frac>>

The resulting type after applying the / operator.

fn div(self, other: u64) -> Wrapping<FixedU64<Frac>>

Performs the / operation.

impl<'a, Frac> Div<&'a u64> for Wrapping<FixedU64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

type Output = Wrapping<FixedU64<Frac>>

The resulting type after applying the / operator.

fn div(self, other: &u64) -> Wrapping<FixedU64<Frac>>

Performs the / operation.

impl<'a, 'b, Frac> Div<&'a u64> for &'b Wrapping<FixedU64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

type Output = Wrapping<FixedU64<Frac>>

The resulting type after applying the / operator.

fn div(self, other: &u64) -> Wrapping<FixedU64<Frac>>

Performs the / operation.

impl<Frac> Div<Wrapping<FixedU128<Frac>>> for Wrapping<FixedU128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

type Output = Wrapping<FixedU128<Frac>>

The resulting type after applying the / operator.

fn div(self, other: Wrapping<FixedU128<Frac>>) -> Wrapping<FixedU128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

Performs the / operation.

impl<'a, Frac> Div<Wrapping<FixedU128<Frac>>> for &'a Wrapping<FixedU128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

type Output = Wrapping<FixedU128<Frac>>

The resulting type after applying the / operator.

fn div(self, other: Wrapping<FixedU128<Frac>>) -> Wrapping<FixedU128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

Performs the / operation.

impl<'a, Frac> Div<&'a Wrapping<FixedU128<Frac>>> for Wrapping<FixedU128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

type Output = Wrapping<FixedU128<Frac>>

The resulting type after applying the / operator.

fn div(self, other: &Wrapping<FixedU128<Frac>>) -> Wrapping<FixedU128<Frac>>

Performs the / operation.

impl<'a, 'b, Frac> Div<&'a Wrapping<FixedU128<Frac>>> for &'b Wrapping<FixedU128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

type Output = Wrapping<FixedU128<Frac>>

The resulting type after applying the / operator.

fn div(self, other: &Wrapping<FixedU128<Frac>>) -> Wrapping<FixedU128<Frac>>

Performs the / operation.

impl<Frac> Div<u128> for Wrapping<FixedU128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

type Output = Wrapping<FixedU128<Frac>>

The resulting type after applying the / operator.

fn div(self, other: u128) -> Wrapping<FixedU128<Frac>>

Performs the / operation.

impl<'a, Frac> Div<u128> for &'a Wrapping<FixedU128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

type Output = Wrapping<FixedU128<Frac>>

The resulting type after applying the / operator.

fn div(self, other: u128) -> Wrapping<FixedU128<Frac>>

Performs the / operation.

impl<'a, Frac> Div<&'a u128> for Wrapping<FixedU128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

type Output = Wrapping<FixedU128<Frac>>

The resulting type after applying the / operator.

fn div(self, other: &u128) -> Wrapping<FixedU128<Frac>>

Performs the / operation.

impl<'a, 'b, Frac> Div<&'a u128> for &'b Wrapping<FixedU128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

type Output = Wrapping<FixedU128<Frac>>

The resulting type after applying the / operator.

fn div(self, other: &u128) -> Wrapping<FixedU128<Frac>>

Performs the / operation.

impl<Frac> Rem<i8> for Wrapping<FixedI8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

type Output = Wrapping<FixedI8<Frac>>

The resulting type after applying the % operator.

fn rem(self, other: i8) -> Wrapping<FixedI8<Frac>>

Performs the % operation.

impl<'a, Frac> Rem<i8> for &'a Wrapping<FixedI8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

type Output = Wrapping<FixedI8<Frac>>

The resulting type after applying the % operator.

fn rem(self, other: i8) -> Wrapping<FixedI8<Frac>>

Performs the % operation.

impl<'a, Frac> Rem<&'a i8> for Wrapping<FixedI8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

type Output = Wrapping<FixedI8<Frac>>

The resulting type after applying the % operator.

fn rem(self, other: &i8) -> Wrapping<FixedI8<Frac>>

Performs the % operation.

impl<'a, 'b, Frac> Rem<&'a i8> for &'b Wrapping<FixedI8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

type Output = Wrapping<FixedI8<Frac>>

The resulting type after applying the % operator.

fn rem(self, other: &i8) -> Wrapping<FixedI8<Frac>>

Performs the % operation.

impl<Frac> Rem<i16> for Wrapping<FixedI16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

type Output = Wrapping<FixedI16<Frac>>

The resulting type after applying the % operator.

fn rem(self, other: i16) -> Wrapping<FixedI16<Frac>>

Performs the % operation.

impl<'a, Frac> Rem<i16> for &'a Wrapping<FixedI16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

type Output = Wrapping<FixedI16<Frac>>

The resulting type after applying the % operator.

fn rem(self, other: i16) -> Wrapping<FixedI16<Frac>>

Performs the % operation.

impl<'a, Frac> Rem<&'a i16> for Wrapping<FixedI16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

type Output = Wrapping<FixedI16<Frac>>

The resulting type after applying the % operator.

fn rem(self, other: &i16) -> Wrapping<FixedI16<Frac>>

Performs the % operation.

impl<'a, 'b, Frac> Rem<&'a i16> for &'b Wrapping<FixedI16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

type Output = Wrapping<FixedI16<Frac>>

The resulting type after applying the % operator.

fn rem(self, other: &i16) -> Wrapping<FixedI16<Frac>>

Performs the % operation.

impl<Frac> Rem<i32> for Wrapping<FixedI32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

type Output = Wrapping<FixedI32<Frac>>

The resulting type after applying the % operator.

fn rem(self, other: i32) -> Wrapping<FixedI32<Frac>>

Performs the % operation.

impl<'a, Frac> Rem<i32> for &'a Wrapping<FixedI32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

type Output = Wrapping<FixedI32<Frac>>

The resulting type after applying the % operator.

fn rem(self, other: i32) -> Wrapping<FixedI32<Frac>>

Performs the % operation.

impl<'a, Frac> Rem<&'a i32> for Wrapping<FixedI32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

type Output = Wrapping<FixedI32<Frac>>

The resulting type after applying the % operator.

fn rem(self, other: &i32) -> Wrapping<FixedI32<Frac>>

Performs the % operation.

impl<'a, 'b, Frac> Rem<&'a i32> for &'b Wrapping<FixedI32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

type Output = Wrapping<FixedI32<Frac>>

The resulting type after applying the % operator.

fn rem(self, other: &i32) -> Wrapping<FixedI32<Frac>>

Performs the % operation.

impl<Frac> Rem<i64> for Wrapping<FixedI64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

type Output = Wrapping<FixedI64<Frac>>

The resulting type after applying the % operator.

fn rem(self, other: i64) -> Wrapping<FixedI64<Frac>>

Performs the % operation.

impl<'a, Frac> Rem<i64> for &'a Wrapping<FixedI64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

type Output = Wrapping<FixedI64<Frac>>

The resulting type after applying the % operator.

fn rem(self, other: i64) -> Wrapping<FixedI64<Frac>>

Performs the % operation.

impl<'a, Frac> Rem<&'a i64> for Wrapping<FixedI64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

type Output = Wrapping<FixedI64<Frac>>

The resulting type after applying the % operator.

fn rem(self, other: &i64) -> Wrapping<FixedI64<Frac>>

Performs the % operation.

impl<'a, 'b, Frac> Rem<&'a i64> for &'b Wrapping<FixedI64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

type Output = Wrapping<FixedI64<Frac>>

The resulting type after applying the % operator.

fn rem(self, other: &i64) -> Wrapping<FixedI64<Frac>>

Performs the % operation.

impl<Frac> Rem<i128> for Wrapping<FixedI128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

type Output = Wrapping<FixedI128<Frac>>

The resulting type after applying the % operator.

fn rem(self, other: i128) -> Wrapping<FixedI128<Frac>>

Performs the % operation.

impl<'a, Frac> Rem<i128> for &'a Wrapping<FixedI128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

type Output = Wrapping<FixedI128<Frac>>

The resulting type after applying the % operator.

fn rem(self, other: i128) -> Wrapping<FixedI128<Frac>>

Performs the % operation.

impl<'a, Frac> Rem<&'a i128> for Wrapping<FixedI128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

type Output = Wrapping<FixedI128<Frac>>

The resulting type after applying the % operator.

fn rem(self, other: &i128) -> Wrapping<FixedI128<Frac>>

Performs the % operation.

impl<'a, 'b, Frac> Rem<&'a i128> for &'b Wrapping<FixedI128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

type Output = Wrapping<FixedI128<Frac>>

The resulting type after applying the % operator.

fn rem(self, other: &i128) -> Wrapping<FixedI128<Frac>>

Performs the % operation.

impl<Frac> Rem<u8> for Wrapping<FixedU8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

type Output = Wrapping<FixedU8<Frac>>

The resulting type after applying the % operator.

fn rem(self, other: u8) -> Wrapping<FixedU8<Frac>>

Performs the % operation.

impl<'a, Frac> Rem<u8> for &'a Wrapping<FixedU8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

type Output = Wrapping<FixedU8<Frac>>

The resulting type after applying the % operator.

fn rem(self, other: u8) -> Wrapping<FixedU8<Frac>>

Performs the % operation.

impl<'a, Frac> Rem<&'a u8> for Wrapping<FixedU8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

type Output = Wrapping<FixedU8<Frac>>

The resulting type after applying the % operator.

fn rem(self, other: &u8) -> Wrapping<FixedU8<Frac>>

Performs the % operation.

impl<'a, 'b, Frac> Rem<&'a u8> for &'b Wrapping<FixedU8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

type Output = Wrapping<FixedU8<Frac>>

The resulting type after applying the % operator.

fn rem(self, other: &u8) -> Wrapping<FixedU8<Frac>>

Performs the % operation.

impl<Frac> Rem<u16> for Wrapping<FixedU16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

type Output = Wrapping<FixedU16<Frac>>

The resulting type after applying the % operator.

fn rem(self, other: u16) -> Wrapping<FixedU16<Frac>>

Performs the % operation.

impl<'a, Frac> Rem<u16> for &'a Wrapping<FixedU16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

type Output = Wrapping<FixedU16<Frac>>

The resulting type after applying the % operator.

fn rem(self, other: u16) -> Wrapping<FixedU16<Frac>>

Performs the % operation.

impl<'a, Frac> Rem<&'a u16> for Wrapping<FixedU16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

type Output = Wrapping<FixedU16<Frac>>

The resulting type after applying the % operator.

fn rem(self, other: &u16) -> Wrapping<FixedU16<Frac>>

Performs the % operation.

impl<'a, 'b, Frac> Rem<&'a u16> for &'b Wrapping<FixedU16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

type Output = Wrapping<FixedU16<Frac>>

The resulting type after applying the % operator.

fn rem(self, other: &u16) -> Wrapping<FixedU16<Frac>>

Performs the % operation.

impl<Frac> Rem<u32> for Wrapping<FixedU32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

type Output = Wrapping<FixedU32<Frac>>

The resulting type after applying the % operator.

fn rem(self, other: u32) -> Wrapping<FixedU32<Frac>>

Performs the % operation.

impl<'a, Frac> Rem<u32> for &'a Wrapping<FixedU32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

type Output = Wrapping<FixedU32<Frac>>

The resulting type after applying the % operator.

fn rem(self, other: u32) -> Wrapping<FixedU32<Frac>>

Performs the % operation.

impl<'a, Frac> Rem<&'a u32> for Wrapping<FixedU32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

type Output = Wrapping<FixedU32<Frac>>

The resulting type after applying the % operator.

fn rem(self, other: &u32) -> Wrapping<FixedU32<Frac>>

Performs the % operation.

impl<'a, 'b, Frac> Rem<&'a u32> for &'b Wrapping<FixedU32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

type Output = Wrapping<FixedU32<Frac>>

The resulting type after applying the % operator.

fn rem(self, other: &u32) -> Wrapping<FixedU32<Frac>>

Performs the % operation.

impl<Frac> Rem<u64> for Wrapping<FixedU64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

type Output = Wrapping<FixedU64<Frac>>

The resulting type after applying the % operator.

fn rem(self, other: u64) -> Wrapping<FixedU64<Frac>>

Performs the % operation.

impl<'a, Frac> Rem<u64> for &'a Wrapping<FixedU64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

type Output = Wrapping<FixedU64<Frac>>

The resulting type after applying the % operator.

fn rem(self, other: u64) -> Wrapping<FixedU64<Frac>>

Performs the % operation.

impl<'a, Frac> Rem<&'a u64> for Wrapping<FixedU64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

type Output = Wrapping<FixedU64<Frac>>

The resulting type after applying the % operator.

fn rem(self, other: &u64) -> Wrapping<FixedU64<Frac>>

Performs the % operation.

impl<'a, 'b, Frac> Rem<&'a u64> for &'b Wrapping<FixedU64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

type Output = Wrapping<FixedU64<Frac>>

The resulting type after applying the % operator.

fn rem(self, other: &u64) -> Wrapping<FixedU64<Frac>>

Performs the % operation.

impl<Frac> Rem<u128> for Wrapping<FixedU128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

type Output = Wrapping<FixedU128<Frac>>

The resulting type after applying the % operator.

fn rem(self, other: u128) -> Wrapping<FixedU128<Frac>>

Performs the % operation.

impl<'a, Frac> Rem<u128> for &'a Wrapping<FixedU128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

type Output = Wrapping<FixedU128<Frac>>

The resulting type after applying the % operator.

fn rem(self, other: u128) -> Wrapping<FixedU128<Frac>>

Performs the % operation.

impl<'a, Frac> Rem<&'a u128> for Wrapping<FixedU128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

type Output = Wrapping<FixedU128<Frac>>

The resulting type after applying the % operator.

fn rem(self, other: &u128) -> Wrapping<FixedU128<Frac>>

Performs the % operation.

impl<'a, 'b, Frac> Rem<&'a u128> for &'b Wrapping<FixedU128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

type Output = Wrapping<FixedU128<Frac>>

The resulting type after applying the % operator.

fn rem(self, other: &u128) -> Wrapping<FixedU128<Frac>>

Performs the % operation.

impl<Frac> Neg for Wrapping<FixedI8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

type Output = Wrapping<FixedI8<Frac>>

The resulting type after applying the - operator.

fn neg(self) -> Wrapping<FixedI8<Frac>>

Performs the unary - operation.

impl<'a, Frac> Neg for &'a Wrapping<FixedI8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

type Output = Wrapping<FixedI8<Frac>>

The resulting type after applying the - operator.

fn neg(self) -> Wrapping<FixedI8<Frac>>

Performs the unary - operation.

impl<Frac> Neg for Wrapping<FixedI16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

type Output = Wrapping<FixedI16<Frac>>

The resulting type after applying the - operator.

fn neg(self) -> Wrapping<FixedI16<Frac>>

Performs the unary - operation.

impl<'a, Frac> Neg for &'a Wrapping<FixedI16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

type Output = Wrapping<FixedI16<Frac>>

The resulting type after applying the - operator.

fn neg(self) -> Wrapping<FixedI16<Frac>>

Performs the unary - operation.

impl<Frac> Neg for Wrapping<FixedI32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

type Output = Wrapping<FixedI32<Frac>>

The resulting type after applying the - operator.

fn neg(self) -> Wrapping<FixedI32<Frac>>

Performs the unary - operation.

impl<'a, Frac> Neg for &'a Wrapping<FixedI32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

type Output = Wrapping<FixedI32<Frac>>

The resulting type after applying the - operator.

fn neg(self) -> Wrapping<FixedI32<Frac>>

Performs the unary - operation.

impl<Frac> Neg for Wrapping<FixedI64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

type Output = Wrapping<FixedI64<Frac>>

The resulting type after applying the - operator.

fn neg(self) -> Wrapping<FixedI64<Frac>>

Performs the unary - operation.

impl<'a, Frac> Neg for &'a Wrapping<FixedI64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

type Output = Wrapping<FixedI64<Frac>>

The resulting type after applying the - operator.

fn neg(self) -> Wrapping<FixedI64<Frac>>

Performs the unary - operation.

impl<Frac> Neg for Wrapping<FixedI128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

type Output = Wrapping<FixedI128<Frac>>

The resulting type after applying the - operator.

fn neg(self) -> Wrapping<FixedI128<Frac>>

Performs the unary - operation.

impl<'a, Frac> Neg for &'a Wrapping<FixedI128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

type Output = Wrapping<FixedI128<Frac>>

The resulting type after applying the - operator.

fn neg(self) -> Wrapping<FixedI128<Frac>>

Performs the unary - operation.

impl<Frac> Neg for Wrapping<FixedU8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

type Output = Wrapping<FixedU8<Frac>>

The resulting type after applying the - operator.

fn neg(self) -> Wrapping<FixedU8<Frac>>

Performs the unary - operation.

impl<'a, Frac> Neg for &'a Wrapping<FixedU8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

type Output = Wrapping<FixedU8<Frac>>

The resulting type after applying the - operator.

fn neg(self) -> Wrapping<FixedU8<Frac>>

Performs the unary - operation.

impl<Frac> Neg for Wrapping<FixedU16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

type Output = Wrapping<FixedU16<Frac>>

The resulting type after applying the - operator.

fn neg(self) -> Wrapping<FixedU16<Frac>>

Performs the unary - operation.

impl<'a, Frac> Neg for &'a Wrapping<FixedU16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

type Output = Wrapping<FixedU16<Frac>>

The resulting type after applying the - operator.

fn neg(self) -> Wrapping<FixedU16<Frac>>

Performs the unary - operation.

impl<Frac> Neg for Wrapping<FixedU32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

type Output = Wrapping<FixedU32<Frac>>

The resulting type after applying the - operator.

fn neg(self) -> Wrapping<FixedU32<Frac>>

Performs the unary - operation.

impl<'a, Frac> Neg for &'a Wrapping<FixedU32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

type Output = Wrapping<FixedU32<Frac>>

The resulting type after applying the - operator.

fn neg(self) -> Wrapping<FixedU32<Frac>>

Performs the unary - operation.

impl<Frac> Neg for Wrapping<FixedU64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

type Output = Wrapping<FixedU64<Frac>>

The resulting type after applying the - operator.

fn neg(self) -> Wrapping<FixedU64<Frac>>

Performs the unary - operation.

impl<'a, Frac> Neg for &'a Wrapping<FixedU64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

type Output = Wrapping<FixedU64<Frac>>

The resulting type after applying the - operator.

fn neg(self) -> Wrapping<FixedU64<Frac>>

Performs the unary - operation.

impl<Frac> Neg for Wrapping<FixedU128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

type Output = Wrapping<FixedU128<Frac>>

The resulting type after applying the - operator.

fn neg(self) -> Wrapping<FixedU128<Frac>>

Performs the unary - operation.

impl<'a, Frac> Neg for &'a Wrapping<FixedU128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

type Output = Wrapping<FixedU128<Frac>>

The resulting type after applying the - operator.

fn neg(self) -> Wrapping<FixedU128<Frac>>

Performs the unary - operation.

impl<Frac> AddAssign<Wrapping<FixedI8<Frac>>> for Wrapping<FixedI8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

fn add_assign(&mut self, other: Wrapping<FixedI8<Frac>>)

Performs the += operation.

impl<'a, Frac> AddAssign<&'a Wrapping<FixedI8<Frac>>> for Wrapping<FixedI8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

fn add_assign(&mut self, other: &Wrapping<FixedI8<Frac>>)

Performs the += operation.

impl<Frac> AddAssign<Wrapping<FixedI16<Frac>>> for Wrapping<FixedI16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

fn add_assign(&mut self, other: Wrapping<FixedI16<Frac>>)

Performs the += operation.

impl<'a, Frac> AddAssign<&'a Wrapping<FixedI16<Frac>>> for Wrapping<FixedI16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

fn add_assign(&mut self, other: &Wrapping<FixedI16<Frac>>)

Performs the += operation.

impl<Frac> AddAssign<Wrapping<FixedI32<Frac>>> for Wrapping<FixedI32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

fn add_assign(&mut self, other: Wrapping<FixedI32<Frac>>)

Performs the += operation.

impl<'a, Frac> AddAssign<&'a Wrapping<FixedI32<Frac>>> for Wrapping<FixedI32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

fn add_assign(&mut self, other: &Wrapping<FixedI32<Frac>>)

Performs the += operation.

impl<Frac> AddAssign<Wrapping<FixedI64<Frac>>> for Wrapping<FixedI64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

fn add_assign(&mut self, other: Wrapping<FixedI64<Frac>>)

Performs the += operation.

impl<'a, Frac> AddAssign<&'a Wrapping<FixedI64<Frac>>> for Wrapping<FixedI64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

fn add_assign(&mut self, other: &Wrapping<FixedI64<Frac>>)

Performs the += operation.

impl<Frac> AddAssign<Wrapping<FixedI128<Frac>>> for Wrapping<FixedI128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

fn add_assign(&mut self, other: Wrapping<FixedI128<Frac>>)

Performs the += operation.

impl<'a, Frac> AddAssign<&'a Wrapping<FixedI128<Frac>>> for Wrapping<FixedI128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

fn add_assign(&mut self, other: &Wrapping<FixedI128<Frac>>)

Performs the += operation.

impl<Frac> AddAssign<Wrapping<FixedU8<Frac>>> for Wrapping<FixedU8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

fn add_assign(&mut self, other: Wrapping<FixedU8<Frac>>)

Performs the += operation.

impl<'a, Frac> AddAssign<&'a Wrapping<FixedU8<Frac>>> for Wrapping<FixedU8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

fn add_assign(&mut self, other: &Wrapping<FixedU8<Frac>>)

Performs the += operation.

impl<Frac> AddAssign<Wrapping<FixedU16<Frac>>> for Wrapping<FixedU16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

fn add_assign(&mut self, other: Wrapping<FixedU16<Frac>>)

Performs the += operation.

impl<'a, Frac> AddAssign<&'a Wrapping<FixedU16<Frac>>> for Wrapping<FixedU16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

fn add_assign(&mut self, other: &Wrapping<FixedU16<Frac>>)

Performs the += operation.

impl<Frac> AddAssign<Wrapping<FixedU32<Frac>>> for Wrapping<FixedU32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

fn add_assign(&mut self, other: Wrapping<FixedU32<Frac>>)

Performs the += operation.

impl<'a, Frac> AddAssign<&'a Wrapping<FixedU32<Frac>>> for Wrapping<FixedU32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

fn add_assign(&mut self, other: &Wrapping<FixedU32<Frac>>)

Performs the += operation.

impl<Frac> AddAssign<Wrapping<FixedU64<Frac>>> for Wrapping<FixedU64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

fn add_assign(&mut self, other: Wrapping<FixedU64<Frac>>)

Performs the += operation.

impl<'a, Frac> AddAssign<&'a Wrapping<FixedU64<Frac>>> for Wrapping<FixedU64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

fn add_assign(&mut self, other: &Wrapping<FixedU64<Frac>>)

Performs the += operation.

impl<Frac> AddAssign<Wrapping<FixedU128<Frac>>> for Wrapping<FixedU128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

fn add_assign(&mut self, other: Wrapping<FixedU128<Frac>>)

Performs the += operation.

impl<'a, Frac> AddAssign<&'a Wrapping<FixedU128<Frac>>> for Wrapping<FixedU128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

fn add_assign(&mut self, other: &Wrapping<FixedU128<Frac>>)

Performs the += operation.

impl<Frac> SubAssign<Wrapping<FixedI8<Frac>>> for Wrapping<FixedI8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

fn sub_assign(&mut self, other: Wrapping<FixedI8<Frac>>)

Performs the -= operation.

impl<'a, Frac> SubAssign<&'a Wrapping<FixedI8<Frac>>> for Wrapping<FixedI8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

fn sub_assign(&mut self, other: &Wrapping<FixedI8<Frac>>)

Performs the -= operation.

impl<Frac> SubAssign<Wrapping<FixedI16<Frac>>> for Wrapping<FixedI16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

fn sub_assign(&mut self, other: Wrapping<FixedI16<Frac>>)

Performs the -= operation.

impl<'a, Frac> SubAssign<&'a Wrapping<FixedI16<Frac>>> for Wrapping<FixedI16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

fn sub_assign(&mut self, other: &Wrapping<FixedI16<Frac>>)

Performs the -= operation.

impl<Frac> SubAssign<Wrapping<FixedI32<Frac>>> for Wrapping<FixedI32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

fn sub_assign(&mut self, other: Wrapping<FixedI32<Frac>>)

Performs the -= operation.

impl<'a, Frac> SubAssign<&'a Wrapping<FixedI32<Frac>>> for Wrapping<FixedI32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

fn sub_assign(&mut self, other: &Wrapping<FixedI32<Frac>>)

Performs the -= operation.

impl<Frac> SubAssign<Wrapping<FixedI64<Frac>>> for Wrapping<FixedI64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

fn sub_assign(&mut self, other: Wrapping<FixedI64<Frac>>)

Performs the -= operation.

impl<'a, Frac> SubAssign<&'a Wrapping<FixedI64<Frac>>> for Wrapping<FixedI64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

fn sub_assign(&mut self, other: &Wrapping<FixedI64<Frac>>)

Performs the -= operation.

impl<Frac> SubAssign<Wrapping<FixedI128<Frac>>> for Wrapping<FixedI128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

fn sub_assign(&mut self, other: Wrapping<FixedI128<Frac>>)

Performs the -= operation.

impl<'a, Frac> SubAssign<&'a Wrapping<FixedI128<Frac>>> for Wrapping<FixedI128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

fn sub_assign(&mut self, other: &Wrapping<FixedI128<Frac>>)

Performs the -= operation.

impl<Frac> SubAssign<Wrapping<FixedU8<Frac>>> for Wrapping<FixedU8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

fn sub_assign(&mut self, other: Wrapping<FixedU8<Frac>>)

Performs the -= operation.

impl<'a, Frac> SubAssign<&'a Wrapping<FixedU8<Frac>>> for Wrapping<FixedU8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

fn sub_assign(&mut self, other: &Wrapping<FixedU8<Frac>>)

Performs the -= operation.

impl<Frac> SubAssign<Wrapping<FixedU16<Frac>>> for Wrapping<FixedU16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

fn sub_assign(&mut self, other: Wrapping<FixedU16<Frac>>)

Performs the -= operation.

impl<'a, Frac> SubAssign<&'a Wrapping<FixedU16<Frac>>> for Wrapping<FixedU16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

fn sub_assign(&mut self, other: &Wrapping<FixedU16<Frac>>)

Performs the -= operation.

impl<Frac> SubAssign<Wrapping<FixedU32<Frac>>> for Wrapping<FixedU32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

fn sub_assign(&mut self, other: Wrapping<FixedU32<Frac>>)

Performs the -= operation.

impl<'a, Frac> SubAssign<&'a Wrapping<FixedU32<Frac>>> for Wrapping<FixedU32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

fn sub_assign(&mut self, other: &Wrapping<FixedU32<Frac>>)

Performs the -= operation.

impl<Frac> SubAssign<Wrapping<FixedU64<Frac>>> for Wrapping<FixedU64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

fn sub_assign(&mut self, other: Wrapping<FixedU64<Frac>>)

Performs the -= operation.

impl<'a, Frac> SubAssign<&'a Wrapping<FixedU64<Frac>>> for Wrapping<FixedU64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

fn sub_assign(&mut self, other: &Wrapping<FixedU64<Frac>>)

Performs the -= operation.

impl<Frac> SubAssign<Wrapping<FixedU128<Frac>>> for Wrapping<FixedU128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

fn sub_assign(&mut self, other: Wrapping<FixedU128<Frac>>)

Performs the -= operation.

impl<'a, Frac> SubAssign<&'a Wrapping<FixedU128<Frac>>> for Wrapping<FixedU128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

fn sub_assign(&mut self, other: &Wrapping<FixedU128<Frac>>)

Performs the -= operation.

impl<Frac> MulAssign<Wrapping<FixedI8<Frac>>> for Wrapping<FixedI8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

fn mul_assign(&mut self, other: Wrapping<FixedI8<Frac>>)

Performs the *= operation.

impl<'a, Frac> MulAssign<&'a Wrapping<FixedI8<Frac>>> for Wrapping<FixedI8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

fn mul_assign(&mut self, other: &Wrapping<FixedI8<Frac>>)

Performs the *= operation.

impl<Frac> MulAssign<i8> for Wrapping<FixedI8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

fn mul_assign(&mut self, other: i8)

Performs the *= operation.

impl<'a, Frac> MulAssign<&'a i8> for Wrapping<FixedI8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

fn mul_assign(&mut self, other: &i8)

Performs the *= operation.

impl<Frac> MulAssign<Wrapping<FixedI16<Frac>>> for Wrapping<FixedI16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

fn mul_assign(&mut self, other: Wrapping<FixedI16<Frac>>)

Performs the *= operation.

impl<'a, Frac> MulAssign<&'a Wrapping<FixedI16<Frac>>> for Wrapping<FixedI16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

fn mul_assign(&mut self, other: &Wrapping<FixedI16<Frac>>)

Performs the *= operation.

impl<Frac> MulAssign<i16> for Wrapping<FixedI16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

fn mul_assign(&mut self, other: i16)

Performs the *= operation.

impl<'a, Frac> MulAssign<&'a i16> for Wrapping<FixedI16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

fn mul_assign(&mut self, other: &i16)

Performs the *= operation.

impl<Frac> MulAssign<Wrapping<FixedI32<Frac>>> for Wrapping<FixedI32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

fn mul_assign(&mut self, other: Wrapping<FixedI32<Frac>>)

Performs the *= operation.

impl<'a, Frac> MulAssign<&'a Wrapping<FixedI32<Frac>>> for Wrapping<FixedI32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

fn mul_assign(&mut self, other: &Wrapping<FixedI32<Frac>>)

Performs the *= operation.

impl<Frac> MulAssign<i32> for Wrapping<FixedI32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

fn mul_assign(&mut self, other: i32)

Performs the *= operation.

impl<'a, Frac> MulAssign<&'a i32> for Wrapping<FixedI32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

fn mul_assign(&mut self, other: &i32)

Performs the *= operation.

impl<Frac> MulAssign<Wrapping<FixedI64<Frac>>> for Wrapping<FixedI64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

fn mul_assign(&mut self, other: Wrapping<FixedI64<Frac>>)

Performs the *= operation.

impl<'a, Frac> MulAssign<&'a Wrapping<FixedI64<Frac>>> for Wrapping<FixedI64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

fn mul_assign(&mut self, other: &Wrapping<FixedI64<Frac>>)

Performs the *= operation.

impl<Frac> MulAssign<i64> for Wrapping<FixedI64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

fn mul_assign(&mut self, other: i64)

Performs the *= operation.

impl<'a, Frac> MulAssign<&'a i64> for Wrapping<FixedI64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

fn mul_assign(&mut self, other: &i64)

Performs the *= operation.

impl<Frac> MulAssign<Wrapping<FixedI128<Frac>>> for Wrapping<FixedI128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

fn mul_assign(&mut self, other: Wrapping<FixedI128<Frac>>)

Performs the *= operation.

impl<'a, Frac> MulAssign<&'a Wrapping<FixedI128<Frac>>> for Wrapping<FixedI128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

fn mul_assign(&mut self, other: &Wrapping<FixedI128<Frac>>)

Performs the *= operation.

impl<Frac> MulAssign<i128> for Wrapping<FixedI128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

fn mul_assign(&mut self, other: i128)

Performs the *= operation.

impl<'a, Frac> MulAssign<&'a i128> for Wrapping<FixedI128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

fn mul_assign(&mut self, other: &i128)

Performs the *= operation.

impl<Frac> MulAssign<Wrapping<FixedU8<Frac>>> for Wrapping<FixedU8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

fn mul_assign(&mut self, other: Wrapping<FixedU8<Frac>>)

Performs the *= operation.

impl<'a, Frac> MulAssign<&'a Wrapping<FixedU8<Frac>>> for Wrapping<FixedU8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

fn mul_assign(&mut self, other: &Wrapping<FixedU8<Frac>>)

Performs the *= operation.

impl<Frac> MulAssign<u8> for Wrapping<FixedU8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

fn mul_assign(&mut self, other: u8)

Performs the *= operation.

impl<'a, Frac> MulAssign<&'a u8> for Wrapping<FixedU8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

fn mul_assign(&mut self, other: &u8)

Performs the *= operation.

impl<Frac> MulAssign<Wrapping<FixedU16<Frac>>> for Wrapping<FixedU16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

fn mul_assign(&mut self, other: Wrapping<FixedU16<Frac>>)

Performs the *= operation.

impl<'a, Frac> MulAssign<&'a Wrapping<FixedU16<Frac>>> for Wrapping<FixedU16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

fn mul_assign(&mut self, other: &Wrapping<FixedU16<Frac>>)

Performs the *= operation.

impl<Frac> MulAssign<u16> for Wrapping<FixedU16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

fn mul_assign(&mut self, other: u16)

Performs the *= operation.

impl<'a, Frac> MulAssign<&'a u16> for Wrapping<FixedU16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

fn mul_assign(&mut self, other: &u16)

Performs the *= operation.

impl<Frac> MulAssign<Wrapping<FixedU32<Frac>>> for Wrapping<FixedU32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

fn mul_assign(&mut self, other: Wrapping<FixedU32<Frac>>)

Performs the *= operation.

impl<'a, Frac> MulAssign<&'a Wrapping<FixedU32<Frac>>> for Wrapping<FixedU32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

fn mul_assign(&mut self, other: &Wrapping<FixedU32<Frac>>)

Performs the *= operation.

impl<Frac> MulAssign<u32> for Wrapping<FixedU32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

fn mul_assign(&mut self, other: u32)

Performs the *= operation.

impl<'a, Frac> MulAssign<&'a u32> for Wrapping<FixedU32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

fn mul_assign(&mut self, other: &u32)

Performs the *= operation.

impl<Frac> MulAssign<Wrapping<FixedU64<Frac>>> for Wrapping<FixedU64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

fn mul_assign(&mut self, other: Wrapping<FixedU64<Frac>>)

Performs the *= operation.

impl<'a, Frac> MulAssign<&'a Wrapping<FixedU64<Frac>>> for Wrapping<FixedU64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

fn mul_assign(&mut self, other: &Wrapping<FixedU64<Frac>>)

Performs the *= operation.

impl<Frac> MulAssign<u64> for Wrapping<FixedU64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

fn mul_assign(&mut self, other: u64)

Performs the *= operation.

impl<'a, Frac> MulAssign<&'a u64> for Wrapping<FixedU64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

fn mul_assign(&mut self, other: &u64)

Performs the *= operation.

impl<Frac> MulAssign<Wrapping<FixedU128<Frac>>> for Wrapping<FixedU128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

fn mul_assign(&mut self, other: Wrapping<FixedU128<Frac>>)

Performs the *= operation.

impl<'a, Frac> MulAssign<&'a Wrapping<FixedU128<Frac>>> for Wrapping<FixedU128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

fn mul_assign(&mut self, other: &Wrapping<FixedU128<Frac>>)

Performs the *= operation.

impl<Frac> MulAssign<u128> for Wrapping<FixedU128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

fn mul_assign(&mut self, other: u128)

Performs the *= operation.

impl<'a, Frac> MulAssign<&'a u128> for Wrapping<FixedU128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

fn mul_assign(&mut self, other: &u128)

Performs the *= operation.

impl<Frac> DivAssign<Wrapping<FixedI8<Frac>>> for Wrapping<FixedI8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

fn div_assign(&mut self, other: Wrapping<FixedI8<Frac>>)

Performs the /= operation.

impl<'a, Frac> DivAssign<&'a Wrapping<FixedI8<Frac>>> for Wrapping<FixedI8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

fn div_assign(&mut self, other: &Wrapping<FixedI8<Frac>>)

Performs the /= operation.

impl<Frac> DivAssign<i8> for Wrapping<FixedI8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

fn div_assign(&mut self, other: i8)

Performs the /= operation.

impl<'a, Frac> DivAssign<&'a i8> for Wrapping<FixedI8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

fn div_assign(&mut self, other: &i8)

Performs the /= operation.

impl<Frac> DivAssign<Wrapping<FixedI16<Frac>>> for Wrapping<FixedI16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

fn div_assign(&mut self, other: Wrapping<FixedI16<Frac>>)

Performs the /= operation.

impl<'a, Frac> DivAssign<&'a Wrapping<FixedI16<Frac>>> for Wrapping<FixedI16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

fn div_assign(&mut self, other: &Wrapping<FixedI16<Frac>>)

Performs the /= operation.

impl<Frac> DivAssign<i16> for Wrapping<FixedI16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

fn div_assign(&mut self, other: i16)

Performs the /= operation.

impl<'a, Frac> DivAssign<&'a i16> for Wrapping<FixedI16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

fn div_assign(&mut self, other: &i16)

Performs the /= operation.

impl<Frac> DivAssign<Wrapping<FixedI32<Frac>>> for Wrapping<FixedI32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

fn div_assign(&mut self, other: Wrapping<FixedI32<Frac>>)

Performs the /= operation.

impl<'a, Frac> DivAssign<&'a Wrapping<FixedI32<Frac>>> for Wrapping<FixedI32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

fn div_assign(&mut self, other: &Wrapping<FixedI32<Frac>>)

Performs the /= operation.

impl<Frac> DivAssign<i32> for Wrapping<FixedI32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

fn div_assign(&mut self, other: i32)

Performs the /= operation.

impl<'a, Frac> DivAssign<&'a i32> for Wrapping<FixedI32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

fn div_assign(&mut self, other: &i32)

Performs the /= operation.

impl<Frac> DivAssign<Wrapping<FixedI64<Frac>>> for Wrapping<FixedI64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

fn div_assign(&mut self, other: Wrapping<FixedI64<Frac>>)

Performs the /= operation.

impl<'a, Frac> DivAssign<&'a Wrapping<FixedI64<Frac>>> for Wrapping<FixedI64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

fn div_assign(&mut self, other: &Wrapping<FixedI64<Frac>>)

Performs the /= operation.

impl<Frac> DivAssign<i64> for Wrapping<FixedI64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

fn div_assign(&mut self, other: i64)

Performs the /= operation.

impl<'a, Frac> DivAssign<&'a i64> for Wrapping<FixedI64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

fn div_assign(&mut self, other: &i64)

Performs the /= operation.

impl<Frac> DivAssign<Wrapping<FixedI128<Frac>>> for Wrapping<FixedI128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

fn div_assign(&mut self, other: Wrapping<FixedI128<Frac>>)

Performs the /= operation.

impl<'a, Frac> DivAssign<&'a Wrapping<FixedI128<Frac>>> for Wrapping<FixedI128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

fn div_assign(&mut self, other: &Wrapping<FixedI128<Frac>>)

Performs the /= operation.

impl<Frac> DivAssign<i128> for Wrapping<FixedI128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

fn div_assign(&mut self, other: i128)

Performs the /= operation.

impl<'a, Frac> DivAssign<&'a i128> for Wrapping<FixedI128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

fn div_assign(&mut self, other: &i128)

Performs the /= operation.

impl<Frac> DivAssign<Wrapping<FixedU8<Frac>>> for Wrapping<FixedU8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

fn div_assign(&mut self, other: Wrapping<FixedU8<Frac>>)

Performs the /= operation.

impl<'a, Frac> DivAssign<&'a Wrapping<FixedU8<Frac>>> for Wrapping<FixedU8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

fn div_assign(&mut self, other: &Wrapping<FixedU8<Frac>>)

Performs the /= operation.

impl<Frac> DivAssign<u8> for Wrapping<FixedU8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

fn div_assign(&mut self, other: u8)

Performs the /= operation.

impl<'a, Frac> DivAssign<&'a u8> for Wrapping<FixedU8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

fn div_assign(&mut self, other: &u8)

Performs the /= operation.

impl<Frac> DivAssign<Wrapping<FixedU16<Frac>>> for Wrapping<FixedU16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

fn div_assign(&mut self, other: Wrapping<FixedU16<Frac>>)

Performs the /= operation.

impl<'a, Frac> DivAssign<&'a Wrapping<FixedU16<Frac>>> for Wrapping<FixedU16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

fn div_assign(&mut self, other: &Wrapping<FixedU16<Frac>>)

Performs the /= operation.

impl<Frac> DivAssign<u16> for Wrapping<FixedU16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

fn div_assign(&mut self, other: u16)

Performs the /= operation.

impl<'a, Frac> DivAssign<&'a u16> for Wrapping<FixedU16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

fn div_assign(&mut self, other: &u16)

Performs the /= operation.

impl<Frac> DivAssign<Wrapping<FixedU32<Frac>>> for Wrapping<FixedU32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

fn div_assign(&mut self, other: Wrapping<FixedU32<Frac>>)

Performs the /= operation.

impl<'a, Frac> DivAssign<&'a Wrapping<FixedU32<Frac>>> for Wrapping<FixedU32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

fn div_assign(&mut self, other: &Wrapping<FixedU32<Frac>>)

Performs the /= operation.

impl<Frac> DivAssign<u32> for Wrapping<FixedU32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

fn div_assign(&mut self, other: u32)

Performs the /= operation.

impl<'a, Frac> DivAssign<&'a u32> for Wrapping<FixedU32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

fn div_assign(&mut self, other: &u32)

Performs the /= operation.

impl<Frac> DivAssign<Wrapping<FixedU64<Frac>>> for Wrapping<FixedU64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

fn div_assign(&mut self, other: Wrapping<FixedU64<Frac>>)

Performs the /= operation.

impl<'a, Frac> DivAssign<&'a Wrapping<FixedU64<Frac>>> for Wrapping<FixedU64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

fn div_assign(&mut self, other: &Wrapping<FixedU64<Frac>>)

Performs the /= operation.

impl<Frac> DivAssign<u64> for Wrapping<FixedU64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

fn div_assign(&mut self, other: u64)

Performs the /= operation.

impl<'a, Frac> DivAssign<&'a u64> for Wrapping<FixedU64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

fn div_assign(&mut self, other: &u64)

Performs the /= operation.

impl<Frac> DivAssign<Wrapping<FixedU128<Frac>>> for Wrapping<FixedU128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

fn div_assign(&mut self, other: Wrapping<FixedU128<Frac>>)

Performs the /= operation.

impl<'a, Frac> DivAssign<&'a Wrapping<FixedU128<Frac>>> for Wrapping<FixedU128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

fn div_assign(&mut self, other: &Wrapping<FixedU128<Frac>>)

Performs the /= operation.

impl<Frac> DivAssign<u128> for Wrapping<FixedU128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

fn div_assign(&mut self, other: u128)

Performs the /= operation.

impl<'a, Frac> DivAssign<&'a u128> for Wrapping<FixedU128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

fn div_assign(&mut self, other: &u128)

Performs the /= operation.

impl<Frac> RemAssign<i8> for Wrapping<FixedI8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

fn rem_assign(&mut self, other: i8)

Performs the %= operation.

impl<'a, Frac> RemAssign<&'a i8> for Wrapping<FixedI8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

fn rem_assign(&mut self, other: &i8)

Performs the %= operation.

impl<Frac> RemAssign<i16> for Wrapping<FixedI16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

fn rem_assign(&mut self, other: i16)

Performs the %= operation.

impl<'a, Frac> RemAssign<&'a i16> for Wrapping<FixedI16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

fn rem_assign(&mut self, other: &i16)

Performs the %= operation.

impl<Frac> RemAssign<i32> for Wrapping<FixedI32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

fn rem_assign(&mut self, other: i32)

Performs the %= operation.

impl<'a, Frac> RemAssign<&'a i32> for Wrapping<FixedI32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

fn rem_assign(&mut self, other: &i32)

Performs the %= operation.

impl<Frac> RemAssign<i64> for Wrapping<FixedI64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

fn rem_assign(&mut self, other: i64)

Performs the %= operation.

impl<'a, Frac> RemAssign<&'a i64> for Wrapping<FixedI64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

fn rem_assign(&mut self, other: &i64)

Performs the %= operation.

impl<Frac> RemAssign<i128> for Wrapping<FixedI128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

fn rem_assign(&mut self, other: i128)

Performs the %= operation.

impl<'a, Frac> RemAssign<&'a i128> for Wrapping<FixedI128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

fn rem_assign(&mut self, other: &i128)

Performs the %= operation.

impl<Frac> RemAssign<u8> for Wrapping<FixedU8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

fn rem_assign(&mut self, other: u8)

Performs the %= operation.

impl<'a, Frac> RemAssign<&'a u8> for Wrapping<FixedU8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

fn rem_assign(&mut self, other: &u8)

Performs the %= operation.

impl<Frac> RemAssign<u16> for Wrapping<FixedU16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

fn rem_assign(&mut self, other: u16)

Performs the %= operation.

impl<'a, Frac> RemAssign<&'a u16> for Wrapping<FixedU16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

fn rem_assign(&mut self, other: &u16)

Performs the %= operation.

impl<Frac> RemAssign<u32> for Wrapping<FixedU32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

fn rem_assign(&mut self, other: u32)

Performs the %= operation.

impl<'a, Frac> RemAssign<&'a u32> for Wrapping<FixedU32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

fn rem_assign(&mut self, other: &u32)

Performs the %= operation.

impl<Frac> RemAssign<u64> for Wrapping<FixedU64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

fn rem_assign(&mut self, other: u64)

Performs the %= operation.

impl<'a, Frac> RemAssign<&'a u64> for Wrapping<FixedU64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

fn rem_assign(&mut self, other: &u64)

Performs the %= operation.

impl<Frac> RemAssign<u128> for Wrapping<FixedU128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

fn rem_assign(&mut self, other: u128)

Performs the %= operation.

impl<'a, Frac> RemAssign<&'a u128> for Wrapping<FixedU128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

fn rem_assign(&mut self, other: &u128)

Performs the %= operation.

impl<Frac> Not for Wrapping<FixedI8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

type Output = Wrapping<FixedI8<Frac>>

The resulting type after applying the ! operator.

fn not(self) -> Wrapping<FixedI8<Frac>>

Performs the unary ! operation.

impl<'a, Frac> Not for &'a Wrapping<FixedI8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

type Output = Wrapping<FixedI8<Frac>>

The resulting type after applying the ! operator.

fn not(self) -> Wrapping<FixedI8<Frac>>

Performs the unary ! operation.

impl<Frac> Not for Wrapping<FixedI16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

type Output = Wrapping<FixedI16<Frac>>

The resulting type after applying the ! operator.

fn not(self) -> Wrapping<FixedI16<Frac>>

Performs the unary ! operation.

impl<'a, Frac> Not for &'a Wrapping<FixedI16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

type Output = Wrapping<FixedI16<Frac>>

The resulting type after applying the ! operator.

fn not(self) -> Wrapping<FixedI16<Frac>>

Performs the unary ! operation.

impl<Frac> Not for Wrapping<FixedI32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

type Output = Wrapping<FixedI32<Frac>>

The resulting type after applying the ! operator.

fn not(self) -> Wrapping<FixedI32<Frac>>

Performs the unary ! operation.

impl<'a, Frac> Not for &'a Wrapping<FixedI32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

type Output = Wrapping<FixedI32<Frac>>

The resulting type after applying the ! operator.

fn not(self) -> Wrapping<FixedI32<Frac>>

Performs the unary ! operation.

impl<Frac> Not for Wrapping<FixedI64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

type Output = Wrapping<FixedI64<Frac>>

The resulting type after applying the ! operator.

fn not(self) -> Wrapping<FixedI64<Frac>>

Performs the unary ! operation.

impl<'a, Frac> Not for &'a Wrapping<FixedI64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

type Output = Wrapping<FixedI64<Frac>>

The resulting type after applying the ! operator.

fn not(self) -> Wrapping<FixedI64<Frac>>

Performs the unary ! operation.

impl<Frac> Not for Wrapping<FixedI128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

type Output = Wrapping<FixedI128<Frac>>

The resulting type after applying the ! operator.

fn not(self) -> Wrapping<FixedI128<Frac>>

Performs the unary ! operation.

impl<'a, Frac> Not for &'a Wrapping<FixedI128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

type Output = Wrapping<FixedI128<Frac>>

The resulting type after applying the ! operator.

fn not(self) -> Wrapping<FixedI128<Frac>>

Performs the unary ! operation.

impl<Frac> Not for Wrapping<FixedU8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

type Output = Wrapping<FixedU8<Frac>>

The resulting type after applying the ! operator.

fn not(self) -> Wrapping<FixedU8<Frac>>

Performs the unary ! operation.

impl<'a, Frac> Not for &'a Wrapping<FixedU8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

type Output = Wrapping<FixedU8<Frac>>

The resulting type after applying the ! operator.

fn not(self) -> Wrapping<FixedU8<Frac>>

Performs the unary ! operation.

impl<Frac> Not for Wrapping<FixedU16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

type Output = Wrapping<FixedU16<Frac>>

The resulting type after applying the ! operator.

fn not(self) -> Wrapping<FixedU16<Frac>>

Performs the unary ! operation.

impl<'a, Frac> Not for &'a Wrapping<FixedU16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

type Output = Wrapping<FixedU16<Frac>>

The resulting type after applying the ! operator.

fn not(self) -> Wrapping<FixedU16<Frac>>

Performs the unary ! operation.

impl<Frac> Not for Wrapping<FixedU32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

type Output = Wrapping<FixedU32<Frac>>

The resulting type after applying the ! operator.

fn not(self) -> Wrapping<FixedU32<Frac>>

Performs the unary ! operation.

impl<'a, Frac> Not for &'a Wrapping<FixedU32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

type Output = Wrapping<FixedU32<Frac>>

The resulting type after applying the ! operator.

fn not(self) -> Wrapping<FixedU32<Frac>>

Performs the unary ! operation.

impl<Frac> Not for Wrapping<FixedU64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

type Output = Wrapping<FixedU64<Frac>>

The resulting type after applying the ! operator.

fn not(self) -> Wrapping<FixedU64<Frac>>

Performs the unary ! operation.

impl<'a, Frac> Not for &'a Wrapping<FixedU64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

type Output = Wrapping<FixedU64<Frac>>

The resulting type after applying the ! operator.

fn not(self) -> Wrapping<FixedU64<Frac>>

Performs the unary ! operation.

impl<Frac> Not for Wrapping<FixedU128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

type Output = Wrapping<FixedU128<Frac>>

The resulting type after applying the ! operator.

fn not(self) -> Wrapping<FixedU128<Frac>>

Performs the unary ! operation.

impl<'a, Frac> Not for &'a Wrapping<FixedU128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

type Output = Wrapping<FixedU128<Frac>>

The resulting type after applying the ! operator.

fn not(self) -> Wrapping<FixedU128<Frac>>

Performs the unary ! operation.

impl<Frac> BitAnd<Wrapping<FixedI8<Frac>>> for Wrapping<FixedI8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

type Output = Wrapping<FixedI8<Frac>>

The resulting type after applying the & operator.

fn bitand(self, other: Wrapping<FixedI8<Frac>>) -> Wrapping<FixedI8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

Performs the & operation.

impl<'a, Frac> BitAnd<Wrapping<FixedI8<Frac>>> for &'a Wrapping<FixedI8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

type Output = Wrapping<FixedI8<Frac>>

The resulting type after applying the & operator.

fn bitand(self, other: Wrapping<FixedI8<Frac>>) -> Wrapping<FixedI8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

Performs the & operation.

impl<'a, Frac> BitAnd<&'a Wrapping<FixedI8<Frac>>> for Wrapping<FixedI8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

type Output = Wrapping<FixedI8<Frac>>

The resulting type after applying the & operator.

fn bitand(self, other: &Wrapping<FixedI8<Frac>>) -> Wrapping<FixedI8<Frac>>

Performs the & operation.

impl<'a, 'b, Frac> BitAnd<&'a Wrapping<FixedI8<Frac>>> for &'b Wrapping<FixedI8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

type Output = Wrapping<FixedI8<Frac>>

The resulting type after applying the & operator.

fn bitand(self, other: &Wrapping<FixedI8<Frac>>) -> Wrapping<FixedI8<Frac>>

Performs the & operation.

impl<Frac> BitAnd<Wrapping<FixedI16<Frac>>> for Wrapping<FixedI16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

type Output = Wrapping<FixedI16<Frac>>

The resulting type after applying the & operator.

fn bitand(self, other: Wrapping<FixedI16<Frac>>) -> Wrapping<FixedI16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

Performs the & operation.

impl<'a, Frac> BitAnd<Wrapping<FixedI16<Frac>>> for &'a Wrapping<FixedI16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

type Output = Wrapping<FixedI16<Frac>>

The resulting type after applying the & operator.

fn bitand(self, other: Wrapping<FixedI16<Frac>>) -> Wrapping<FixedI16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

Performs the & operation.

impl<'a, Frac> BitAnd<&'a Wrapping<FixedI16<Frac>>> for Wrapping<FixedI16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

type Output = Wrapping<FixedI16<Frac>>

The resulting type after applying the & operator.

fn bitand(self, other: &Wrapping<FixedI16<Frac>>) -> Wrapping<FixedI16<Frac>>

Performs the & operation.

impl<'a, 'b, Frac> BitAnd<&'a Wrapping<FixedI16<Frac>>> for &'b Wrapping<FixedI16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

type Output = Wrapping<FixedI16<Frac>>

The resulting type after applying the & operator.

fn bitand(self, other: &Wrapping<FixedI16<Frac>>) -> Wrapping<FixedI16<Frac>>

Performs the & operation.

impl<Frac> BitAnd<Wrapping<FixedI32<Frac>>> for Wrapping<FixedI32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

type Output = Wrapping<FixedI32<Frac>>

The resulting type after applying the & operator.

fn bitand(self, other: Wrapping<FixedI32<Frac>>) -> Wrapping<FixedI32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

Performs the & operation.

impl<'a, Frac> BitAnd<Wrapping<FixedI32<Frac>>> for &'a Wrapping<FixedI32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

type Output = Wrapping<FixedI32<Frac>>

The resulting type after applying the & operator.

fn bitand(self, other: Wrapping<FixedI32<Frac>>) -> Wrapping<FixedI32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

Performs the & operation.

impl<'a, Frac> BitAnd<&'a Wrapping<FixedI32<Frac>>> for Wrapping<FixedI32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

type Output = Wrapping<FixedI32<Frac>>

The resulting type after applying the & operator.

fn bitand(self, other: &Wrapping<FixedI32<Frac>>) -> Wrapping<FixedI32<Frac>>

Performs the & operation.

impl<'a, 'b, Frac> BitAnd<&'a Wrapping<FixedI32<Frac>>> for &'b Wrapping<FixedI32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

type Output = Wrapping<FixedI32<Frac>>

The resulting type after applying the & operator.

fn bitand(self, other: &Wrapping<FixedI32<Frac>>) -> Wrapping<FixedI32<Frac>>

Performs the & operation.

impl<Frac> BitAnd<Wrapping<FixedI64<Frac>>> for Wrapping<FixedI64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

type Output = Wrapping<FixedI64<Frac>>

The resulting type after applying the & operator.

fn bitand(self, other: Wrapping<FixedI64<Frac>>) -> Wrapping<FixedI64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

Performs the & operation.

impl<'a, Frac> BitAnd<Wrapping<FixedI64<Frac>>> for &'a Wrapping<FixedI64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

type Output = Wrapping<FixedI64<Frac>>

The resulting type after applying the & operator.

fn bitand(self, other: Wrapping<FixedI64<Frac>>) -> Wrapping<FixedI64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

Performs the & operation.

impl<'a, Frac> BitAnd<&'a Wrapping<FixedI64<Frac>>> for Wrapping<FixedI64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

type Output = Wrapping<FixedI64<Frac>>

The resulting type after applying the & operator.

fn bitand(self, other: &Wrapping<FixedI64<Frac>>) -> Wrapping<FixedI64<Frac>>

Performs the & operation.

impl<'a, 'b, Frac> BitAnd<&'a Wrapping<FixedI64<Frac>>> for &'b Wrapping<FixedI64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

type Output = Wrapping<FixedI64<Frac>>

The resulting type after applying the & operator.

fn bitand(self, other: &Wrapping<FixedI64<Frac>>) -> Wrapping<FixedI64<Frac>>

Performs the & operation.

impl<Frac> BitAnd<Wrapping<FixedI128<Frac>>> for Wrapping<FixedI128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

type Output = Wrapping<FixedI128<Frac>>

The resulting type after applying the & operator.

fn bitand(self, other: Wrapping<FixedI128<Frac>>) -> Wrapping<FixedI128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

Performs the & operation.

impl<'a, Frac> BitAnd<Wrapping<FixedI128<Frac>>> for &'a Wrapping<FixedI128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

type Output = Wrapping<FixedI128<Frac>>

The resulting type after applying the & operator.

fn bitand(self, other: Wrapping<FixedI128<Frac>>) -> Wrapping<FixedI128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

Performs the & operation.

impl<'a, Frac> BitAnd<&'a Wrapping<FixedI128<Frac>>> for Wrapping<FixedI128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

type Output = Wrapping<FixedI128<Frac>>

The resulting type after applying the & operator.

fn bitand(self, other: &Wrapping<FixedI128<Frac>>) -> Wrapping<FixedI128<Frac>>

Performs the & operation.

impl<'a, 'b, Frac> BitAnd<&'a Wrapping<FixedI128<Frac>>> for &'b Wrapping<FixedI128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

type Output = Wrapping<FixedI128<Frac>>

The resulting type after applying the & operator.

fn bitand(self, other: &Wrapping<FixedI128<Frac>>) -> Wrapping<FixedI128<Frac>>

Performs the & operation.

impl<Frac> BitAnd<Wrapping<FixedU8<Frac>>> for Wrapping<FixedU8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

type Output = Wrapping<FixedU8<Frac>>

The resulting type after applying the & operator.

fn bitand(self, other: Wrapping<FixedU8<Frac>>) -> Wrapping<FixedU8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

Performs the & operation.

impl<'a, Frac> BitAnd<Wrapping<FixedU8<Frac>>> for &'a Wrapping<FixedU8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

type Output = Wrapping<FixedU8<Frac>>

The resulting type after applying the & operator.

fn bitand(self, other: Wrapping<FixedU8<Frac>>) -> Wrapping<FixedU8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

Performs the & operation.

impl<'a, Frac> BitAnd<&'a Wrapping<FixedU8<Frac>>> for Wrapping<FixedU8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

type Output = Wrapping<FixedU8<Frac>>

The resulting type after applying the & operator.

fn bitand(self, other: &Wrapping<FixedU8<Frac>>) -> Wrapping<FixedU8<Frac>>

Performs the & operation.

impl<'a, 'b, Frac> BitAnd<&'a Wrapping<FixedU8<Frac>>> for &'b Wrapping<FixedU8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

type Output = Wrapping<FixedU8<Frac>>

The resulting type after applying the & operator.

fn bitand(self, other: &Wrapping<FixedU8<Frac>>) -> Wrapping<FixedU8<Frac>>

Performs the & operation.

impl<Frac> BitAnd<Wrapping<FixedU16<Frac>>> for Wrapping<FixedU16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

type Output = Wrapping<FixedU16<Frac>>

The resulting type after applying the & operator.

fn bitand(self, other: Wrapping<FixedU16<Frac>>) -> Wrapping<FixedU16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

Performs the & operation.

impl<'a, Frac> BitAnd<Wrapping<FixedU16<Frac>>> for &'a Wrapping<FixedU16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

type Output = Wrapping<FixedU16<Frac>>

The resulting type after applying the & operator.

fn bitand(self, other: Wrapping<FixedU16<Frac>>) -> Wrapping<FixedU16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

Performs the & operation.

impl<'a, Frac> BitAnd<&'a Wrapping<FixedU16<Frac>>> for Wrapping<FixedU16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

type Output = Wrapping<FixedU16<Frac>>

The resulting type after applying the & operator.

fn bitand(self, other: &Wrapping<FixedU16<Frac>>) -> Wrapping<FixedU16<Frac>>

Performs the & operation.

impl<'a, 'b, Frac> BitAnd<&'a Wrapping<FixedU16<Frac>>> for &'b Wrapping<FixedU16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

type Output = Wrapping<FixedU16<Frac>>

The resulting type after applying the & operator.

fn bitand(self, other: &Wrapping<FixedU16<Frac>>) -> Wrapping<FixedU16<Frac>>

Performs the & operation.

impl<Frac> BitAnd<Wrapping<FixedU32<Frac>>> for Wrapping<FixedU32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

type Output = Wrapping<FixedU32<Frac>>

The resulting type after applying the & operator.

fn bitand(self, other: Wrapping<FixedU32<Frac>>) -> Wrapping<FixedU32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

Performs the & operation.

impl<'a, Frac> BitAnd<Wrapping<FixedU32<Frac>>> for &'a Wrapping<FixedU32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

type Output = Wrapping<FixedU32<Frac>>

The resulting type after applying the & operator.

fn bitand(self, other: Wrapping<FixedU32<Frac>>) -> Wrapping<FixedU32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

Performs the & operation.

impl<'a, Frac> BitAnd<&'a Wrapping<FixedU32<Frac>>> for Wrapping<FixedU32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

type Output = Wrapping<FixedU32<Frac>>

The resulting type after applying the & operator.

fn bitand(self, other: &Wrapping<FixedU32<Frac>>) -> Wrapping<FixedU32<Frac>>

Performs the & operation.

impl<'a, 'b, Frac> BitAnd<&'a Wrapping<FixedU32<Frac>>> for &'b Wrapping<FixedU32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

type Output = Wrapping<FixedU32<Frac>>

The resulting type after applying the & operator.

fn bitand(self, other: &Wrapping<FixedU32<Frac>>) -> Wrapping<FixedU32<Frac>>

Performs the & operation.

impl<Frac> BitAnd<Wrapping<FixedU64<Frac>>> for Wrapping<FixedU64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

type Output = Wrapping<FixedU64<Frac>>

The resulting type after applying the & operator.

fn bitand(self, other: Wrapping<FixedU64<Frac>>) -> Wrapping<FixedU64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

Performs the & operation.

impl<'a, Frac> BitAnd<Wrapping<FixedU64<Frac>>> for &'a Wrapping<FixedU64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

type Output = Wrapping<FixedU64<Frac>>

The resulting type after applying the & operator.

fn bitand(self, other: Wrapping<FixedU64<Frac>>) -> Wrapping<FixedU64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

Performs the & operation.

impl<'a, Frac> BitAnd<&'a Wrapping<FixedU64<Frac>>> for Wrapping<FixedU64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

type Output = Wrapping<FixedU64<Frac>>

The resulting type after applying the & operator.

fn bitand(self, other: &Wrapping<FixedU64<Frac>>) -> Wrapping<FixedU64<Frac>>

Performs the & operation.

impl<'a, 'b, Frac> BitAnd<&'a Wrapping<FixedU64<Frac>>> for &'b Wrapping<FixedU64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

type Output = Wrapping<FixedU64<Frac>>

The resulting type after applying the & operator.

fn bitand(self, other: &Wrapping<FixedU64<Frac>>) -> Wrapping<FixedU64<Frac>>

Performs the & operation.

impl<Frac> BitAnd<Wrapping<FixedU128<Frac>>> for Wrapping<FixedU128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

type Output = Wrapping<FixedU128<Frac>>

The resulting type after applying the & operator.

fn bitand(self, other: Wrapping<FixedU128<Frac>>) -> Wrapping<FixedU128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

Performs the & operation.

impl<'a, Frac> BitAnd<Wrapping<FixedU128<Frac>>> for &'a Wrapping<FixedU128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

type Output = Wrapping<FixedU128<Frac>>

The resulting type after applying the & operator.

fn bitand(self, other: Wrapping<FixedU128<Frac>>) -> Wrapping<FixedU128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

Performs the & operation.

impl<'a, Frac> BitAnd<&'a Wrapping<FixedU128<Frac>>> for Wrapping<FixedU128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

type Output = Wrapping<FixedU128<Frac>>

The resulting type after applying the & operator.

fn bitand(self, other: &Wrapping<FixedU128<Frac>>) -> Wrapping<FixedU128<Frac>>

Performs the & operation.

impl<'a, 'b, Frac> BitAnd<&'a Wrapping<FixedU128<Frac>>> for &'b Wrapping<FixedU128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

type Output = Wrapping<FixedU128<Frac>>

The resulting type after applying the & operator.

fn bitand(self, other: &Wrapping<FixedU128<Frac>>) -> Wrapping<FixedU128<Frac>>

Performs the & operation.

impl<Frac> BitOr<Wrapping<FixedI8<Frac>>> for Wrapping<FixedI8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

type Output = Wrapping<FixedI8<Frac>>

The resulting type after applying the | operator.

fn bitor(self, other: Wrapping<FixedI8<Frac>>) -> Wrapping<FixedI8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

Performs the | operation.

impl<'a, Frac> BitOr<Wrapping<FixedI8<Frac>>> for &'a Wrapping<FixedI8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

type Output = Wrapping<FixedI8<Frac>>

The resulting type after applying the | operator.

fn bitor(self, other: Wrapping<FixedI8<Frac>>) -> Wrapping<FixedI8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

Performs the | operation.

impl<'a, Frac> BitOr<&'a Wrapping<FixedI8<Frac>>> for Wrapping<FixedI8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

type Output = Wrapping<FixedI8<Frac>>

The resulting type after applying the | operator.

fn bitor(self, other: &Wrapping<FixedI8<Frac>>) -> Wrapping<FixedI8<Frac>>

Performs the | operation.

impl<'a, 'b, Frac> BitOr<&'a Wrapping<FixedI8<Frac>>> for &'b Wrapping<FixedI8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

type Output = Wrapping<FixedI8<Frac>>

The resulting type after applying the | operator.

fn bitor(self, other: &Wrapping<FixedI8<Frac>>) -> Wrapping<FixedI8<Frac>>

Performs the | operation.

impl<Frac> BitOr<Wrapping<FixedI16<Frac>>> for Wrapping<FixedI16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

type Output = Wrapping<FixedI16<Frac>>

The resulting type after applying the | operator.

fn bitor(self, other: Wrapping<FixedI16<Frac>>) -> Wrapping<FixedI16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

Performs the | operation.

impl<'a, Frac> BitOr<Wrapping<FixedI16<Frac>>> for &'a Wrapping<FixedI16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

type Output = Wrapping<FixedI16<Frac>>

The resulting type after applying the | operator.

fn bitor(self, other: Wrapping<FixedI16<Frac>>) -> Wrapping<FixedI16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

Performs the | operation.

impl<'a, Frac> BitOr<&'a Wrapping<FixedI16<Frac>>> for Wrapping<FixedI16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

type Output = Wrapping<FixedI16<Frac>>

The resulting type after applying the | operator.

fn bitor(self, other: &Wrapping<FixedI16<Frac>>) -> Wrapping<FixedI16<Frac>>

Performs the | operation.

impl<'a, 'b, Frac> BitOr<&'a Wrapping<FixedI16<Frac>>> for &'b Wrapping<FixedI16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

type Output = Wrapping<FixedI16<Frac>>

The resulting type after applying the | operator.

fn bitor(self, other: &Wrapping<FixedI16<Frac>>) -> Wrapping<FixedI16<Frac>>

Performs the | operation.

impl<Frac> BitOr<Wrapping<FixedI32<Frac>>> for Wrapping<FixedI32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

type Output = Wrapping<FixedI32<Frac>>

The resulting type after applying the | operator.

fn bitor(self, other: Wrapping<FixedI32<Frac>>) -> Wrapping<FixedI32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

Performs the | operation.

impl<'a, Frac> BitOr<Wrapping<FixedI32<Frac>>> for &'a Wrapping<FixedI32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

type Output = Wrapping<FixedI32<Frac>>

The resulting type after applying the | operator.

fn bitor(self, other: Wrapping<FixedI32<Frac>>) -> Wrapping<FixedI32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

Performs the | operation.

impl<'a, Frac> BitOr<&'a Wrapping<FixedI32<Frac>>> for Wrapping<FixedI32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

type Output = Wrapping<FixedI32<Frac>>

The resulting type after applying the | operator.

fn bitor(self, other: &Wrapping<FixedI32<Frac>>) -> Wrapping<FixedI32<Frac>>

Performs the | operation.

impl<'a, 'b, Frac> BitOr<&'a Wrapping<FixedI32<Frac>>> for &'b Wrapping<FixedI32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

type Output = Wrapping<FixedI32<Frac>>

The resulting type after applying the | operator.

fn bitor(self, other: &Wrapping<FixedI32<Frac>>) -> Wrapping<FixedI32<Frac>>

Performs the | operation.

impl<Frac> BitOr<Wrapping<FixedI64<Frac>>> for Wrapping<FixedI64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

type Output = Wrapping<FixedI64<Frac>>

The resulting type after applying the | operator.

fn bitor(self, other: Wrapping<FixedI64<Frac>>) -> Wrapping<FixedI64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

Performs the | operation.

impl<'a, Frac> BitOr<Wrapping<FixedI64<Frac>>> for &'a Wrapping<FixedI64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

type Output = Wrapping<FixedI64<Frac>>

The resulting type after applying the | operator.

fn bitor(self, other: Wrapping<FixedI64<Frac>>) -> Wrapping<FixedI64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

Performs the | operation.

impl<'a, Frac> BitOr<&'a Wrapping<FixedI64<Frac>>> for Wrapping<FixedI64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

type Output = Wrapping<FixedI64<Frac>>

The resulting type after applying the | operator.

fn bitor(self, other: &Wrapping<FixedI64<Frac>>) -> Wrapping<FixedI64<Frac>>

Performs the | operation.

impl<'a, 'b, Frac> BitOr<&'a Wrapping<FixedI64<Frac>>> for &'b Wrapping<FixedI64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

type Output = Wrapping<FixedI64<Frac>>

The resulting type after applying the | operator.

fn bitor(self, other: &Wrapping<FixedI64<Frac>>) -> Wrapping<FixedI64<Frac>>

Performs the | operation.

impl<Frac> BitOr<Wrapping<FixedI128<Frac>>> for Wrapping<FixedI128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

type Output = Wrapping<FixedI128<Frac>>

The resulting type after applying the | operator.

fn bitor(self, other: Wrapping<FixedI128<Frac>>) -> Wrapping<FixedI128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

Performs the | operation.

impl<'a, Frac> BitOr<Wrapping<FixedI128<Frac>>> for &'a Wrapping<FixedI128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

type Output = Wrapping<FixedI128<Frac>>

The resulting type after applying the | operator.

fn bitor(self, other: Wrapping<FixedI128<Frac>>) -> Wrapping<FixedI128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

Performs the | operation.

impl<'a, Frac> BitOr<&'a Wrapping<FixedI128<Frac>>> for Wrapping<FixedI128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

type Output = Wrapping<FixedI128<Frac>>

The resulting type after applying the | operator.

fn bitor(self, other: &Wrapping<FixedI128<Frac>>) -> Wrapping<FixedI128<Frac>>

Performs the | operation.

impl<'a, 'b, Frac> BitOr<&'a Wrapping<FixedI128<Frac>>> for &'b Wrapping<FixedI128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

type Output = Wrapping<FixedI128<Frac>>

The resulting type after applying the | operator.

fn bitor(self, other: &Wrapping<FixedI128<Frac>>) -> Wrapping<FixedI128<Frac>>

Performs the | operation.

impl<Frac> BitOr<Wrapping<FixedU8<Frac>>> for Wrapping<FixedU8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

type Output = Wrapping<FixedU8<Frac>>

The resulting type after applying the | operator.

fn bitor(self, other: Wrapping<FixedU8<Frac>>) -> Wrapping<FixedU8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

Performs the | operation.

impl<'a, Frac> BitOr<Wrapping<FixedU8<Frac>>> for &'a Wrapping<FixedU8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

type Output = Wrapping<FixedU8<Frac>>

The resulting type after applying the | operator.

fn bitor(self, other: Wrapping<FixedU8<Frac>>) -> Wrapping<FixedU8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

Performs the | operation.

impl<'a, Frac> BitOr<&'a Wrapping<FixedU8<Frac>>> for Wrapping<FixedU8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

type Output = Wrapping<FixedU8<Frac>>

The resulting type after applying the | operator.

fn bitor(self, other: &Wrapping<FixedU8<Frac>>) -> Wrapping<FixedU8<Frac>>

Performs the | operation.

impl<'a, 'b, Frac> BitOr<&'a Wrapping<FixedU8<Frac>>> for &'b Wrapping<FixedU8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

type Output = Wrapping<FixedU8<Frac>>

The resulting type after applying the | operator.

fn bitor(self, other: &Wrapping<FixedU8<Frac>>) -> Wrapping<FixedU8<Frac>>

Performs the | operation.

impl<Frac> BitOr<Wrapping<FixedU16<Frac>>> for Wrapping<FixedU16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

type Output = Wrapping<FixedU16<Frac>>

The resulting type after applying the | operator.

fn bitor(self, other: Wrapping<FixedU16<Frac>>) -> Wrapping<FixedU16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

Performs the | operation.

impl<'a, Frac> BitOr<Wrapping<FixedU16<Frac>>> for &'a Wrapping<FixedU16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

type Output = Wrapping<FixedU16<Frac>>

The resulting type after applying the | operator.

fn bitor(self, other: Wrapping<FixedU16<Frac>>) -> Wrapping<FixedU16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

Performs the | operation.

impl<'a, Frac> BitOr<&'a Wrapping<FixedU16<Frac>>> for Wrapping<FixedU16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

type Output = Wrapping<FixedU16<Frac>>

The resulting type after applying the | operator.

fn bitor(self, other: &Wrapping<FixedU16<Frac>>) -> Wrapping<FixedU16<Frac>>

Performs the | operation.

impl<'a, 'b, Frac> BitOr<&'a Wrapping<FixedU16<Frac>>> for &'b Wrapping<FixedU16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

type Output = Wrapping<FixedU16<Frac>>

The resulting type after applying the | operator.

fn bitor(self, other: &Wrapping<FixedU16<Frac>>) -> Wrapping<FixedU16<Frac>>

Performs the | operation.

impl<Frac> BitOr<Wrapping<FixedU32<Frac>>> for Wrapping<FixedU32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

type Output = Wrapping<FixedU32<Frac>>

The resulting type after applying the | operator.

fn bitor(self, other: Wrapping<FixedU32<Frac>>) -> Wrapping<FixedU32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

Performs the | operation.

impl<'a, Frac> BitOr<Wrapping<FixedU32<Frac>>> for &'a Wrapping<FixedU32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

type Output = Wrapping<FixedU32<Frac>>

The resulting type after applying the | operator.

fn bitor(self, other: Wrapping<FixedU32<Frac>>) -> Wrapping<FixedU32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

Performs the | operation.

impl<'a, Frac> BitOr<&'a Wrapping<FixedU32<Frac>>> for Wrapping<FixedU32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

type Output = Wrapping<FixedU32<Frac>>

The resulting type after applying the | operator.

fn bitor(self, other: &Wrapping<FixedU32<Frac>>) -> Wrapping<FixedU32<Frac>>

Performs the | operation.

impl<'a, 'b, Frac> BitOr<&'a Wrapping<FixedU32<Frac>>> for &'b Wrapping<FixedU32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

type Output = Wrapping<FixedU32<Frac>>

The resulting type after applying the | operator.

fn bitor(self, other: &Wrapping<FixedU32<Frac>>) -> Wrapping<FixedU32<Frac>>

Performs the | operation.

impl<Frac> BitOr<Wrapping<FixedU64<Frac>>> for Wrapping<FixedU64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

type Output = Wrapping<FixedU64<Frac>>

The resulting type after applying the | operator.

fn bitor(self, other: Wrapping<FixedU64<Frac>>) -> Wrapping<FixedU64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

Performs the | operation.

impl<'a, Frac> BitOr<Wrapping<FixedU64<Frac>>> for &'a Wrapping<FixedU64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

type Output = Wrapping<FixedU64<Frac>>

The resulting type after applying the | operator.

fn bitor(self, other: Wrapping<FixedU64<Frac>>) -> Wrapping<FixedU64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

Performs the | operation.

impl<'a, Frac> BitOr<&'a Wrapping<FixedU64<Frac>>> for Wrapping<FixedU64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

type Output = Wrapping<FixedU64<Frac>>

The resulting type after applying the | operator.

fn bitor(self, other: &Wrapping<FixedU64<Frac>>) -> Wrapping<FixedU64<Frac>>

Performs the | operation.

impl<'a, 'b, Frac> BitOr<&'a Wrapping<FixedU64<Frac>>> for &'b Wrapping<FixedU64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

type Output = Wrapping<FixedU64<Frac>>

The resulting type after applying the | operator.

fn bitor(self, other: &Wrapping<FixedU64<Frac>>) -> Wrapping<FixedU64<Frac>>

Performs the | operation.

impl<Frac> BitOr<Wrapping<FixedU128<Frac>>> for Wrapping<FixedU128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

type Output = Wrapping<FixedU128<Frac>>

The resulting type after applying the | operator.

fn bitor(self, other: Wrapping<FixedU128<Frac>>) -> Wrapping<FixedU128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

Performs the | operation.

impl<'a, Frac> BitOr<Wrapping<FixedU128<Frac>>> for &'a Wrapping<FixedU128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

type Output = Wrapping<FixedU128<Frac>>

The resulting type after applying the | operator.

fn bitor(self, other: Wrapping<FixedU128<Frac>>) -> Wrapping<FixedU128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

Performs the | operation.

impl<'a, Frac> BitOr<&'a Wrapping<FixedU128<Frac>>> for Wrapping<FixedU128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

type Output = Wrapping<FixedU128<Frac>>

The resulting type after applying the | operator.

fn bitor(self, other: &Wrapping<FixedU128<Frac>>) -> Wrapping<FixedU128<Frac>>

Performs the | operation.

impl<'a, 'b, Frac> BitOr<&'a Wrapping<FixedU128<Frac>>> for &'b Wrapping<FixedU128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

type Output = Wrapping<FixedU128<Frac>>

The resulting type after applying the | operator.

fn bitor(self, other: &Wrapping<FixedU128<Frac>>) -> Wrapping<FixedU128<Frac>>

Performs the | operation.

impl<Frac> BitXor<Wrapping<FixedI8<Frac>>> for Wrapping<FixedI8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

type Output = Wrapping<FixedI8<Frac>>

The resulting type after applying the ^ operator.

fn bitxor(self, other: Wrapping<FixedI8<Frac>>) -> Wrapping<FixedI8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

Performs the ^ operation.

impl<'a, Frac> BitXor<Wrapping<FixedI8<Frac>>> for &'a Wrapping<FixedI8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

type Output = Wrapping<FixedI8<Frac>>

The resulting type after applying the ^ operator.

fn bitxor(self, other: Wrapping<FixedI8<Frac>>) -> Wrapping<FixedI8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

Performs the ^ operation.

impl<'a, Frac> BitXor<&'a Wrapping<FixedI8<Frac>>> for Wrapping<FixedI8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

type Output = Wrapping<FixedI8<Frac>>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &Wrapping<FixedI8<Frac>>) -> Wrapping<FixedI8<Frac>>

Performs the ^ operation.

impl<'a, 'b, Frac> BitXor<&'a Wrapping<FixedI8<Frac>>> for &'b Wrapping<FixedI8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

type Output = Wrapping<FixedI8<Frac>>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &Wrapping<FixedI8<Frac>>) -> Wrapping<FixedI8<Frac>>

Performs the ^ operation.

impl<Frac> BitXor<Wrapping<FixedI16<Frac>>> for Wrapping<FixedI16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

type Output = Wrapping<FixedI16<Frac>>

The resulting type after applying the ^ operator.

fn bitxor(self, other: Wrapping<FixedI16<Frac>>) -> Wrapping<FixedI16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

Performs the ^ operation.

impl<'a, Frac> BitXor<Wrapping<FixedI16<Frac>>> for &'a Wrapping<FixedI16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

type Output = Wrapping<FixedI16<Frac>>

The resulting type after applying the ^ operator.

fn bitxor(self, other: Wrapping<FixedI16<Frac>>) -> Wrapping<FixedI16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

Performs the ^ operation.

impl<'a, Frac> BitXor<&'a Wrapping<FixedI16<Frac>>> for Wrapping<FixedI16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

type Output = Wrapping<FixedI16<Frac>>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &Wrapping<FixedI16<Frac>>) -> Wrapping<FixedI16<Frac>>

Performs the ^ operation.

impl<'a, 'b, Frac> BitXor<&'a Wrapping<FixedI16<Frac>>> for &'b Wrapping<FixedI16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

type Output = Wrapping<FixedI16<Frac>>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &Wrapping<FixedI16<Frac>>) -> Wrapping<FixedI16<Frac>>

Performs the ^ operation.

impl<Frac> BitXor<Wrapping<FixedI32<Frac>>> for Wrapping<FixedI32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

type Output = Wrapping<FixedI32<Frac>>

The resulting type after applying the ^ operator.

fn bitxor(self, other: Wrapping<FixedI32<Frac>>) -> Wrapping<FixedI32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

Performs the ^ operation.

impl<'a, Frac> BitXor<Wrapping<FixedI32<Frac>>> for &'a Wrapping<FixedI32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

type Output = Wrapping<FixedI32<Frac>>

The resulting type after applying the ^ operator.

fn bitxor(self, other: Wrapping<FixedI32<Frac>>) -> Wrapping<FixedI32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

Performs the ^ operation.

impl<'a, Frac> BitXor<&'a Wrapping<FixedI32<Frac>>> for Wrapping<FixedI32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

type Output = Wrapping<FixedI32<Frac>>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &Wrapping<FixedI32<Frac>>) -> Wrapping<FixedI32<Frac>>

Performs the ^ operation.

impl<'a, 'b, Frac> BitXor<&'a Wrapping<FixedI32<Frac>>> for &'b Wrapping<FixedI32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

type Output = Wrapping<FixedI32<Frac>>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &Wrapping<FixedI32<Frac>>) -> Wrapping<FixedI32<Frac>>

Performs the ^ operation.

impl<Frac> BitXor<Wrapping<FixedI64<Frac>>> for Wrapping<FixedI64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

type Output = Wrapping<FixedI64<Frac>>

The resulting type after applying the ^ operator.

fn bitxor(self, other: Wrapping<FixedI64<Frac>>) -> Wrapping<FixedI64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

Performs the ^ operation.

impl<'a, Frac> BitXor<Wrapping<FixedI64<Frac>>> for &'a Wrapping<FixedI64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

type Output = Wrapping<FixedI64<Frac>>

The resulting type after applying the ^ operator.

fn bitxor(self, other: Wrapping<FixedI64<Frac>>) -> Wrapping<FixedI64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

Performs the ^ operation.

impl<'a, Frac> BitXor<&'a Wrapping<FixedI64<Frac>>> for Wrapping<FixedI64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

type Output = Wrapping<FixedI64<Frac>>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &Wrapping<FixedI64<Frac>>) -> Wrapping<FixedI64<Frac>>

Performs the ^ operation.

impl<'a, 'b, Frac> BitXor<&'a Wrapping<FixedI64<Frac>>> for &'b Wrapping<FixedI64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

type Output = Wrapping<FixedI64<Frac>>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &Wrapping<FixedI64<Frac>>) -> Wrapping<FixedI64<Frac>>

Performs the ^ operation.

impl<Frac> BitXor<Wrapping<FixedI128<Frac>>> for Wrapping<FixedI128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

type Output = Wrapping<FixedI128<Frac>>

The resulting type after applying the ^ operator.

fn bitxor(self, other: Wrapping<FixedI128<Frac>>) -> Wrapping<FixedI128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

Performs the ^ operation.

impl<'a, Frac> BitXor<Wrapping<FixedI128<Frac>>> for &'a Wrapping<FixedI128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

type Output = Wrapping<FixedI128<Frac>>

The resulting type after applying the ^ operator.

fn bitxor(self, other: Wrapping<FixedI128<Frac>>) -> Wrapping<FixedI128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

Performs the ^ operation.

impl<'a, Frac> BitXor<&'a Wrapping<FixedI128<Frac>>> for Wrapping<FixedI128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

type Output = Wrapping<FixedI128<Frac>>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &Wrapping<FixedI128<Frac>>) -> Wrapping<FixedI128<Frac>>

Performs the ^ operation.

impl<'a, 'b, Frac> BitXor<&'a Wrapping<FixedI128<Frac>>> for &'b Wrapping<FixedI128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

type Output = Wrapping<FixedI128<Frac>>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &Wrapping<FixedI128<Frac>>) -> Wrapping<FixedI128<Frac>>

Performs the ^ operation.

impl<Frac> BitXor<Wrapping<FixedU8<Frac>>> for Wrapping<FixedU8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

type Output = Wrapping<FixedU8<Frac>>

The resulting type after applying the ^ operator.

fn bitxor(self, other: Wrapping<FixedU8<Frac>>) -> Wrapping<FixedU8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

Performs the ^ operation.

impl<'a, Frac> BitXor<Wrapping<FixedU8<Frac>>> for &'a Wrapping<FixedU8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

type Output = Wrapping<FixedU8<Frac>>

The resulting type after applying the ^ operator.

fn bitxor(self, other: Wrapping<FixedU8<Frac>>) -> Wrapping<FixedU8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

Performs the ^ operation.

impl<'a, Frac> BitXor<&'a Wrapping<FixedU8<Frac>>> for Wrapping<FixedU8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

type Output = Wrapping<FixedU8<Frac>>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &Wrapping<FixedU8<Frac>>) -> Wrapping<FixedU8<Frac>>

Performs the ^ operation.

impl<'a, 'b, Frac> BitXor<&'a Wrapping<FixedU8<Frac>>> for &'b Wrapping<FixedU8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

type Output = Wrapping<FixedU8<Frac>>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &Wrapping<FixedU8<Frac>>) -> Wrapping<FixedU8<Frac>>

Performs the ^ operation.

impl<Frac> BitXor<Wrapping<FixedU16<Frac>>> for Wrapping<FixedU16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

type Output = Wrapping<FixedU16<Frac>>

The resulting type after applying the ^ operator.

fn bitxor(self, other: Wrapping<FixedU16<Frac>>) -> Wrapping<FixedU16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

Performs the ^ operation.

impl<'a, Frac> BitXor<Wrapping<FixedU16<Frac>>> for &'a Wrapping<FixedU16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

type Output = Wrapping<FixedU16<Frac>>

The resulting type after applying the ^ operator.

fn bitxor(self, other: Wrapping<FixedU16<Frac>>) -> Wrapping<FixedU16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

Performs the ^ operation.

impl<'a, Frac> BitXor<&'a Wrapping<FixedU16<Frac>>> for Wrapping<FixedU16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

type Output = Wrapping<FixedU16<Frac>>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &Wrapping<FixedU16<Frac>>) -> Wrapping<FixedU16<Frac>>

Performs the ^ operation.

impl<'a, 'b, Frac> BitXor<&'a Wrapping<FixedU16<Frac>>> for &'b Wrapping<FixedU16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

type Output = Wrapping<FixedU16<Frac>>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &Wrapping<FixedU16<Frac>>) -> Wrapping<FixedU16<Frac>>

Performs the ^ operation.

impl<Frac> BitXor<Wrapping<FixedU32<Frac>>> for Wrapping<FixedU32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

type Output = Wrapping<FixedU32<Frac>>

The resulting type after applying the ^ operator.

fn bitxor(self, other: Wrapping<FixedU32<Frac>>) -> Wrapping<FixedU32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

Performs the ^ operation.

impl<'a, Frac> BitXor<Wrapping<FixedU32<Frac>>> for &'a Wrapping<FixedU32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

type Output = Wrapping<FixedU32<Frac>>

The resulting type after applying the ^ operator.

fn bitxor(self, other: Wrapping<FixedU32<Frac>>) -> Wrapping<FixedU32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

Performs the ^ operation.

impl<'a, Frac> BitXor<&'a Wrapping<FixedU32<Frac>>> for Wrapping<FixedU32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

type Output = Wrapping<FixedU32<Frac>>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &Wrapping<FixedU32<Frac>>) -> Wrapping<FixedU32<Frac>>

Performs the ^ operation.

impl<'a, 'b, Frac> BitXor<&'a Wrapping<FixedU32<Frac>>> for &'b Wrapping<FixedU32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

type Output = Wrapping<FixedU32<Frac>>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &Wrapping<FixedU32<Frac>>) -> Wrapping<FixedU32<Frac>>

Performs the ^ operation.

impl<Frac> BitXor<Wrapping<FixedU64<Frac>>> for Wrapping<FixedU64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

type Output = Wrapping<FixedU64<Frac>>

The resulting type after applying the ^ operator.

fn bitxor(self, other: Wrapping<FixedU64<Frac>>) -> Wrapping<FixedU64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

Performs the ^ operation.

impl<'a, Frac> BitXor<Wrapping<FixedU64<Frac>>> for &'a Wrapping<FixedU64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

type Output = Wrapping<FixedU64<Frac>>

The resulting type after applying the ^ operator.

fn bitxor(self, other: Wrapping<FixedU64<Frac>>) -> Wrapping<FixedU64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

Performs the ^ operation.

impl<'a, Frac> BitXor<&'a Wrapping<FixedU64<Frac>>> for Wrapping<FixedU64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

type Output = Wrapping<FixedU64<Frac>>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &Wrapping<FixedU64<Frac>>) -> Wrapping<FixedU64<Frac>>

Performs the ^ operation.

impl<'a, 'b, Frac> BitXor<&'a Wrapping<FixedU64<Frac>>> for &'b Wrapping<FixedU64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

type Output = Wrapping<FixedU64<Frac>>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &Wrapping<FixedU64<Frac>>) -> Wrapping<FixedU64<Frac>>

Performs the ^ operation.

impl<Frac> BitXor<Wrapping<FixedU128<Frac>>> for Wrapping<FixedU128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

type Output = Wrapping<FixedU128<Frac>>

The resulting type after applying the ^ operator.

fn bitxor(self, other: Wrapping<FixedU128<Frac>>) -> Wrapping<FixedU128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

Performs the ^ operation.

impl<'a, Frac> BitXor<Wrapping<FixedU128<Frac>>> for &'a Wrapping<FixedU128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

type Output = Wrapping<FixedU128<Frac>>

The resulting type after applying the ^ operator.

fn bitxor(self, other: Wrapping<FixedU128<Frac>>) -> Wrapping<FixedU128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

Performs the ^ operation.

impl<'a, Frac> BitXor<&'a Wrapping<FixedU128<Frac>>> for Wrapping<FixedU128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

type Output = Wrapping<FixedU128<Frac>>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &Wrapping<FixedU128<Frac>>) -> Wrapping<FixedU128<Frac>>

Performs the ^ operation.

impl<'a, 'b, Frac> BitXor<&'a Wrapping<FixedU128<Frac>>> for &'b Wrapping<FixedU128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

type Output = Wrapping<FixedU128<Frac>>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &Wrapping<FixedU128<Frac>>) -> Wrapping<FixedU128<Frac>>

Performs the ^ operation.

impl<Frac> Shl<usize> for Wrapping<FixedI8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

type Output = Wrapping<FixedI8<Frac>>

The resulting type after applying the << operator.

fn shl(self, other: usize) -> Wrapping<FixedI8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

Performs the << operation.

impl<Frac> Shl<usize> for Wrapping<FixedI16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

type Output = Wrapping<FixedI16<Frac>>

The resulting type after applying the << operator.

fn shl(self, other: usize) -> Wrapping<FixedI16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

Performs the << operation.

impl<Frac> Shl<usize> for Wrapping<FixedI32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

type Output = Wrapping<FixedI32<Frac>>

The resulting type after applying the << operator.

fn shl(self, other: usize) -> Wrapping<FixedI32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

Performs the << operation.

impl<Frac> Shl<usize> for Wrapping<FixedI64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

type Output = Wrapping<FixedI64<Frac>>

The resulting type after applying the << operator.

fn shl(self, other: usize) -> Wrapping<FixedI64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

Performs the << operation.

impl<Frac> Shl<usize> for Wrapping<FixedI128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

type Output = Wrapping<FixedI128<Frac>>

The resulting type after applying the << operator.

fn shl(self, other: usize) -> Wrapping<FixedI128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

Performs the << operation.

impl<Frac> Shl<usize> for Wrapping<FixedU8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

type Output = Wrapping<FixedU8<Frac>>

The resulting type after applying the << operator.

fn shl(self, other: usize) -> Wrapping<FixedU8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

Performs the << operation.

impl<Frac> Shl<usize> for Wrapping<FixedU16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

type Output = Wrapping<FixedU16<Frac>>

The resulting type after applying the << operator.

fn shl(self, other: usize) -> Wrapping<FixedU16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

Performs the << operation.

impl<Frac> Shl<usize> for Wrapping<FixedU32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

type Output = Wrapping<FixedU32<Frac>>

The resulting type after applying the << operator.

fn shl(self, other: usize) -> Wrapping<FixedU32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

Performs the << operation.

impl<Frac> Shl<usize> for Wrapping<FixedU64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

type Output = Wrapping<FixedU64<Frac>>

The resulting type after applying the << operator.

fn shl(self, other: usize) -> Wrapping<FixedU64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

Performs the << operation.

impl<Frac> Shl<usize> for Wrapping<FixedU128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

type Output = Wrapping<FixedU128<Frac>>

The resulting type after applying the << operator.

fn shl(self, other: usize) -> Wrapping<FixedU128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

Performs the << operation.

impl<Frac> Shr<usize> for Wrapping<FixedI8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

type Output = Wrapping<FixedI8<Frac>>

The resulting type after applying the >> operator.

fn shr(self, other: usize) -> Wrapping<FixedI8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

Performs the >> operation.

impl<Frac> Shr<usize> for Wrapping<FixedI16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

type Output = Wrapping<FixedI16<Frac>>

The resulting type after applying the >> operator.

fn shr(self, other: usize) -> Wrapping<FixedI16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

Performs the >> operation.

impl<Frac> Shr<usize> for Wrapping<FixedI32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

type Output = Wrapping<FixedI32<Frac>>

The resulting type after applying the >> operator.

fn shr(self, other: usize) -> Wrapping<FixedI32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

Performs the >> operation.

impl<Frac> Shr<usize> for Wrapping<FixedI64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

type Output = Wrapping<FixedI64<Frac>>

The resulting type after applying the >> operator.

fn shr(self, other: usize) -> Wrapping<FixedI64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

Performs the >> operation.

impl<Frac> Shr<usize> for Wrapping<FixedI128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

type Output = Wrapping<FixedI128<Frac>>

The resulting type after applying the >> operator.

fn shr(self, other: usize) -> Wrapping<FixedI128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

Performs the >> operation.

impl<Frac> Shr<usize> for Wrapping<FixedU8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

type Output = Wrapping<FixedU8<Frac>>

The resulting type after applying the >> operator.

fn shr(self, other: usize) -> Wrapping<FixedU8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

Performs the >> operation.

impl<Frac> Shr<usize> for Wrapping<FixedU16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

type Output = Wrapping<FixedU16<Frac>>

The resulting type after applying the >> operator.

fn shr(self, other: usize) -> Wrapping<FixedU16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

Performs the >> operation.

impl<Frac> Shr<usize> for Wrapping<FixedU32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

type Output = Wrapping<FixedU32<Frac>>

The resulting type after applying the >> operator.

fn shr(self, other: usize) -> Wrapping<FixedU32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

Performs the >> operation.

impl<Frac> Shr<usize> for Wrapping<FixedU64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

type Output = Wrapping<FixedU64<Frac>>

The resulting type after applying the >> operator.

fn shr(self, other: usize) -> Wrapping<FixedU64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

Performs the >> operation.

impl<Frac> Shr<usize> for Wrapping<FixedU128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

type Output = Wrapping<FixedU128<Frac>>

The resulting type after applying the >> operator.

fn shr(self, other: usize) -> Wrapping<FixedU128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

Performs the >> operation.

impl<Frac> BitAndAssign<Wrapping<FixedI8<Frac>>> for Wrapping<FixedI8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

fn bitand_assign(&mut self, other: Wrapping<FixedI8<Frac>>)

Performs the &= operation.

impl<'a, Frac> BitAndAssign<&'a Wrapping<FixedI8<Frac>>> for Wrapping<FixedI8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

fn bitand_assign(&mut self, other: &Wrapping<FixedI8<Frac>>)

Performs the &= operation.

impl<Frac> BitAndAssign<Wrapping<FixedI16<Frac>>> for Wrapping<FixedI16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

fn bitand_assign(&mut self, other: Wrapping<FixedI16<Frac>>)

Performs the &= operation.

impl<'a, Frac> BitAndAssign<&'a Wrapping<FixedI16<Frac>>> for Wrapping<FixedI16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

fn bitand_assign(&mut self, other: &Wrapping<FixedI16<Frac>>)

Performs the &= operation.

impl<Frac> BitAndAssign<Wrapping<FixedI32<Frac>>> for Wrapping<FixedI32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

fn bitand_assign(&mut self, other: Wrapping<FixedI32<Frac>>)

Performs the &= operation.

impl<'a, Frac> BitAndAssign<&'a Wrapping<FixedI32<Frac>>> for Wrapping<FixedI32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

fn bitand_assign(&mut self, other: &Wrapping<FixedI32<Frac>>)

Performs the &= operation.

impl<Frac> BitAndAssign<Wrapping<FixedI64<Frac>>> for Wrapping<FixedI64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

fn bitand_assign(&mut self, other: Wrapping<FixedI64<Frac>>)

Performs the &= operation.

impl<'a, Frac> BitAndAssign<&'a Wrapping<FixedI64<Frac>>> for Wrapping<FixedI64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

fn bitand_assign(&mut self, other: &Wrapping<FixedI64<Frac>>)

Performs the &= operation.

impl<Frac> BitAndAssign<Wrapping<FixedI128<Frac>>> for Wrapping<FixedI128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

fn bitand_assign(&mut self, other: Wrapping<FixedI128<Frac>>)

Performs the &= operation.

impl<'a, Frac> BitAndAssign<&'a Wrapping<FixedI128<Frac>>> for Wrapping<FixedI128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

fn bitand_assign(&mut self, other: &Wrapping<FixedI128<Frac>>)

Performs the &= operation.

impl<Frac> BitAndAssign<Wrapping<FixedU8<Frac>>> for Wrapping<FixedU8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

fn bitand_assign(&mut self, other: Wrapping<FixedU8<Frac>>)

Performs the &= operation.

impl<'a, Frac> BitAndAssign<&'a Wrapping<FixedU8<Frac>>> for Wrapping<FixedU8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

fn bitand_assign(&mut self, other: &Wrapping<FixedU8<Frac>>)

Performs the &= operation.

impl<Frac> BitAndAssign<Wrapping<FixedU16<Frac>>> for Wrapping<FixedU16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

fn bitand_assign(&mut self, other: Wrapping<FixedU16<Frac>>)

Performs the &= operation.

impl<'a, Frac> BitAndAssign<&'a Wrapping<FixedU16<Frac>>> for Wrapping<FixedU16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

fn bitand_assign(&mut self, other: &Wrapping<FixedU16<Frac>>)

Performs the &= operation.

impl<Frac> BitAndAssign<Wrapping<FixedU32<Frac>>> for Wrapping<FixedU32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

fn bitand_assign(&mut self, other: Wrapping<FixedU32<Frac>>)

Performs the &= operation.

impl<'a, Frac> BitAndAssign<&'a Wrapping<FixedU32<Frac>>> for Wrapping<FixedU32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

fn bitand_assign(&mut self, other: &Wrapping<FixedU32<Frac>>)

Performs the &= operation.

impl<Frac> BitAndAssign<Wrapping<FixedU64<Frac>>> for Wrapping<FixedU64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

fn bitand_assign(&mut self, other: Wrapping<FixedU64<Frac>>)

Performs the &= operation.

impl<'a, Frac> BitAndAssign<&'a Wrapping<FixedU64<Frac>>> for Wrapping<FixedU64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

fn bitand_assign(&mut self, other: &Wrapping<FixedU64<Frac>>)

Performs the &= operation.

impl<Frac> BitAndAssign<Wrapping<FixedU128<Frac>>> for Wrapping<FixedU128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

fn bitand_assign(&mut self, other: Wrapping<FixedU128<Frac>>)

Performs the &= operation.

impl<'a, Frac> BitAndAssign<&'a Wrapping<FixedU128<Frac>>> for Wrapping<FixedU128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

fn bitand_assign(&mut self, other: &Wrapping<FixedU128<Frac>>)

Performs the &= operation.

impl<Frac> BitOrAssign<Wrapping<FixedI8<Frac>>> for Wrapping<FixedI8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

fn bitor_assign(&mut self, other: Wrapping<FixedI8<Frac>>)

Performs the |= operation.

impl<'a, Frac> BitOrAssign<&'a Wrapping<FixedI8<Frac>>> for Wrapping<FixedI8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

fn bitor_assign(&mut self, other: &Wrapping<FixedI8<Frac>>)

Performs the |= operation.

impl<Frac> BitOrAssign<Wrapping<FixedI16<Frac>>> for Wrapping<FixedI16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

fn bitor_assign(&mut self, other: Wrapping<FixedI16<Frac>>)

Performs the |= operation.

impl<'a, Frac> BitOrAssign<&'a Wrapping<FixedI16<Frac>>> for Wrapping<FixedI16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

fn bitor_assign(&mut self, other: &Wrapping<FixedI16<Frac>>)

Performs the |= operation.

impl<Frac> BitOrAssign<Wrapping<FixedI32<Frac>>> for Wrapping<FixedI32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

fn bitor_assign(&mut self, other: Wrapping<FixedI32<Frac>>)

Performs the |= operation.

impl<'a, Frac> BitOrAssign<&'a Wrapping<FixedI32<Frac>>> for Wrapping<FixedI32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

fn bitor_assign(&mut self, other: &Wrapping<FixedI32<Frac>>)

Performs the |= operation.

impl<Frac> BitOrAssign<Wrapping<FixedI64<Frac>>> for Wrapping<FixedI64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

fn bitor_assign(&mut self, other: Wrapping<FixedI64<Frac>>)

Performs the |= operation.

impl<'a, Frac> BitOrAssign<&'a Wrapping<FixedI64<Frac>>> for Wrapping<FixedI64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

fn bitor_assign(&mut self, other: &Wrapping<FixedI64<Frac>>)

Performs the |= operation.

impl<Frac> BitOrAssign<Wrapping<FixedI128<Frac>>> for Wrapping<FixedI128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

fn bitor_assign(&mut self, other: Wrapping<FixedI128<Frac>>)

Performs the |= operation.

impl<'a, Frac> BitOrAssign<&'a Wrapping<FixedI128<Frac>>> for Wrapping<FixedI128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

fn bitor_assign(&mut self, other: &Wrapping<FixedI128<Frac>>)

Performs the |= operation.

impl<Frac> BitOrAssign<Wrapping<FixedU8<Frac>>> for Wrapping<FixedU8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

fn bitor_assign(&mut self, other: Wrapping<FixedU8<Frac>>)

Performs the |= operation.

impl<'a, Frac> BitOrAssign<&'a Wrapping<FixedU8<Frac>>> for Wrapping<FixedU8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

fn bitor_assign(&mut self, other: &Wrapping<FixedU8<Frac>>)

Performs the |= operation.

impl<Frac> BitOrAssign<Wrapping<FixedU16<Frac>>> for Wrapping<FixedU16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

fn bitor_assign(&mut self, other: Wrapping<FixedU16<Frac>>)

Performs the |= operation.

impl<'a, Frac> BitOrAssign<&'a Wrapping<FixedU16<Frac>>> for Wrapping<FixedU16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

fn bitor_assign(&mut self, other: &Wrapping<FixedU16<Frac>>)

Performs the |= operation.

impl<Frac> BitOrAssign<Wrapping<FixedU32<Frac>>> for Wrapping<FixedU32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

fn bitor_assign(&mut self, other: Wrapping<FixedU32<Frac>>)

Performs the |= operation.

impl<'a, Frac> BitOrAssign<&'a Wrapping<FixedU32<Frac>>> for Wrapping<FixedU32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

fn bitor_assign(&mut self, other: &Wrapping<FixedU32<Frac>>)

Performs the |= operation.

impl<Frac> BitOrAssign<Wrapping<FixedU64<Frac>>> for Wrapping<FixedU64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

fn bitor_assign(&mut self, other: Wrapping<FixedU64<Frac>>)

Performs the |= operation.

impl<'a, Frac> BitOrAssign<&'a Wrapping<FixedU64<Frac>>> for Wrapping<FixedU64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

fn bitor_assign(&mut self, other: &Wrapping<FixedU64<Frac>>)

Performs the |= operation.

impl<Frac> BitOrAssign<Wrapping<FixedU128<Frac>>> for Wrapping<FixedU128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

fn bitor_assign(&mut self, other: Wrapping<FixedU128<Frac>>)

Performs the |= operation.

impl<'a, Frac> BitOrAssign<&'a Wrapping<FixedU128<Frac>>> for Wrapping<FixedU128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

fn bitor_assign(&mut self, other: &Wrapping<FixedU128<Frac>>)

Performs the |= operation.

impl<Frac> BitXorAssign<Wrapping<FixedI8<Frac>>> for Wrapping<FixedI8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

fn bitxor_assign(&mut self, other: Wrapping<FixedI8<Frac>>)

Performs the ^= operation.

impl<'a, Frac> BitXorAssign<&'a Wrapping<FixedI8<Frac>>> for Wrapping<FixedI8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

fn bitxor_assign(&mut self, other: &Wrapping<FixedI8<Frac>>)

Performs the ^= operation.

impl<Frac> BitXorAssign<Wrapping<FixedI16<Frac>>> for Wrapping<FixedI16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

fn bitxor_assign(&mut self, other: Wrapping<FixedI16<Frac>>)

Performs the ^= operation.

impl<'a, Frac> BitXorAssign<&'a Wrapping<FixedI16<Frac>>> for Wrapping<FixedI16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

fn bitxor_assign(&mut self, other: &Wrapping<FixedI16<Frac>>)

Performs the ^= operation.

impl<Frac> BitXorAssign<Wrapping<FixedI32<Frac>>> for Wrapping<FixedI32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

fn bitxor_assign(&mut self, other: Wrapping<FixedI32<Frac>>)

Performs the ^= operation.

impl<'a, Frac> BitXorAssign<&'a Wrapping<FixedI32<Frac>>> for Wrapping<FixedI32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

fn bitxor_assign(&mut self, other: &Wrapping<FixedI32<Frac>>)

Performs the ^= operation.

impl<Frac> BitXorAssign<Wrapping<FixedI64<Frac>>> for Wrapping<FixedI64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

fn bitxor_assign(&mut self, other: Wrapping<FixedI64<Frac>>)

Performs the ^= operation.

impl<'a, Frac> BitXorAssign<&'a Wrapping<FixedI64<Frac>>> for Wrapping<FixedI64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

fn bitxor_assign(&mut self, other: &Wrapping<FixedI64<Frac>>)

Performs the ^= operation.

impl<Frac> BitXorAssign<Wrapping<FixedI128<Frac>>> for Wrapping<FixedI128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

fn bitxor_assign(&mut self, other: Wrapping<FixedI128<Frac>>)

Performs the ^= operation.

impl<'a, Frac> BitXorAssign<&'a Wrapping<FixedI128<Frac>>> for Wrapping<FixedI128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

fn bitxor_assign(&mut self, other: &Wrapping<FixedI128<Frac>>)

Performs the ^= operation.

impl<Frac> BitXorAssign<Wrapping<FixedU8<Frac>>> for Wrapping<FixedU8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

fn bitxor_assign(&mut self, other: Wrapping<FixedU8<Frac>>)

Performs the ^= operation.

impl<'a, Frac> BitXorAssign<&'a Wrapping<FixedU8<Frac>>> for Wrapping<FixedU8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

fn bitxor_assign(&mut self, other: &Wrapping<FixedU8<Frac>>)

Performs the ^= operation.

impl<Frac> BitXorAssign<Wrapping<FixedU16<Frac>>> for Wrapping<FixedU16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

fn bitxor_assign(&mut self, other: Wrapping<FixedU16<Frac>>)

Performs the ^= operation.

impl<'a, Frac> BitXorAssign<&'a Wrapping<FixedU16<Frac>>> for Wrapping<FixedU16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

fn bitxor_assign(&mut self, other: &Wrapping<FixedU16<Frac>>)

Performs the ^= operation.

impl<Frac> BitXorAssign<Wrapping<FixedU32<Frac>>> for Wrapping<FixedU32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

fn bitxor_assign(&mut self, other: Wrapping<FixedU32<Frac>>)

Performs the ^= operation.

impl<'a, Frac> BitXorAssign<&'a Wrapping<FixedU32<Frac>>> for Wrapping<FixedU32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

fn bitxor_assign(&mut self, other: &Wrapping<FixedU32<Frac>>)

Performs the ^= operation.

impl<Frac> BitXorAssign<Wrapping<FixedU64<Frac>>> for Wrapping<FixedU64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

fn bitxor_assign(&mut self, other: Wrapping<FixedU64<Frac>>)

Performs the ^= operation.

impl<'a, Frac> BitXorAssign<&'a Wrapping<FixedU64<Frac>>> for Wrapping<FixedU64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

fn bitxor_assign(&mut self, other: &Wrapping<FixedU64<Frac>>)

Performs the ^= operation.

impl<Frac> BitXorAssign<Wrapping<FixedU128<Frac>>> for Wrapping<FixedU128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

fn bitxor_assign(&mut self, other: Wrapping<FixedU128<Frac>>)

Performs the ^= operation.

impl<'a, Frac> BitXorAssign<&'a Wrapping<FixedU128<Frac>>> for Wrapping<FixedU128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

fn bitxor_assign(&mut self, other: &Wrapping<FixedU128<Frac>>)

Performs the ^= operation.

impl<Frac> ShlAssign<usize> for Wrapping<FixedI8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

fn shl_assign(&mut self, other: usize)

Performs the <<= operation.

impl<'a, Frac> ShlAssign<&'a usize> for Wrapping<FixedI8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

fn shl_assign(&mut self, other: &usize)

Performs the <<= operation.

impl<Frac> ShlAssign<usize> for Wrapping<FixedI16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

fn shl_assign(&mut self, other: usize)

Performs the <<= operation.

impl<'a, Frac> ShlAssign<&'a usize> for Wrapping<FixedI16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

fn shl_assign(&mut self, other: &usize)

Performs the <<= operation.

impl<Frac> ShlAssign<usize> for Wrapping<FixedI32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

fn shl_assign(&mut self, other: usize)

Performs the <<= operation.

impl<'a, Frac> ShlAssign<&'a usize> for Wrapping<FixedI32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

fn shl_assign(&mut self, other: &usize)

Performs the <<= operation.

impl<Frac> ShlAssign<usize> for Wrapping<FixedI64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

fn shl_assign(&mut self, other: usize)

Performs the <<= operation.

impl<'a, Frac> ShlAssign<&'a usize> for Wrapping<FixedI64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

fn shl_assign(&mut self, other: &usize)

Performs the <<= operation.

impl<Frac> ShlAssign<usize> for Wrapping<FixedI128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

fn shl_assign(&mut self, other: usize)

Performs the <<= operation.

impl<'a, Frac> ShlAssign<&'a usize> for Wrapping<FixedI128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

fn shl_assign(&mut self, other: &usize)

Performs the <<= operation.

impl<Frac> ShlAssign<usize> for Wrapping<FixedU8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

fn shl_assign(&mut self, other: usize)

Performs the <<= operation.

impl<'a, Frac> ShlAssign<&'a usize> for Wrapping<FixedU8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

fn shl_assign(&mut self, other: &usize)

Performs the <<= operation.

impl<Frac> ShlAssign<usize> for Wrapping<FixedU16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

fn shl_assign(&mut self, other: usize)

Performs the <<= operation.

impl<'a, Frac> ShlAssign<&'a usize> for Wrapping<FixedU16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

fn shl_assign(&mut self, other: &usize)

Performs the <<= operation.

impl<Frac> ShlAssign<usize> for Wrapping<FixedU32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

fn shl_assign(&mut self, other: usize)

Performs the <<= operation.

impl<'a, Frac> ShlAssign<&'a usize> for Wrapping<FixedU32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

fn shl_assign(&mut self, other: &usize)

Performs the <<= operation.

impl<Frac> ShlAssign<usize> for Wrapping<FixedU64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

fn shl_assign(&mut self, other: usize)

Performs the <<= operation.

impl<'a, Frac> ShlAssign<&'a usize> for Wrapping<FixedU64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

fn shl_assign(&mut self, other: &usize)

Performs the <<= operation.

impl<Frac> ShlAssign<usize> for Wrapping<FixedU128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

fn shl_assign(&mut self, other: usize)

Performs the <<= operation.

impl<'a, Frac> ShlAssign<&'a usize> for Wrapping<FixedU128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

fn shl_assign(&mut self, other: &usize)

Performs the <<= operation.

impl<Frac> ShrAssign<usize> for Wrapping<FixedI8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

fn shr_assign(&mut self, other: usize)

Performs the >>= operation.

impl<'a, Frac> ShrAssign<&'a usize> for Wrapping<FixedI8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

fn shr_assign(&mut self, other: &usize)

Performs the >>= operation.

impl<Frac> ShrAssign<usize> for Wrapping<FixedI16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

fn shr_assign(&mut self, other: usize)

Performs the >>= operation.

impl<'a, Frac> ShrAssign<&'a usize> for Wrapping<FixedI16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

fn shr_assign(&mut self, other: &usize)

Performs the >>= operation.

impl<Frac> ShrAssign<usize> for Wrapping<FixedI32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

fn shr_assign(&mut self, other: usize)

Performs the >>= operation.

impl<'a, Frac> ShrAssign<&'a usize> for Wrapping<FixedI32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

fn shr_assign(&mut self, other: &usize)

Performs the >>= operation.

impl<Frac> ShrAssign<usize> for Wrapping<FixedI64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

fn shr_assign(&mut self, other: usize)

Performs the >>= operation.

impl<'a, Frac> ShrAssign<&'a usize> for Wrapping<FixedI64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

fn shr_assign(&mut self, other: &usize)

Performs the >>= operation.

impl<Frac> ShrAssign<usize> for Wrapping<FixedI128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

fn shr_assign(&mut self, other: usize)

Performs the >>= operation.

impl<'a, Frac> ShrAssign<&'a usize> for Wrapping<FixedI128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

fn shr_assign(&mut self, other: &usize)

Performs the >>= operation.

impl<Frac> ShrAssign<usize> for Wrapping<FixedU8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

fn shr_assign(&mut self, other: usize)

Performs the >>= operation.

impl<'a, Frac> ShrAssign<&'a usize> for Wrapping<FixedU8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

fn shr_assign(&mut self, other: &usize)

Performs the >>= operation.

impl<Frac> ShrAssign<usize> for Wrapping<FixedU16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

fn shr_assign(&mut self, other: usize)

Performs the >>= operation.

impl<'a, Frac> ShrAssign<&'a usize> for Wrapping<FixedU16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

fn shr_assign(&mut self, other: &usize)

Performs the >>= operation.

impl<Frac> ShrAssign<usize> for Wrapping<FixedU32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

fn shr_assign(&mut self, other: usize)

Performs the >>= operation.

impl<'a, Frac> ShrAssign<&'a usize> for Wrapping<FixedU32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

fn shr_assign(&mut self, other: &usize)

Performs the >>= operation.

impl<Frac> ShrAssign<usize> for Wrapping<FixedU64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

fn shr_assign(&mut self, other: usize)

Performs the >>= operation.

impl<'a, Frac> ShrAssign<&'a usize> for Wrapping<FixedU64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

fn shr_assign(&mut self, other: &usize)

Performs the >>= operation.

impl<Frac> ShrAssign<usize> for Wrapping<FixedU128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

fn shr_assign(&mut self, other: usize)

Performs the >>= operation.

impl<'a, Frac> ShrAssign<&'a usize> for Wrapping<FixedU128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

fn shr_assign(&mut self, other: &usize)

Performs the >>= operation.

impl<Frac> Product<Wrapping<FixedI8<Frac>>> for Wrapping<FixedI8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

fn product<I>(iter: I) -> Wrapping<FixedI8<Frac>> where
    I: Iterator<Item = Wrapping<FixedI8<Frac>>>, 

Method which takes an iterator and generates Self from the elements by multiplying the items.

impl<'a, Frac> Product<&'a Wrapping<FixedI8<Frac>>> for Wrapping<FixedI8<Frac>> where
    Frac: 'a + Unsigned + IsLessOrEqual<U8, Output = True>, 

fn product<I>(iter: I) -> Wrapping<FixedI8<Frac>> where
    I: Iterator<Item = &'a Wrapping<FixedI8<Frac>>>, 

Method which takes an iterator and generates Self from the elements by multiplying the items.

impl<Frac> Product<Wrapping<FixedI16<Frac>>> for Wrapping<FixedI16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

fn product<I>(iter: I) -> Wrapping<FixedI16<Frac>> where
    I: Iterator<Item = Wrapping<FixedI16<Frac>>>, 

Method which takes an iterator and generates Self from the elements by multiplying the items.

impl<'a, Frac> Product<&'a Wrapping<FixedI16<Frac>>> for Wrapping<FixedI16<Frac>> where
    Frac: 'a + Unsigned + IsLessOrEqual<U16, Output = True>, 

fn product<I>(iter: I) -> Wrapping<FixedI16<Frac>> where
    I: Iterator<Item = &'a Wrapping<FixedI16<Frac>>>, 

Method which takes an iterator and generates Self from the elements by multiplying the items.

impl<Frac> Product<Wrapping<FixedI32<Frac>>> for Wrapping<FixedI32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

fn product<I>(iter: I) -> Wrapping<FixedI32<Frac>> where
    I: Iterator<Item = Wrapping<FixedI32<Frac>>>, 

Method which takes an iterator and generates Self from the elements by multiplying the items.

impl<'a, Frac> Product<&'a Wrapping<FixedI32<Frac>>> for Wrapping<FixedI32<Frac>> where
    Frac: 'a + Unsigned + IsLessOrEqual<U32, Output = True>, 

fn product<I>(iter: I) -> Wrapping<FixedI32<Frac>> where
    I: Iterator<Item = &'a Wrapping<FixedI32<Frac>>>, 

Method which takes an iterator and generates Self from the elements by multiplying the items.

impl<Frac> Product<Wrapping<FixedI64<Frac>>> for Wrapping<FixedI64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

fn product<I>(iter: I) -> Wrapping<FixedI64<Frac>> where
    I: Iterator<Item = Wrapping<FixedI64<Frac>>>, 

Method which takes an iterator and generates Self from the elements by multiplying the items.

impl<'a, Frac> Product<&'a Wrapping<FixedI64<Frac>>> for Wrapping<FixedI64<Frac>> where
    Frac: 'a + Unsigned + IsLessOrEqual<U64, Output = True>, 

fn product<I>(iter: I) -> Wrapping<FixedI64<Frac>> where
    I: Iterator<Item = &'a Wrapping<FixedI64<Frac>>>, 

Method which takes an iterator and generates Self from the elements by multiplying the items.

impl<Frac> Product<Wrapping<FixedI128<Frac>>> for Wrapping<FixedI128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

fn product<I>(iter: I) -> Wrapping<FixedI128<Frac>> where
    I: Iterator<Item = Wrapping<FixedI128<Frac>>>, 

Method which takes an iterator and generates Self from the elements by multiplying the items.

impl<'a, Frac> Product<&'a Wrapping<FixedI128<Frac>>> for Wrapping<FixedI128<Frac>> where
    Frac: 'a + Unsigned + IsLessOrEqual<U128, Output = True>, 

fn product<I>(iter: I) -> Wrapping<FixedI128<Frac>> where
    I: Iterator<Item = &'a Wrapping<FixedI128<Frac>>>, 

Method which takes an iterator and generates Self from the elements by multiplying the items.

impl<Frac> Product<Wrapping<FixedU8<Frac>>> for Wrapping<FixedU8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

fn product<I>(iter: I) -> Wrapping<FixedU8<Frac>> where
    I: Iterator<Item = Wrapping<FixedU8<Frac>>>, 

Method which takes an iterator and generates Self from the elements by multiplying the items.

impl<'a, Frac> Product<&'a Wrapping<FixedU8<Frac>>> for Wrapping<FixedU8<Frac>> where
    Frac: 'a + Unsigned + IsLessOrEqual<U8, Output = True>, 

fn product<I>(iter: I) -> Wrapping<FixedU8<Frac>> where
    I: Iterator<Item = &'a Wrapping<FixedU8<Frac>>>, 

Method which takes an iterator and generates Self from the elements by multiplying the items.

impl<Frac> Product<Wrapping<FixedU16<Frac>>> for Wrapping<FixedU16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

fn product<I>(iter: I) -> Wrapping<FixedU16<Frac>> where
    I: Iterator<Item = Wrapping<FixedU16<Frac>>>, 

Method which takes an iterator and generates Self from the elements by multiplying the items.

impl<'a, Frac> Product<&'a Wrapping<FixedU16<Frac>>> for Wrapping<FixedU16<Frac>> where
    Frac: 'a + Unsigned + IsLessOrEqual<U16, Output = True>, 

fn product<I>(iter: I) -> Wrapping<FixedU16<Frac>> where
    I: Iterator<Item = &'a Wrapping<FixedU16<Frac>>>, 

Method which takes an iterator and generates Self from the elements by multiplying the items.

impl<Frac> Product<Wrapping<FixedU32<Frac>>> for Wrapping<FixedU32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

fn product<I>(iter: I) -> Wrapping<FixedU32<Frac>> where
    I: Iterator<Item = Wrapping<FixedU32<Frac>>>, 

Method which takes an iterator and generates Self from the elements by multiplying the items.

impl<'a, Frac> Product<&'a Wrapping<FixedU32<Frac>>> for Wrapping<FixedU32<Frac>> where
    Frac: 'a + Unsigned + IsLessOrEqual<U32, Output = True>, 

fn product<I>(iter: I) -> Wrapping<FixedU32<Frac>> where
    I: Iterator<Item = &'a Wrapping<FixedU32<Frac>>>, 

Method which takes an iterator and generates Self from the elements by multiplying the items.

impl<Frac> Product<Wrapping<FixedU64<Frac>>> for Wrapping<FixedU64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

fn product<I>(iter: I) -> Wrapping<FixedU64<Frac>> where
    I: Iterator<Item = Wrapping<FixedU64<Frac>>>, 

Method which takes an iterator and generates Self from the elements by multiplying the items.

impl<'a, Frac> Product<&'a Wrapping<FixedU64<Frac>>> for Wrapping<FixedU64<Frac>> where
    Frac: 'a + Unsigned + IsLessOrEqual<U64, Output = True>, 

fn product<I>(iter: I) -> Wrapping<FixedU64<Frac>> where
    I: Iterator<Item = &'a Wrapping<FixedU64<Frac>>>, 

Method which takes an iterator and generates Self from the elements by multiplying the items.

impl<Frac> Product<Wrapping<FixedU128<Frac>>> for Wrapping<FixedU128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

fn product<I>(iter: I) -> Wrapping<FixedU128<Frac>> where
    I: Iterator<Item = Wrapping<FixedU128<Frac>>>, 

Method which takes an iterator and generates Self from the elements by multiplying the items.

impl<'a, Frac> Product<&'a Wrapping<FixedU128<Frac>>> for Wrapping<FixedU128<Frac>> where
    Frac: 'a + Unsigned + IsLessOrEqual<U128, Output = True>, 

fn product<I>(iter: I) -> Wrapping<FixedU128<Frac>> where
    I: Iterator<Item = &'a Wrapping<FixedU128<Frac>>>, 

Method which takes an iterator and generates Self from the elements by multiplying the items.

impl<Frac> Sum<Wrapping<FixedI8<Frac>>> for Wrapping<FixedI8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

fn sum<I>(iter: I) -> Wrapping<FixedI8<Frac>> where
    I: Iterator<Item = Wrapping<FixedI8<Frac>>>, 

Method which takes an iterator and generates Self from the elements by "summing up" the items.

impl<'a, Frac> Sum<&'a Wrapping<FixedI8<Frac>>> for Wrapping<FixedI8<Frac>> where
    Frac: 'a + Unsigned + IsLessOrEqual<U8, Output = True>, 

fn sum<I>(iter: I) -> Wrapping<FixedI8<Frac>> where
    I: Iterator<Item = &'a Wrapping<FixedI8<Frac>>>, 

Method which takes an iterator and generates Self from the elements by "summing up" the items.

impl<Frac> Sum<Wrapping<FixedI16<Frac>>> for Wrapping<FixedI16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

fn sum<I>(iter: I) -> Wrapping<FixedI16<Frac>> where
    I: Iterator<Item = Wrapping<FixedI16<Frac>>>, 

Method which takes an iterator and generates Self from the elements by "summing up" the items.

impl<'a, Frac> Sum<&'a Wrapping<FixedI16<Frac>>> for Wrapping<FixedI16<Frac>> where
    Frac: 'a + Unsigned + IsLessOrEqual<U16, Output = True>, 

fn sum<I>(iter: I) -> Wrapping<FixedI16<Frac>> where
    I: Iterator<Item = &'a Wrapping<FixedI16<Frac>>>, 

Method which takes an iterator and generates Self from the elements by "summing up" the items.

impl<Frac> Sum<Wrapping<FixedI32<Frac>>> for Wrapping<FixedI32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

fn sum<I>(iter: I) -> Wrapping<FixedI32<Frac>> where
    I: Iterator<Item = Wrapping<FixedI32<Frac>>>, 

Method which takes an iterator and generates Self from the elements by "summing up" the items.

impl<'a, Frac> Sum<&'a Wrapping<FixedI32<Frac>>> for Wrapping<FixedI32<Frac>> where
    Frac: 'a + Unsigned + IsLessOrEqual<U32, Output = True>, 

fn sum<I>(iter: I) -> Wrapping<FixedI32<Frac>> where
    I: Iterator<Item = &'a Wrapping<FixedI32<Frac>>>, 

Method which takes an iterator and generates Self from the elements by "summing up" the items.

impl<Frac> Sum<Wrapping<FixedI64<Frac>>> for Wrapping<FixedI64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

fn sum<I>(iter: I) -> Wrapping<FixedI64<Frac>> where
    I: Iterator<Item = Wrapping<FixedI64<Frac>>>, 

Method which takes an iterator and generates Self from the elements by "summing up" the items.

impl<'a, Frac> Sum<&'a Wrapping<FixedI64<Frac>>> for Wrapping<FixedI64<Frac>> where
    Frac: 'a + Unsigned + IsLessOrEqual<U64, Output = True>, 

fn sum<I>(iter: I) -> Wrapping<FixedI64<Frac>> where
    I: Iterator<Item = &'a Wrapping<FixedI64<Frac>>>, 

Method which takes an iterator and generates Self from the elements by "summing up" the items.

impl<Frac> Sum<Wrapping<FixedI128<Frac>>> for Wrapping<FixedI128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

fn sum<I>(iter: I) -> Wrapping<FixedI128<Frac>> where
    I: Iterator<Item = Wrapping<FixedI128<Frac>>>, 

Method which takes an iterator and generates Self from the elements by "summing up" the items.

impl<'a, Frac> Sum<&'a Wrapping<FixedI128<Frac>>> for Wrapping<FixedI128<Frac>> where
    Frac: 'a + Unsigned + IsLessOrEqual<U128, Output = True>, 

fn sum<I>(iter: I) -> Wrapping<FixedI128<Frac>> where
    I: Iterator<Item = &'a Wrapping<FixedI128<Frac>>>, 

Method which takes an iterator and generates Self from the elements by "summing up" the items.

impl<Frac> Sum<Wrapping<FixedU8<Frac>>> for Wrapping<FixedU8<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U8, Output = True>, 

fn sum<I>(iter: I) -> Wrapping<FixedU8<Frac>> where
    I: Iterator<Item = Wrapping<FixedU8<Frac>>>, 

Method which takes an iterator and generates Self from the elements by "summing up" the items.

impl<'a, Frac> Sum<&'a Wrapping<FixedU8<Frac>>> for Wrapping<FixedU8<Frac>> where
    Frac: 'a + Unsigned + IsLessOrEqual<U8, Output = True>, 

fn sum<I>(iter: I) -> Wrapping<FixedU8<Frac>> where
    I: Iterator<Item = &'a Wrapping<FixedU8<Frac>>>, 

Method which takes an iterator and generates Self from the elements by "summing up" the items.

impl<Frac> Sum<Wrapping<FixedU16<Frac>>> for Wrapping<FixedU16<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U16, Output = True>, 

fn sum<I>(iter: I) -> Wrapping<FixedU16<Frac>> where
    I: Iterator<Item = Wrapping<FixedU16<Frac>>>, 

Method which takes an iterator and generates Self from the elements by "summing up" the items.

impl<'a, Frac> Sum<&'a Wrapping<FixedU16<Frac>>> for Wrapping<FixedU16<Frac>> where
    Frac: 'a + Unsigned + IsLessOrEqual<U16, Output = True>, 

fn sum<I>(iter: I) -> Wrapping<FixedU16<Frac>> where
    I: Iterator<Item = &'a Wrapping<FixedU16<Frac>>>, 

Method which takes an iterator and generates Self from the elements by "summing up" the items.

impl<Frac> Sum<Wrapping<FixedU32<Frac>>> for Wrapping<FixedU32<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U32, Output = True>, 

fn sum<I>(iter: I) -> Wrapping<FixedU32<Frac>> where
    I: Iterator<Item = Wrapping<FixedU32<Frac>>>, 

Method which takes an iterator and generates Self from the elements by "summing up" the items.

impl<'a, Frac> Sum<&'a Wrapping<FixedU32<Frac>>> for Wrapping<FixedU32<Frac>> where
    Frac: 'a + Unsigned + IsLessOrEqual<U32, Output = True>, 

fn sum<I>(iter: I) -> Wrapping<FixedU32<Frac>> where
    I: Iterator<Item = &'a Wrapping<FixedU32<Frac>>>, 

Method which takes an iterator and generates Self from the elements by "summing up" the items.

impl<Frac> Sum<Wrapping<FixedU64<Frac>>> for Wrapping<FixedU64<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U64, Output = True>, 

fn sum<I>(iter: I) -> Wrapping<FixedU64<Frac>> where
    I: Iterator<Item = Wrapping<FixedU64<Frac>>>, 

Method which takes an iterator and generates Self from the elements by "summing up" the items.

impl<'a, Frac> Sum<&'a Wrapping<FixedU64<Frac>>> for Wrapping<FixedU64<Frac>> where
    Frac: 'a + Unsigned + IsLessOrEqual<U64, Output = True>, 

fn sum<I>(iter: I) -> Wrapping<FixedU64<Frac>> where
    I: Iterator<Item = &'a Wrapping<FixedU64<Frac>>>, 

Method which takes an iterator and generates Self from the elements by "summing up" the items.

impl<Frac> Sum<Wrapping<FixedU128<Frac>>> for Wrapping<FixedU128<Frac>> where
    Frac: Unsigned + IsLessOrEqual<U128, Output = True>, 

fn sum<I>(iter: I) -> Wrapping<FixedU128<Frac>> where
    I: Iterator<Item = Wrapping<FixedU128<Frac>>>, 

Method which takes an iterator and generates Self from the elements by "summing up" the items.

impl<'a, Frac> Sum<&'a Wrapping<FixedU128<Frac>>> for Wrapping<FixedU128<Frac>> where
    Frac: 'a + Unsigned + IsLessOrEqual<U128, Output = True>, 

fn sum<I>(iter: I) -> Wrapping<FixedU128<Frac>> where
    I: Iterator<Item = &'a Wrapping<FixedU128<Frac>>>, 

Method which takes an iterator and generates Self from the elements by "summing up" the items.

impl<F> Default for Wrapping<F> where
    F: Fixed, 

fn default() -> Wrapping<F>

Returns the "default value" for a type.