Struct fixed::Wrapping

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

Provides intentionally wrapped arithmetic on fixed-point numbers.

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

Examples

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

Methods

impl<F: Fixed> Wrapping<F>

pub fn min_value() -> Wrapping<F>

Returns the smallest value that can be represented.

Examples

use fixed::{types::I16F16, Wrapping};
assert_eq!(Wrapping::<I16F16>::min_value(), Wrapping(I16F16::min_value()));

pub fn max_value() -> Wrapping<F>

Returns the largest value that can be represented.

Examples

use fixed::{types::I16F16, Wrapping};
assert_eq!(Wrapping::<I16F16>::max_value(), Wrapping(I16F16::max_value()));

pub fn int_nbits() -> u32

Returns the number of integer bits.

Examples

use fixed::{types::I16F16, Wrapping};
assert_eq!(Wrapping::<I16F16>::int_nbits(), I16F16::int_nbits());

pub fn frac_nbits() -> u32

Returns the number of fractional bits.

Examples

use fixed::{types::I16F16, Wrapping};
assert_eq!(Wrapping::<I16F16>::frac_nbits(), I16F16::frac_nbits());

pub fn from_bits(bits: F::Bits) -> Wrapping<F>

Creates a fixed-point number that has a bitwise representation identical to the given integer.

Examples

use fixed::{types::I16F16, Wrapping};
assert_eq!(Wrapping::<I16F16>::from_bits(0x1C), Wrapping(I16F16::from_bits(0x1C)));

pub fn to_bits(self) -> F::Bits

Creates an integer that has a bitwise representation identical to the given fixed-point number.

Examples

use fixed::{types::I16F16, Wrapping};
let w = Wrapping(I16F16::from_bits(0x1C));
assert_eq!(w.to_bits(), 0x1C);

pub fn from_num<Src: ToFixed>(src: Src) -> Wrapping<F>

Wrapping conversion from another number.

The other number can be:

• A fixed-point number. Any extra fractional bits are truncated.
• An integer of type i8, i16, i32, i64, i128, isize, u8, u16, u32, u64, u128, or usize.
• A floating-point number of type f32 or f64. If the f16 feature is enabled, it can also be of type f16 or bf16. For this conversion, the method rounds to the nearest, with ties rounding to even.
• Any other number src for which ToFixed is implemented, in which case this method returns Wrapping(src.wrapping_to_fixed()).

Panics

For floating-point numbers, panics if the value is not finite.

Examples

use fixed::{
    types::{I4F4, I16F16},
    Wrapping,
};

// 0x1234.5678 wraps into 0x4.5
let src = I16F16::from_bits(0x1234_5678);
let dst = Wrapping::<I4F4>::from_num(src);
assert_eq!(dst, Wrapping(I4F4::from_bits(0x45)));

// 0x1234 wraps into 0x4.0
let src_int = 0x1234_i32;
let dst_int = Wrapping::<I4F4>::from_num(src_int);
assert_eq!(dst_int, Wrapping(I4F4::from_bits(0x40)));

// 129.75 wrapped into 1.75 (binary 1.1100)
let src_float = 129.75;
let dst_float = Wrapping::<I4F4>::from_num(src_float);
assert_eq!(dst_float, Wrapping(I4F4::from_bits(0b11100)));

pub fn to_num<Dst: FromFixed>(self) -> Dst

Converts a fixed-point number to another number, wrapping the value on overflow.

The other number can be:

• Another fixed-point number. Any extra fractional bits are truncated.
• An integer of type i8, i16, i32, i64, i128, isize, u8, u16, u32, u64, u128, or usize. Any fractional bits are truncated.
• A floating-point number of type f32 or f64. If the f16 feature is enabled, it can also be of type f16 or bf16. For this conversion, the method rounds to the nearest, with ties rounding to even.
• Any other type Dst for which FromFixed is implemented, in which case this method returns Dst::wrapping_from_fixed(self.0).

Examples

use fixed::{
    types::{I16F16, I2F6, I4F4},
    Wrapping,
};

// conversion that fits
let src = Wrapping(I4F4::from_num(1.75));
let expected = I16F16::from_num(1.75);
assert_eq!(src.to_num::<I16F16>(), expected);

// conversion that wraps
let src = Wrapping(I4F4::max_value());
let wrapped = I2F6::from_bits(I2F6::max_value().to_bits() << 2);
assert_eq!(src.to_num::<I2F6>(), wrapped);

pub fn from_str_binary(src: &str) -> Result<Wrapping<F>, ParseFixedError>

Converts a string slice containing binary digits to a fixed-point number.

Examples

use fixed::{types::I8F8, Wrapping};
let check = Wrapping(I8F8::from_bits(0b1110001 << (8 - 1)));
assert_eq!(Wrapping::<I8F8>::from_str_binary("101100111000.1"), Ok(check));

pub fn from_str_octal(src: &str) -> Result<Wrapping<F>, ParseFixedError>

Converts a string slice containing octal digits to a fixed-point number.

Examples

use fixed::{types::I8F8, Wrapping};
let check = Wrapping(I8F8::from_bits(0o1654 << (8 - 3)));
assert_eq!(Wrapping::<I8F8>::from_str_octal("7165.4"), Ok(check));

pub fn from_str_hex(src: &str) -> Result<Wrapping<F>, ParseFixedError>

Converts a string slice containing hexadecimal digits to a fixed-point number.

Examples

use fixed::{types::I8F8, Wrapping};
let check = Wrapping(I8F8::from_bits(0xFFE));
assert_eq!(Wrapping::<I8F8>::from_str_hex("C0F.FE"), Ok(check));

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

Returns the integer part.

Note that since the numbers are stored in two’s complement, negative numbers with non-zero fractional parts will be rounded towards −∞, except in the case where there are no integer bits, for example for the type Wrapping<I0F16>, where the return value is always zero.

Examples

use fixed::{types::I16F16, Wrapping};
assert_eq!(Wrapping(I16F16::from_num(12.25)).int(), Wrapping(I16F16::from_num(12)));
assert_eq!(Wrapping(I16F16::from_num(-12.25)).int(), Wrapping(I16F16::from_num(-13)));

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

Returns the fractional part.

Note that since the numbers are stored in two’s complement, the returned fraction will be non-negative for negative numbers, except in the case where there are no integer bits, for example for the type Wrapping<I0F16>, where the return value is always equal to self.

Examples

use fixed::{types::I16F16, Wrapping};
assert_eq!(Wrapping(I16F16::from_num(12.25)).frac(), Wrapping(I16F16::from_num(0.25)));
assert_eq!(Wrapping(I16F16::from_num(-12.25)).frac(), Wrapping(I16F16::from_num(0.75)));

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

Rounds to the next integer towards 0.

Examples

use fixed::{types::I16F16, Wrapping};
let three = Wrapping(I16F16::from_num(3));
assert_eq!(Wrapping(I16F16::from_num(3.9)).round_to_zero(), three);
assert_eq!(Wrapping(I16F16::from_num(-3.9)).round_to_zero(), -three);

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

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

Examples

use fixed::{types::I16F16, Wrapping};
let two_half = Wrapping(I16F16::from_num(5) / 2);
assert_eq!(two_half.ceil(), Wrapping(I16F16::from_num(3)));
assert_eq!(Wrapping(I16F16::max_value()).ceil(), Wrapping(I16F16::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::{
    types::{I0F32, I16F16},
    Wrapping,
};
let two_half = Wrapping(I16F16::from_num(5) / 2);
assert_eq!(two_half.floor(), Wrapping(I16F16::from_num(2)));
assert_eq!(Wrapping(I0F32::min_value()).floor(), Wrapping(I0F32::from_num(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::{types::I16F16, Wrapping};
let two_half = Wrapping(I16F16::from_num(5) / 2);
assert_eq!(two_half.round(), Wrapping(I16F16::from_num(3)));
assert_eq!((-two_half).round(), Wrapping(I16F16::from_num(-3)));
assert_eq!(Wrapping(I16F16::max_value()).round(), Wrapping(I16F16::min_value()));

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

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

Examples

use fixed::{types::I16F16, Wrapping};
let two_half = Wrapping(I16F16::from_num(2.5));
assert_eq!(two_half.round_ties_to_even(), Wrapping(I16F16::from_num(2)));
let three_half = Wrapping(I16F16::from_num(3.5));
assert_eq!(three_half.round_ties_to_even(), Wrapping(I16F16::from_num(4)));
let max = Wrapping(I16F16::max_value());
assert_eq!(max.round_ties_to_even(), Wrapping(I16F16::min_value()));

pub fn count_ones(self) -> u32

Returns the number of ones in the binary representation.

Examples

use fixed::{types::I16F16, Wrapping};
let w = Wrapping(I16F16::from_bits(0x00FF_FF00));
assert_eq!(w.count_ones(), w.0.count_ones());

pub fn count_zeros(self) -> u32

Returns the number of zeros in the binary representation.

Examples

use fixed::{types::I16F16, Wrapping};
let w = Wrapping(I16F16::from_bits(0x00FF_FF00));
assert_eq!(w.count_zeros(), w.0.count_zeros());

pub fn leading_zeros(self) -> u32

Returns the number of leading zeros in the binary representation.

Examples

use fixed::{types::I16F16, Wrapping};
let w = Wrapping(I16F16::from_bits(0x00FF_FF00));
assert_eq!(w.leading_zeros(), w.0.leading_zeros());

pub fn trailing_zeros(self) -> u32

Returns the number of trailing zeros in the binary representation.

Examples

use fixed::{types::I16F16, Wrapping};
let w = Wrapping(I16F16::from_bits(0x00FF_FF00));
assert_eq!(w.trailing_zeros(), w.0.trailing_zeros());

pub fn rotate_left(self, n: u32) -> Wrapping<F>

Shifts to the left by n bits, wrapping the truncated bits to the right end.

Examples

use fixed::{types::I16F16, Wrapping};
let i = I16F16::from_bits(0x00FF_FF00);
assert_eq!(Wrapping(i).rotate_left(12), Wrapping(i.rotate_left(12)));

pub fn rotate_right(self, n: u32) -> Wrapping<F>

Shifts to the right by n bits, wrapping the truncated bits to the left end.

Examples

use fixed::{types::I16F16, Wrapping};
let i = I16F16::from_bits(0x00FF_FF00);
assert_eq!(Wrapping(i).rotate_right(12), Wrapping(i.rotate_right(12)));

pub fn div_euclid(self, divisor: Wrapping<F>) -> Wrapping<F>

Euclidean division.

Panics

Panics if the divisor is zero.

Examples

use fixed::{types::I16F16, Wrapping};
let num = Wrapping(I16F16::from_num(7.5));
let den = Wrapping(I16F16::from_num(2));
assert_eq!(num.div_euclid(den), Wrapping(I16F16::from_num(3)));
let quarter = Wrapping(I16F16::from_num(0.25));
let check = (Wrapping::max_value() * 4i32).round_to_zero();
assert_eq!(Wrapping::max_value().div_euclid(quarter), check);

pub fn rem_euclid(self, divisor: Wrapping<F>) -> Wrapping<F>

Remainder for Euclidean division.

Panics

Panics if the divisor is zero.

Examples

use fixed::{types::I16F16, Wrapping};
let num = Wrapping(I16F16::from_num(7.5));
let den = Wrapping(I16F16::from_num(2));
assert_eq!(num.rem_euclid(den), Wrapping(I16F16::from_num(1.5)));
assert_eq!((-num).rem_euclid(den), Wrapping(I16F16::from_num(0.5)));

pub fn div_euclid_int(self, divisor: F::Bits) -> Wrapping<F>

Euclidean division by an integer.

Panics

Panics if the divisor is zero.

Examples

use fixed::{types::I16F16, Wrapping};
let num = Wrapping(I16F16::from_num(7.5));
assert_eq!(num.div_euclid_int(2), Wrapping(I16F16::from_num(3)));
let min = Wrapping(I16F16::min_value());
assert_eq!(min.div_euclid_int(-1), min);

pub fn rem_euclid_int(self, divisor: F::Bits) -> Wrapping<F>

Remainder for Euclidean division.

Panics

Panics if the divisor is zero.

Examples

use fixed::{types::I16F16, Wrapping};
let num = Wrapping(I16F16::from_num(7.5));
assert_eq!(num.rem_euclid_int(2), Wrapping(I16F16::from_num(1.5)));
assert_eq!((-num).rem_euclid_int(2), Wrapping(I16F16::from_num(0.5)));

impl<F: FixedSigned> Wrapping<F>

pub fn is_positive(self) -> bool

Returns true if the number is > 0.

Examples

use fixed::{types::I16F16, Wrapping};
assert!(Wrapping(I16F16::from_num(4.3)).is_positive());
assert!(!Wrapping(I16F16::from_num(0)).is_positive());
assert!(!Wrapping(I16F16::from_num(-4.3)).is_positive());

pub fn is_negative(self) -> bool

Returns true if the number is < 0.

Examples

use fixed::{types::I16F16, Wrapping};
assert!(!Wrapping(I16F16::from_num(4.3)).is_negative());
assert!(!Wrapping(I16F16::from_num(0)).is_negative());
assert!(Wrapping(I16F16::from_num(-4.3)).is_negative());

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

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

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

Examples

use fixed::{types::I16F16, Wrapping};
assert_eq!(Wrapping(I16F16::from_num(-5)).abs(), Wrapping(I16F16::from_num(5)));
assert_eq!(Wrapping(I16F16::min_value()).abs(), Wrapping(I16F16::min_value()));

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

Returns a number representing the sign of self.

Warning

Using this method when 1 and −1 cannot be represented is almost certainly a bug, however, this is allowed and gives the following wrapped results.

• When there are no integer bits, for example for the type Wrapping<I0F16>, the return value is always zero.
• When there is one integer bit, for example for the type Wrapping<I1F15>, the return value is zero when self is zero, and −1 otherwise. This means that for a positive number, −1 is returned, because +1 does not fit and is wrapped to −1.

Examples

use fixed::{types::I16F16, Wrapping};
assert_eq!(Wrapping(<I16F16>::from_num(-3.9)).signum(), Wrapping(I16F16::from_num(-1)));
assert_eq!(Wrapping(<I16F16>::from_num(0)).signum(), Wrapping(I16F16::from_num(0)));
assert_eq!(Wrapping(<I16F16>::from_num(3.9)).signum(), Wrapping(I16F16::from_num(1)));

impl<F: FixedUnsigned> Wrapping<F>

pub fn is_power_of_two(self) -> bool

Returns true if the fixed-point number is 2^k for some integer k.

Examples

use fixed::{types::U16F16, Wrapping};
assert!(Wrapping(U16F16::from_num(0.5)).is_power_of_two());
assert!(Wrapping(U16F16::from_num(4)).is_power_of_two());
assert!(!Wrapping(U16F16::from_num(5)).is_power_of_two());

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

Returns the smallest power of two that is ≥ self.

If the next power of two is too large to fit, it is wrapped to zero.

Examples

use fixed::{types::U16F16, Wrapping};
let half = Wrapping(U16F16::from_num(0.5));
assert_eq!(Wrapping(U16F16::from_num(0.3)).next_power_of_two(), half);
let four = Wrapping(U16F16::from_num(4));
assert_eq!(Wrapping(U16F16::from_num(4)).next_power_of_two(), four);
let zero = Wrapping(U16F16::from_num(0));
assert_eq!(Wrapping(U16F16::max_value()).next_power_of_two(), zero);

Trait Implementations

impl<'a, F: Fixed> Add<&'a Wrapping<F>> for Wrapping<F>

type Output = Wrapping<F>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'a, 'b, F: Fixed> Add<&'a Wrapping<F>> for &'b Wrapping<F>

type Output = Wrapping<F>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<F: Fixed> Add<Wrapping<F>> for Wrapping<F>

type Output = Wrapping<F>

The resulting type after applying the + operator.

fn add(self, other: Wrapping<F>) -> Wrapping<F>

Performs the + operation.

impl<'a, F: Fixed> Add<Wrapping<F>> for &'a Wrapping<F>

type Output = Wrapping<F>

The resulting type after applying the + operator.

fn add(self, other: Wrapping<F>) -> Wrapping<F>

Performs the + operation.

impl<'a, F: Fixed> AddAssign<&'a Wrapping<F>> for Wrapping<F>

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

Performs the += operation.

impl<F: Fixed> AddAssign<Wrapping<F>> for Wrapping<F>

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

Performs the += operation.

impl<'a, F> BitAnd<&'a Wrapping<F>> for Wrapping<F> where
    F: BitAnd<&'a F, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the & operator.

fn bitand(self, other: &'a Wrapping<F>) -> Wrapping<F>

Performs the & operation.

impl<'a, 'b, F> BitAnd<&'a Wrapping<F>> for &'b Wrapping<F> where
    &'b F: BitAnd<&'a F, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the & operator.

fn bitand(self, other: &'a Wrapping<F>) -> Wrapping<F>

Performs the & operation.

impl<F> BitAnd<Wrapping<F>> for Wrapping<F> where
    F: BitAnd<F, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the & operator.

fn bitand(self, other: Wrapping<F>) -> Wrapping<F>

Performs the & operation.

impl<'a, F> BitAnd<Wrapping<F>> for &'a Wrapping<F> where
    &'a F: BitAnd<F, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the & operator.

fn bitand(self, other: Wrapping<F>) -> Wrapping<F>

Performs the & operation.

impl<'a, F> BitAndAssign<&'a Wrapping<F>> for Wrapping<F> where
    F: BitAndAssign<&'a F>, 

fn bitand_assign(&mut self, other: &'a Wrapping<F>)

Performs the &= operation.

impl<F> BitAndAssign<Wrapping<F>> for Wrapping<F> where
    F: BitAndAssign<F>, 

fn bitand_assign(&mut self, other: Wrapping<F>)

Performs the &= operation.

impl<'a, F> BitOr<&'a Wrapping<F>> for Wrapping<F> where
    F: BitOr<&'a F, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the | operator.

fn bitor(self, other: &'a Wrapping<F>) -> Wrapping<F>

Performs the | operation.

impl<'a, 'b, F> BitOr<&'a Wrapping<F>> for &'b Wrapping<F> where
    &'b F: BitOr<&'a F, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the | operator.

fn bitor(self, other: &'a Wrapping<F>) -> Wrapping<F>

Performs the | operation.

impl<F> BitOr<Wrapping<F>> for Wrapping<F> where
    F: BitOr<F, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the | operator.

fn bitor(self, other: Wrapping<F>) -> Wrapping<F>

Performs the | operation.

impl<'a, F> BitOr<Wrapping<F>> for &'a Wrapping<F> where
    &'a F: BitOr<F, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the | operator.

fn bitor(self, other: Wrapping<F>) -> Wrapping<F>

Performs the | operation.

impl<'a, F> BitOrAssign<&'a Wrapping<F>> for Wrapping<F> where
    F: BitOrAssign<&'a F>, 

fn bitor_assign(&mut self, other: &'a Wrapping<F>)

Performs the |= operation.

impl<F> BitOrAssign<Wrapping<F>> for Wrapping<F> where
    F: BitOrAssign<F>, 

fn bitor_assign(&mut self, other: Wrapping<F>)

Performs the |= operation.

impl<'a, F> BitXor<&'a Wrapping<F>> for Wrapping<F> where
    F: BitXor<&'a F, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &'a Wrapping<F>) -> Wrapping<F>

Performs the ^ operation.

impl<'a, 'b, F> BitXor<&'a Wrapping<F>> for &'b Wrapping<F> where
    &'b F: BitXor<&'a F, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &'a Wrapping<F>) -> Wrapping<F>

Performs the ^ operation.

impl<F> BitXor<Wrapping<F>> for Wrapping<F> where
    F: BitXor<F, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the ^ operator.

fn bitxor(self, other: Wrapping<F>) -> Wrapping<F>

Performs the ^ operation.

impl<'a, F> BitXor<Wrapping<F>> for &'a Wrapping<F> where
    &'a F: BitXor<F, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the ^ operator.

fn bitxor(self, other: Wrapping<F>) -> Wrapping<F>

Performs the ^ operation.

impl<'a, F> BitXorAssign<&'a Wrapping<F>> for Wrapping<F> where
    F: BitXorAssign<&'a F>, 

fn bitxor_assign(&mut self, other: &'a Wrapping<F>)

Performs the ^= operation.

impl<F> BitXorAssign<Wrapping<F>> for Wrapping<F> where
    F: BitXorAssign<F>, 

fn bitxor_assign(&mut self, other: Wrapping<F>)

Performs the ^= operation.

impl<F: Clone> Clone for Wrapping<F>

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: Copy> Copy for Wrapping<F>

impl<F: Debug> Debug for Wrapping<F>

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

Formats the value using the given formatter.

impl<F: Default> Default for Wrapping<F>

fn default() -> Wrapping<F>

Returns the "default value" for a type.

impl<'de, Frac: LeEqU8> Deserialize<'de> for Wrapping<FixedI8<Frac>>

fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>

Deserialize this value from the given Serde deserializer.

impl<'de, Frac: LeEqU16> Deserialize<'de> for Wrapping<FixedI16<Frac>>

fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>

Deserialize this value from the given Serde deserializer.

impl<'de, Frac: LeEqU32> Deserialize<'de> for Wrapping<FixedI32<Frac>>

fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>

Deserialize this value from the given Serde deserializer.

impl<'de, Frac: LeEqU64> Deserialize<'de> for Wrapping<FixedI64<Frac>>

fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>

Deserialize this value from the given Serde deserializer.

impl<'de, Frac: LeEqU128> Deserialize<'de> for Wrapping<FixedI128<Frac>>

fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>

Deserialize this value from the given Serde deserializer.

impl<'de, Frac: LeEqU8> Deserialize<'de> for Wrapping<FixedU8<Frac>>

fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>

Deserialize this value from the given Serde deserializer.

impl<'de, Frac: LeEqU16> Deserialize<'de> for Wrapping<FixedU16<Frac>>

fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>

Deserialize this value from the given Serde deserializer.

impl<'de, Frac: LeEqU32> Deserialize<'de> for Wrapping<FixedU32<Frac>>

fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>

Deserialize this value from the given Serde deserializer.

impl<'de, Frac: LeEqU64> Deserialize<'de> for Wrapping<FixedU64<Frac>>

fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>

Deserialize this value from the given Serde deserializer.

impl<'de, Frac: LeEqU128> Deserialize<'de> for Wrapping<FixedU128<Frac>>

fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>

Deserialize this value from the given Serde deserializer.

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

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

Formats the value using the given formatter.

impl<'a, F: Fixed> Div<&'a Wrapping<F>> for Wrapping<F>

type Output = Wrapping<F>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'a, 'b, F: Fixed> Div<&'a Wrapping<F>> for &'b Wrapping<F>

type Output = Wrapping<F>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'a, Frac> Div<&'a i128> for Wrapping<FixedI128<Frac>>

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>>

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 i16> for Wrapping<FixedI16<Frac>>

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>>

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 i32> for Wrapping<FixedI32<Frac>>

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>>

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 i64> for Wrapping<FixedI64<Frac>>

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>>

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 i8> for Wrapping<FixedI8<Frac>>

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>>

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 u128> for Wrapping<FixedU128<Frac>>

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>>

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 u16> for Wrapping<FixedU16<Frac>>

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>>

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 u32> for Wrapping<FixedU32<Frac>>

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>>

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 u64> for Wrapping<FixedU64<Frac>>

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>>

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 u8> for Wrapping<FixedU8<Frac>>

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>>

type Output = Wrapping<FixedU8<Frac>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<F: Fixed> Div<Wrapping<F>> for Wrapping<F>

type Output = Wrapping<F>

The resulting type after applying the / operator.

fn div(self, other: Wrapping<F>) -> Wrapping<F>

Performs the / operation.

impl<'a, F: Fixed> Div<Wrapping<F>> for &'a Wrapping<F>

type Output = Wrapping<F>

The resulting type after applying the / operator.

fn div(self, other: Wrapping<F>) -> Wrapping<F>

Performs the / operation.

impl<Frac> Div<i128> for Wrapping<FixedI128<Frac>>

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>>

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<i16> for Wrapping<FixedI16<Frac>>

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>>

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<i32> for Wrapping<FixedI32<Frac>>

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>>

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<i64> for Wrapping<FixedI64<Frac>>

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>>

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<i8> for Wrapping<FixedI8<Frac>>

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>>

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<u128> for Wrapping<FixedU128<Frac>>

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>>

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> Div<u16> for Wrapping<FixedU16<Frac>>

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>>

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<u32> for Wrapping<FixedU32<Frac>>

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>>

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<u64> for Wrapping<FixedU64<Frac>>

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>>

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<u8> for Wrapping<FixedU8<Frac>>

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>>

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, F: Fixed> DivAssign<&'a Wrapping<F>> for Wrapping<F>

fn div_assign(&mut self, other: &Wrapping<F>)

Performs the /= operation.

impl<'a, Frac> DivAssign<&'a i128> for Wrapping<FixedI128<Frac>>

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

Performs the /= operation.

impl<'a, Frac> DivAssign<&'a i16> for Wrapping<FixedI16<Frac>>

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

Performs the /= operation.

impl<'a, Frac> DivAssign<&'a i32> for Wrapping<FixedI32<Frac>>

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

Performs the /= operation.

impl<'a, Frac> DivAssign<&'a i64> for Wrapping<FixedI64<Frac>>

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

Performs the /= operation.

impl<'a, Frac> DivAssign<&'a i8> for Wrapping<FixedI8<Frac>>

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

Performs the /= operation.

impl<'a, Frac> DivAssign<&'a u128> for Wrapping<FixedU128<Frac>>

fn div_assign(&mut self, other: &u128)

Performs the /= operation.

impl<'a, Frac> DivAssign<&'a u16> for Wrapping<FixedU16<Frac>>

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

Performs the /= operation.

impl<'a, Frac> DivAssign<&'a u32> for Wrapping<FixedU32<Frac>>

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

Performs the /= operation.

impl<'a, Frac> DivAssign<&'a u64> for Wrapping<FixedU64<Frac>>

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

Performs the /= operation.

impl<'a, Frac> DivAssign<&'a u8> for Wrapping<FixedU8<Frac>>

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

Performs the /= operation.

impl<F: Fixed> DivAssign<Wrapping<F>> for Wrapping<F>

fn div_assign(&mut self, other: Wrapping<F>)

Performs the /= operation.

impl<Frac> DivAssign<i128> for Wrapping<FixedI128<Frac>>

fn div_assign(&mut self, other: i128)

Performs the /= operation.

impl<Frac> DivAssign<i16> for Wrapping<FixedI16<Frac>>

fn div_assign(&mut self, other: i16)

Performs the /= operation.

impl<Frac> DivAssign<i32> for Wrapping<FixedI32<Frac>>

fn div_assign(&mut self, other: i32)

Performs the /= operation.

impl<Frac> DivAssign<i64> for Wrapping<FixedI64<Frac>>

fn div_assign(&mut self, other: i64)

Performs the /= operation.

impl<Frac> DivAssign<i8> for Wrapping<FixedI8<Frac>>

fn div_assign(&mut self, other: i8)

Performs the /= operation.

impl<Frac> DivAssign<u128> for Wrapping<FixedU128<Frac>>

fn div_assign(&mut self, other: u128)

Performs the /= operation.

impl<Frac> DivAssign<u16> for Wrapping<FixedU16<Frac>>

fn div_assign(&mut self, other: u16)

Performs the /= operation.

impl<Frac> DivAssign<u32> for Wrapping<FixedU32<Frac>>

fn div_assign(&mut self, other: u32)

Performs the /= operation.

impl<Frac> DivAssign<u64> for Wrapping<FixedU64<Frac>>

fn div_assign(&mut self, other: u64)

Performs the /= operation.

impl<Frac> DivAssign<u8> for Wrapping<FixedU8<Frac>>

fn div_assign(&mut self, other: u8)

Performs the /= operation.

impl<F: Eq> Eq for Wrapping<F>

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

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

Performs the conversion.

impl<F: Fixed> FromStr for Wrapping<F>

type Err = ParseFixedError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl<F: Hash> Hash for Wrapping<F>

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

Feeds this value into the given [Hasher].

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

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

impl<'a, F: Fixed> Mul<&'a Wrapping<F>> for Wrapping<F>

type Output = Wrapping<F>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b, F: Fixed> Mul<&'a Wrapping<F>> for &'b Wrapping<F>

type Output = Wrapping<F>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, Frac> Mul<&'a i128> for Wrapping<FixedI128<Frac>>

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>>

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 i16> for Wrapping<FixedI16<Frac>>

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>>

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 i32> for Wrapping<FixedI32<Frac>>

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>>

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 i64> for Wrapping<FixedI64<Frac>>

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>>

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 i8> for Wrapping<FixedI8<Frac>>

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>>

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 u128> for Wrapping<FixedU128<Frac>>

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>>

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 u16> for Wrapping<FixedU16<Frac>>

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>>

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 u32> for Wrapping<FixedU32<Frac>>

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>>

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 u64> for Wrapping<FixedU64<Frac>>

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>>

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 u8> for Wrapping<FixedU8<Frac>>

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>>

type Output = Wrapping<FixedU8<Frac>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<F: Fixed> Mul<Wrapping<F>> for Wrapping<F>

type Output = Wrapping<F>

The resulting type after applying the * operator.

fn mul(self, other: Wrapping<F>) -> Wrapping<F>

Performs the * operation.

impl<'a, F: Fixed> Mul<Wrapping<F>> for &'a Wrapping<F>

type Output = Wrapping<F>

The resulting type after applying the * operator.

fn mul(self, other: Wrapping<F>) -> Wrapping<F>

Performs the * operation.

impl<Frac> Mul<i128> for Wrapping<FixedI128<Frac>>

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>>

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<i16> for Wrapping<FixedI16<Frac>>

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>>

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<i32> for Wrapping<FixedI32<Frac>>

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>>

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<i64> for Wrapping<FixedI64<Frac>>

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>>

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<i8> for Wrapping<FixedI8<Frac>>

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>>

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<u128> for Wrapping<FixedU128<Frac>>

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>>

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> Mul<u16> for Wrapping<FixedU16<Frac>>

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>>

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<u32> for Wrapping<FixedU32<Frac>>

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>>

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<u64> for Wrapping<FixedU64<Frac>>

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>>

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<u8> for Wrapping<FixedU8<Frac>>

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>>

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, F: Fixed> MulAssign<&'a Wrapping<F>> for Wrapping<F>

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

Performs the *= operation.

impl<'a, Frac> MulAssign<&'a i128> for Wrapping<FixedI128<Frac>>

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

Performs the *= operation.

impl<'a, Frac> MulAssign<&'a i16> for Wrapping<FixedI16<Frac>>

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

Performs the *= operation.

impl<'a, Frac> MulAssign<&'a i32> for Wrapping<FixedI32<Frac>>

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

Performs the *= operation.

impl<'a, Frac> MulAssign<&'a i64> for Wrapping<FixedI64<Frac>>

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

Performs the *= operation.

impl<'a, Frac> MulAssign<&'a i8> for Wrapping<FixedI8<Frac>>

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

Performs the *= operation.

impl<'a, Frac> MulAssign<&'a u128> for Wrapping<FixedU128<Frac>>

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

Performs the *= operation.

impl<'a, Frac> MulAssign<&'a u16> for Wrapping<FixedU16<Frac>>

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

Performs the *= operation.

impl<'a, Frac> MulAssign<&'a u32> for Wrapping<FixedU32<Frac>>

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

Performs the *= operation.

impl<'a, Frac> MulAssign<&'a u64> for Wrapping<FixedU64<Frac>>

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

Performs the *= operation.

impl<'a, Frac> MulAssign<&'a u8> for Wrapping<FixedU8<Frac>>

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

Performs the *= operation.

impl<F: Fixed> MulAssign<Wrapping<F>> for Wrapping<F>

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

Performs the *= operation.

impl<Frac> MulAssign<i128> for Wrapping<FixedI128<Frac>>

fn mul_assign(&mut self, other: i128)

Performs the *= operation.

impl<Frac> MulAssign<i16> for Wrapping<FixedI16<Frac>>

fn mul_assign(&mut self, other: i16)

Performs the *= operation.

impl<Frac> MulAssign<i32> for Wrapping<FixedI32<Frac>>

fn mul_assign(&mut self, other: i32)

Performs the *= operation.

impl<Frac> MulAssign<i64> for Wrapping<FixedI64<Frac>>

fn mul_assign(&mut self, other: i64)

Performs the *= operation.

impl<Frac> MulAssign<i8> for Wrapping<FixedI8<Frac>>

fn mul_assign(&mut self, other: i8)

Performs the *= operation.

impl<Frac> MulAssign<u128> for Wrapping<FixedU128<Frac>>

fn mul_assign(&mut self, other: u128)

Performs the *= operation.

impl<Frac> MulAssign<u16> for Wrapping<FixedU16<Frac>>

fn mul_assign(&mut self, other: u16)

Performs the *= operation.

impl<Frac> MulAssign<u32> for Wrapping<FixedU32<Frac>>

fn mul_assign(&mut self, other: u32)

Performs the *= operation.

impl<Frac> MulAssign<u64> for Wrapping<FixedU64<Frac>>

fn mul_assign(&mut self, other: u64)

Performs the *= operation.

impl<Frac> MulAssign<u8> for Wrapping<FixedU8<Frac>>

fn mul_assign(&mut self, other: u8)

Performs the *= operation.

impl<F: Fixed> Neg for Wrapping<F>

type Output = Wrapping<F>

The resulting type after applying the - operator.

fn neg(self) -> Wrapping<F>

Performs the unary - operation.

impl<'a, F: Fixed> Neg for &'a Wrapping<F>

type Output = Wrapping<F>

The resulting type after applying the - operator.

fn neg(self) -> Wrapping<F>

Performs the unary - operation.

impl<F> Not for Wrapping<F> where
    F: Not<Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the ! operator.

fn not(self) -> Wrapping<F>

Performs the unary ! operation.

impl<'a, F> Not for &'a Wrapping<F> where
    &'a F: Not<Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the ! operator.

fn not(self) -> Wrapping<F>

Performs the unary ! operation.

impl<F: Ord> Ord for Wrapping<F>

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

This method returns an [Ordering] between self and other.

#[must_use] fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use] fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use] fn clamp(self, min: Self, max: Self) -> Self

🔬 This is a nightly-only experimental API. (clamp)

Restrict a value to a certain interval.

impl<F: PartialEq> PartialEq<Wrapping<F>> for Wrapping<F>

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

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

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

This method tests for !=.

impl<F: PartialOrd> PartialOrd<Wrapping<F>> for Wrapping<F>

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<'a, F: 'a + Fixed> Product<&'a Wrapping<F>> for Wrapping<F>

fn product<I>(iter: I) -> Wrapping<F> where
    I: Iterator<Item = &'a Wrapping<F>>, 

Method which takes an iterator and generates Self from the elements by multiplying the items.

impl<F: Fixed> Product<Wrapping<F>> for Wrapping<F>

fn product<I>(iter: I) -> Wrapping<F> where
    I: Iterator<Item = Wrapping<F>>, 

Method which takes an iterator and generates Self from the elements by multiplying the items.

impl<'a, F: Fixed> Rem<&'a Wrapping<F>> for Wrapping<F>

type Output = Wrapping<F>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<'a, 'b, F: Fixed> Rem<&'a Wrapping<F>> for &'b Wrapping<F>

type Output = Wrapping<F>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<'a, Frac: LeEqU128> Rem<&'a i128> for Wrapping<FixedI128<Frac>>

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: LeEqU128> Rem<&'a i128> for &'b Wrapping<FixedI128<Frac>>

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: LeEqU16> Rem<&'a i16> for Wrapping<FixedI16<Frac>>

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: LeEqU16> Rem<&'a i16> for &'b Wrapping<FixedI16<Frac>>

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: LeEqU32> Rem<&'a i32> for Wrapping<FixedI32<Frac>>

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: LeEqU32> Rem<&'a i32> for &'b Wrapping<FixedI32<Frac>>

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: LeEqU64> Rem<&'a i64> for Wrapping<FixedI64<Frac>>

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: LeEqU64> Rem<&'a i64> for &'b Wrapping<FixedI64<Frac>>

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: LeEqU8> Rem<&'a i8> for Wrapping<FixedI8<Frac>>

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: LeEqU8> Rem<&'a i8> for &'b Wrapping<FixedI8<Frac>>

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: LeEqU128> Rem<&'a u128> for Wrapping<FixedU128<Frac>>

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: LeEqU128> Rem<&'a u128> for &'b Wrapping<FixedU128<Frac>>

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: LeEqU16> Rem<&'a u16> for Wrapping<FixedU16<Frac>>

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: LeEqU16> Rem<&'a u16> for &'b Wrapping<FixedU16<Frac>>

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: LeEqU32> Rem<&'a u32> for Wrapping<FixedU32<Frac>>

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: LeEqU32> Rem<&'a u32> for &'b Wrapping<FixedU32<Frac>>

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: LeEqU64> Rem<&'a u64> for Wrapping<FixedU64<Frac>>

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: LeEqU64> Rem<&'a u64> for &'b Wrapping<FixedU64<Frac>>

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: LeEqU8> Rem<&'a u8> for Wrapping<FixedU8<Frac>>

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: LeEqU8> Rem<&'a u8> for &'b Wrapping<FixedU8<Frac>>

type Output = Wrapping<FixedU8<Frac>>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<F: Fixed> Rem<Wrapping<F>> for Wrapping<F>

type Output = Wrapping<F>

The resulting type after applying the % operator.

fn rem(self, other: Wrapping<F>) -> Wrapping<F>

Performs the % operation.

impl<'a, F: Fixed> Rem<Wrapping<F>> for &'a Wrapping<F>

type Output = Wrapping<F>

The resulting type after applying the % operator.

fn rem(self, other: Wrapping<F>) -> Wrapping<F>

Performs the % operation.

impl<Frac: LeEqU128> Rem<i128> for Wrapping<FixedI128<Frac>>

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: LeEqU128> Rem<i128> for &'a Wrapping<FixedI128<Frac>>

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: LeEqU16> Rem<i16> for Wrapping<FixedI16<Frac>>

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: LeEqU16> Rem<i16> for &'a Wrapping<FixedI16<Frac>>

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: LeEqU32> Rem<i32> for Wrapping<FixedI32<Frac>>

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: LeEqU32> Rem<i32> for &'a Wrapping<FixedI32<Frac>>

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: LeEqU64> Rem<i64> for Wrapping<FixedI64<Frac>>

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: LeEqU64> Rem<i64> for &'a Wrapping<FixedI64<Frac>>

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: LeEqU8> Rem<i8> for Wrapping<FixedI8<Frac>>

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: LeEqU8> Rem<i8> for &'a Wrapping<FixedI8<Frac>>

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: LeEqU128> Rem<u128> for Wrapping<FixedU128<Frac>>

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: LeEqU128> Rem<u128> for &'a Wrapping<FixedU128<Frac>>

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: LeEqU16> Rem<u16> for Wrapping<FixedU16<Frac>>

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: LeEqU16> Rem<u16> for &'a Wrapping<FixedU16<Frac>>

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: LeEqU32> Rem<u32> for Wrapping<FixedU32<Frac>>

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: LeEqU32> Rem<u32> for &'a Wrapping<FixedU32<Frac>>

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: LeEqU64> Rem<u64> for Wrapping<FixedU64<Frac>>

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: LeEqU64> Rem<u64> for &'a Wrapping<FixedU64<Frac>>

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: LeEqU8> Rem<u8> for Wrapping<FixedU8<Frac>>

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: LeEqU8> Rem<u8> for &'a Wrapping<FixedU8<Frac>>

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, F: Fixed> RemAssign<&'a Wrapping<F>> for Wrapping<F>

fn rem_assign(&mut self, other: &Wrapping<F>)

Performs the %= operation.

impl<'a, Frac: LeEqU128> RemAssign<&'a i128> for Wrapping<FixedI128<Frac>>

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

Performs the %= operation.

impl<'a, Frac: LeEqU16> RemAssign<&'a i16> for Wrapping<FixedI16<Frac>>

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

Performs the %= operation.

impl<'a, Frac: LeEqU32> RemAssign<&'a i32> for Wrapping<FixedI32<Frac>>

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

Performs the %= operation.

impl<'a, Frac: LeEqU64> RemAssign<&'a i64> for Wrapping<FixedI64<Frac>>

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

Performs the %= operation.

impl<'a, Frac: LeEqU8> RemAssign<&'a i8> for Wrapping<FixedI8<Frac>>

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

Performs the %= operation.

impl<'a, Frac: LeEqU128> RemAssign<&'a u128> for Wrapping<FixedU128<Frac>>

fn rem_assign(&mut self, other: &u128)

Performs the %= operation.

impl<'a, Frac: LeEqU16> RemAssign<&'a u16> for Wrapping<FixedU16<Frac>>

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

Performs the %= operation.

impl<'a, Frac: LeEqU32> RemAssign<&'a u32> for Wrapping<FixedU32<Frac>>

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

Performs the %= operation.

impl<'a, Frac: LeEqU64> RemAssign<&'a u64> for Wrapping<FixedU64<Frac>>

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

Performs the %= operation.

impl<'a, Frac: LeEqU8> RemAssign<&'a u8> for Wrapping<FixedU8<Frac>>

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

Performs the %= operation.

impl<F: Fixed> RemAssign<Wrapping<F>> for Wrapping<F>

fn rem_assign(&mut self, other: Wrapping<F>)

Performs the %= operation.

impl<Frac: LeEqU128> RemAssign<i128> for Wrapping<FixedI128<Frac>>

fn rem_assign(&mut self, other: i128)

Performs the %= operation.

impl<Frac: LeEqU16> RemAssign<i16> for Wrapping<FixedI16<Frac>>

fn rem_assign(&mut self, other: i16)

Performs the %= operation.

impl<Frac: LeEqU32> RemAssign<i32> for Wrapping<FixedI32<Frac>>

fn rem_assign(&mut self, other: i32)

Performs the %= operation.

impl<Frac: LeEqU64> RemAssign<i64> for Wrapping<FixedI64<Frac>>

fn rem_assign(&mut self, other: i64)

Performs the %= operation.

impl<Frac: LeEqU8> RemAssign<i8> for Wrapping<FixedI8<Frac>>

fn rem_assign(&mut self, other: i8)

Performs the %= operation.

impl<Frac: LeEqU128> RemAssign<u128> for Wrapping<FixedU128<Frac>>

fn rem_assign(&mut self, other: u128)

Performs the %= operation.

impl<Frac: LeEqU16> RemAssign<u16> for Wrapping<FixedU16<Frac>>

fn rem_assign(&mut self, other: u16)

Performs the %= operation.

impl<Frac: LeEqU32> RemAssign<u32> for Wrapping<FixedU32<Frac>>

fn rem_assign(&mut self, other: u32)

Performs the %= operation.

impl<Frac: LeEqU64> RemAssign<u64> for Wrapping<FixedU64<Frac>>

fn rem_assign(&mut self, other: u64)

Performs the %= operation.

impl<Frac: LeEqU8> RemAssign<u8> for Wrapping<FixedU8<Frac>>

fn rem_assign(&mut self, other: u8)

Performs the %= operation.

impl<Frac: LeEqU8> Serialize for Wrapping<FixedI8<Frac>>

fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.

impl<Frac: LeEqU16> Serialize for Wrapping<FixedI16<Frac>>

fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.

impl<Frac: LeEqU32> Serialize for Wrapping<FixedI32<Frac>>

fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.

impl<Frac: LeEqU64> Serialize for Wrapping<FixedI64<Frac>>

fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.

impl<Frac: LeEqU128> Serialize for Wrapping<FixedI128<Frac>>

fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.

impl<Frac: LeEqU8> Serialize for Wrapping<FixedU8<Frac>>

fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.

impl<Frac: LeEqU16> Serialize for Wrapping<FixedU16<Frac>>

fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.

impl<Frac: LeEqU32> Serialize for Wrapping<FixedU32<Frac>>

fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.

impl<Frac: LeEqU64> Serialize for Wrapping<FixedU64<Frac>>

fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.

impl<Frac: LeEqU128> Serialize for Wrapping<FixedU128<Frac>>

fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.

impl<'a, F> Shl<&'a i128> for Wrapping<F> where
    F: Shl<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the << operator.

fn shl(self, other: &i128) -> Wrapping<F>

Performs the << operation.

impl<'a, 'b, F> Shl<&'a i128> for &'b Wrapping<F> where
    &'b F: Shl<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the << operator.

fn shl(self, other: &i128) -> Wrapping<F>

Performs the << operation.

impl<'a, F> Shl<&'a i16> for Wrapping<F> where
    F: Shl<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the << operator.

fn shl(self, other: &i16) -> Wrapping<F>

Performs the << operation.

impl<'a, 'b, F> Shl<&'a i16> for &'b Wrapping<F> where
    &'b F: Shl<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the << operator.

fn shl(self, other: &i16) -> Wrapping<F>

Performs the << operation.

impl<'a, F> Shl<&'a i32> for Wrapping<F> where
    F: Shl<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the << operator.

fn shl(self, other: &i32) -> Wrapping<F>

Performs the << operation.

impl<'a, 'b, F> Shl<&'a i32> for &'b Wrapping<F> where
    &'b F: Shl<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the << operator.

fn shl(self, other: &i32) -> Wrapping<F>

Performs the << operation.

impl<'a, F> Shl<&'a i64> for Wrapping<F> where
    F: Shl<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the << operator.

fn shl(self, other: &i64) -> Wrapping<F>

Performs the << operation.

impl<'a, 'b, F> Shl<&'a i64> for &'b Wrapping<F> where
    &'b F: Shl<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the << operator.

fn shl(self, other: &i64) -> Wrapping<F>

Performs the << operation.

impl<'a, F> Shl<&'a i8> for Wrapping<F> where
    F: Shl<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the << operator.

fn shl(self, other: &i8) -> Wrapping<F>

Performs the << operation.

impl<'a, 'b, F> Shl<&'a i8> for &'b Wrapping<F> where
    &'b F: Shl<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the << operator.

fn shl(self, other: &i8) -> Wrapping<F>

Performs the << operation.

impl<'a, F> Shl<&'a isize> for Wrapping<F> where
    F: Shl<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the << operator.

fn shl(self, other: &isize) -> Wrapping<F>

Performs the << operation.

impl<'a, 'b, F> Shl<&'a isize> for &'b Wrapping<F> where
    &'b F: Shl<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the << operator.

fn shl(self, other: &isize) -> Wrapping<F>

Performs the << operation.

impl<'a, F> Shl<&'a u128> for Wrapping<F> where
    F: Shl<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the << operator.

fn shl(self, other: &u128) -> Wrapping<F>

Performs the << operation.

impl<'a, 'b, F> Shl<&'a u128> for &'b Wrapping<F> where
    &'b F: Shl<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the << operator.

fn shl(self, other: &u128) -> Wrapping<F>

Performs the << operation.

impl<'a, F> Shl<&'a u16> for Wrapping<F> where
    F: Shl<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the << operator.

fn shl(self, other: &u16) -> Wrapping<F>

Performs the << operation.

impl<'a, 'b, F> Shl<&'a u16> for &'b Wrapping<F> where
    &'b F: Shl<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the << operator.

fn shl(self, other: &u16) -> Wrapping<F>

Performs the << operation.

impl<'a, F> Shl<&'a u32> for Wrapping<F> where
    F: Shl<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the << operator.

fn shl(self, other: &u32) -> Wrapping<F>

Performs the << operation.

impl<'a, 'b, F> Shl<&'a u32> for &'b Wrapping<F> where
    &'b F: Shl<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the << operator.

fn shl(self, other: &u32) -> Wrapping<F>

Performs the << operation.

impl<'a, F> Shl<&'a u64> for Wrapping<F> where
    F: Shl<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the << operator.

fn shl(self, other: &u64) -> Wrapping<F>

Performs the << operation.

impl<'a, 'b, F> Shl<&'a u64> for &'b Wrapping<F> where
    &'b F: Shl<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the << operator.

fn shl(self, other: &u64) -> Wrapping<F>

Performs the << operation.

impl<'a, F> Shl<&'a u8> for Wrapping<F> where
    F: Shl<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the << operator.

fn shl(self, other: &u8) -> Wrapping<F>

Performs the << operation.

impl<'a, 'b, F> Shl<&'a u8> for &'b Wrapping<F> where
    &'b F: Shl<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the << operator.

fn shl(self, other: &u8) -> Wrapping<F>

Performs the << operation.

impl<'a, F> Shl<&'a usize> for Wrapping<F> where
    F: Shl<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the << operator.

fn shl(self, other: &usize) -> Wrapping<F>

Performs the << operation.

impl<'a, 'b, F> Shl<&'a usize> for &'b Wrapping<F> where
    &'b F: Shl<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the << operator.

fn shl(self, other: &usize) -> Wrapping<F>

Performs the << operation.

impl<F> Shl<i128> for Wrapping<F> where
    F: Shl<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the << operator.

fn shl(self, other: i128) -> Wrapping<F>

Performs the << operation.

impl<'a, F> Shl<i128> for &'a Wrapping<F> where
    &'a F: Shl<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the << operator.

fn shl(self, other: i128) -> Wrapping<F>

Performs the << operation.

impl<F> Shl<i16> for Wrapping<F> where
    F: Shl<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the << operator.

fn shl(self, other: i16) -> Wrapping<F>

Performs the << operation.

impl<'a, F> Shl<i16> for &'a Wrapping<F> where
    &'a F: Shl<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the << operator.

fn shl(self, other: i16) -> Wrapping<F>

Performs the << operation.

impl<F> Shl<i32> for Wrapping<F> where
    F: Shl<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the << operator.

fn shl(self, other: i32) -> Wrapping<F>

Performs the << operation.

impl<'a, F> Shl<i32> for &'a Wrapping<F> where
    &'a F: Shl<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the << operator.

fn shl(self, other: i32) -> Wrapping<F>

Performs the << operation.

impl<F> Shl<i64> for Wrapping<F> where
    F: Shl<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the << operator.

fn shl(self, other: i64) -> Wrapping<F>

Performs the << operation.

impl<'a, F> Shl<i64> for &'a Wrapping<F> where
    &'a F: Shl<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the << operator.

fn shl(self, other: i64) -> Wrapping<F>

Performs the << operation.

impl<F> Shl<i8> for Wrapping<F> where
    F: Shl<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the << operator.

fn shl(self, other: i8) -> Wrapping<F>

Performs the << operation.

impl<'a, F> Shl<i8> for &'a Wrapping<F> where
    &'a F: Shl<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the << operator.

fn shl(self, other: i8) -> Wrapping<F>

Performs the << operation.

impl<F> Shl<isize> for Wrapping<F> where
    F: Shl<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the << operator.

fn shl(self, other: isize) -> Wrapping<F>

Performs the << operation.

impl<'a, F> Shl<isize> for &'a Wrapping<F> where
    &'a F: Shl<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the << operator.

fn shl(self, other: isize) -> Wrapping<F>

Performs the << operation.

impl<F> Shl<u128> for Wrapping<F> where
    F: Shl<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the << operator.

fn shl(self, other: u128) -> Wrapping<F>

Performs the << operation.

impl<'a, F> Shl<u128> for &'a Wrapping<F> where
    &'a F: Shl<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the << operator.

fn shl(self, other: u128) -> Wrapping<F>

Performs the << operation.

impl<F> Shl<u16> for Wrapping<F> where
    F: Shl<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the << operator.

fn shl(self, other: u16) -> Wrapping<F>

Performs the << operation.

impl<'a, F> Shl<u16> for &'a Wrapping<F> where
    &'a F: Shl<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the << operator.

fn shl(self, other: u16) -> Wrapping<F>

Performs the << operation.

impl<F> Shl<u32> for Wrapping<F> where
    F: Shl<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the << operator.

fn shl(self, other: u32) -> Wrapping<F>

Performs the << operation.

impl<'a, F> Shl<u32> for &'a Wrapping<F> where
    &'a F: Shl<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the << operator.

fn shl(self, other: u32) -> Wrapping<F>

Performs the << operation.

impl<F> Shl<u64> for Wrapping<F> where
    F: Shl<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the << operator.

fn shl(self, other: u64) -> Wrapping<F>

Performs the << operation.

impl<'a, F> Shl<u64> for &'a Wrapping<F> where
    &'a F: Shl<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the << operator.

fn shl(self, other: u64) -> Wrapping<F>

Performs the << operation.

impl<F> Shl<u8> for Wrapping<F> where
    F: Shl<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the << operator.

fn shl(self, other: u8) -> Wrapping<F>

Performs the << operation.

impl<'a, F> Shl<u8> for &'a Wrapping<F> where
    &'a F: Shl<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the << operator.

fn shl(self, other: u8) -> Wrapping<F>

Performs the << operation.

impl<F> Shl<usize> for Wrapping<F> where
    F: Shl<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the << operator.

fn shl(self, other: usize) -> Wrapping<F>

Performs the << operation.

impl<'a, F> Shl<usize> for &'a Wrapping<F> where
    &'a F: Shl<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the << operator.

fn shl(self, other: usize) -> Wrapping<F>

Performs the << operation.

impl<'a, F> ShlAssign<&'a i128> for Wrapping<F> where
    F: ShlAssign<u32>, 

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

Performs the <<= operation.

impl<'a, F> ShlAssign<&'a i16> for Wrapping<F> where
    F: ShlAssign<u32>, 

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

Performs the <<= operation.

impl<'a, F> ShlAssign<&'a i32> for Wrapping<F> where
    F: ShlAssign<u32>, 

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

Performs the <<= operation.

impl<'a, F> ShlAssign<&'a i64> for Wrapping<F> where
    F: ShlAssign<u32>, 

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

Performs the <<= operation.

impl<'a, F> ShlAssign<&'a i8> for Wrapping<F> where
    F: ShlAssign<u32>, 

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

Performs the <<= operation.

impl<'a, F> ShlAssign<&'a isize> for Wrapping<F> where
    F: ShlAssign<u32>, 

fn shl_assign(&mut self, other: &isize)

Performs the <<= operation.

impl<'a, F> ShlAssign<&'a u128> for Wrapping<F> where
    F: ShlAssign<u32>, 

fn shl_assign(&mut self, other: &u128)

Performs the <<= operation.

impl<'a, F> ShlAssign<&'a u16> for Wrapping<F> where
    F: ShlAssign<u32>, 

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

Performs the <<= operation.

impl<'a, F> ShlAssign<&'a u32> for Wrapping<F> where
    F: ShlAssign<u32>, 

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

Performs the <<= operation.

impl<'a, F> ShlAssign<&'a u64> for Wrapping<F> where
    F: ShlAssign<u32>, 

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

Performs the <<= operation.

impl<'a, F> ShlAssign<&'a u8> for Wrapping<F> where
    F: ShlAssign<u32>, 

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

Performs the <<= operation.

impl<'a, F> ShlAssign<&'a usize> for Wrapping<F> where
    F: ShlAssign<u32>, 

fn shl_assign(&mut self, other: &usize)

Performs the <<= operation.

impl<F> ShlAssign<i128> for Wrapping<F> where
    F: ShlAssign<u32>, 

fn shl_assign(&mut self, other: i128)

Performs the <<= operation.

impl<F> ShlAssign<i16> for Wrapping<F> where
    F: ShlAssign<u32>, 

fn shl_assign(&mut self, other: i16)

Performs the <<= operation.

impl<F> ShlAssign<i32> for Wrapping<F> where
    F: ShlAssign<u32>, 

fn shl_assign(&mut self, other: i32)

Performs the <<= operation.

impl<F> ShlAssign<i64> for Wrapping<F> where
    F: ShlAssign<u32>, 

fn shl_assign(&mut self, other: i64)

Performs the <<= operation.

impl<F> ShlAssign<i8> for Wrapping<F> where
    F: ShlAssign<u32>, 

fn shl_assign(&mut self, other: i8)

Performs the <<= operation.

impl<F> ShlAssign<isize> for Wrapping<F> where
    F: ShlAssign<u32>, 

fn shl_assign(&mut self, other: isize)

Performs the <<= operation.

impl<F> ShlAssign<u128> for Wrapping<F> where
    F: ShlAssign<u32>, 

fn shl_assign(&mut self, other: u128)

Performs the <<= operation.

impl<F> ShlAssign<u16> for Wrapping<F> where
    F: ShlAssign<u32>, 

fn shl_assign(&mut self, other: u16)

Performs the <<= operation.

impl<F> ShlAssign<u32> for Wrapping<F> where
    F: ShlAssign<u32>, 

fn shl_assign(&mut self, other: u32)

Performs the <<= operation.

impl<F> ShlAssign<u64> for Wrapping<F> where
    F: ShlAssign<u32>, 

fn shl_assign(&mut self, other: u64)

Performs the <<= operation.

impl<F> ShlAssign<u8> for Wrapping<F> where
    F: ShlAssign<u32>, 

fn shl_assign(&mut self, other: u8)

Performs the <<= operation.

impl<F> ShlAssign<usize> for Wrapping<F> where
    F: ShlAssign<u32>, 

fn shl_assign(&mut self, other: usize)

Performs the <<= operation.

impl<'a, F> Shr<&'a i128> for Wrapping<F> where
    F: Shr<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the >> operator.

fn shr(self, other: &i128) -> Wrapping<F>

Performs the >> operation.

impl<'a, 'b, F> Shr<&'a i128> for &'b Wrapping<F> where
    &'b F: Shr<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the >> operator.

fn shr(self, other: &i128) -> Wrapping<F>

Performs the >> operation.

impl<'a, F> Shr<&'a i16> for Wrapping<F> where
    F: Shr<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the >> operator.

fn shr(self, other: &i16) -> Wrapping<F>

Performs the >> operation.

impl<'a, 'b, F> Shr<&'a i16> for &'b Wrapping<F> where
    &'b F: Shr<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the >> operator.

fn shr(self, other: &i16) -> Wrapping<F>

Performs the >> operation.

impl<'a, F> Shr<&'a i32> for Wrapping<F> where
    F: Shr<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the >> operator.

fn shr(self, other: &i32) -> Wrapping<F>

Performs the >> operation.

impl<'a, 'b, F> Shr<&'a i32> for &'b Wrapping<F> where
    &'b F: Shr<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the >> operator.

fn shr(self, other: &i32) -> Wrapping<F>

Performs the >> operation.

impl<'a, F> Shr<&'a i64> for Wrapping<F> where
    F: Shr<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the >> operator.

fn shr(self, other: &i64) -> Wrapping<F>

Performs the >> operation.

impl<'a, 'b, F> Shr<&'a i64> for &'b Wrapping<F> where
    &'b F: Shr<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the >> operator.

fn shr(self, other: &i64) -> Wrapping<F>

Performs the >> operation.

impl<'a, F> Shr<&'a i8> for Wrapping<F> where
    F: Shr<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the >> operator.

fn shr(self, other: &i8) -> Wrapping<F>

Performs the >> operation.

impl<'a, 'b, F> Shr<&'a i8> for &'b Wrapping<F> where
    &'b F: Shr<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the >> operator.

fn shr(self, other: &i8) -> Wrapping<F>

Performs the >> operation.

impl<'a, F> Shr<&'a isize> for Wrapping<F> where
    F: Shr<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the >> operator.

fn shr(self, other: &isize) -> Wrapping<F>

Performs the >> operation.

impl<'a, 'b, F> Shr<&'a isize> for &'b Wrapping<F> where
    &'b F: Shr<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the >> operator.

fn shr(self, other: &isize) -> Wrapping<F>

Performs the >> operation.

impl<'a, F> Shr<&'a u128> for Wrapping<F> where
    F: Shr<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the >> operator.

fn shr(self, other: &u128) -> Wrapping<F>

Performs the >> operation.

impl<'a, 'b, F> Shr<&'a u128> for &'b Wrapping<F> where
    &'b F: Shr<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the >> operator.

fn shr(self, other: &u128) -> Wrapping<F>

Performs the >> operation.

impl<'a, F> Shr<&'a u16> for Wrapping<F> where
    F: Shr<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the >> operator.

fn shr(self, other: &u16) -> Wrapping<F>

Performs the >> operation.

impl<'a, 'b, F> Shr<&'a u16> for &'b Wrapping<F> where
    &'b F: Shr<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the >> operator.

fn shr(self, other: &u16) -> Wrapping<F>

Performs the >> operation.

impl<'a, F> Shr<&'a u32> for Wrapping<F> where
    F: Shr<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the >> operator.

fn shr(self, other: &u32) -> Wrapping<F>

Performs the >> operation.

impl<'a, 'b, F> Shr<&'a u32> for &'b Wrapping<F> where
    &'b F: Shr<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the >> operator.

fn shr(self, other: &u32) -> Wrapping<F>

Performs the >> operation.

impl<'a, F> Shr<&'a u64> for Wrapping<F> where
    F: Shr<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the >> operator.

fn shr(self, other: &u64) -> Wrapping<F>

Performs the >> operation.

impl<'a, 'b, F> Shr<&'a u64> for &'b Wrapping<F> where
    &'b F: Shr<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the >> operator.

fn shr(self, other: &u64) -> Wrapping<F>

Performs the >> operation.

impl<'a, F> Shr<&'a u8> for Wrapping<F> where
    F: Shr<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the >> operator.

fn shr(self, other: &u8) -> Wrapping<F>

Performs the >> operation.

impl<'a, 'b, F> Shr<&'a u8> for &'b Wrapping<F> where
    &'b F: Shr<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the >> operator.

fn shr(self, other: &u8) -> Wrapping<F>

Performs the >> operation.

impl<'a, F> Shr<&'a usize> for Wrapping<F> where
    F: Shr<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the >> operator.

fn shr(self, other: &usize) -> Wrapping<F>

Performs the >> operation.

impl<'a, 'b, F> Shr<&'a usize> for &'b Wrapping<F> where
    &'b F: Shr<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the >> operator.

fn shr(self, other: &usize) -> Wrapping<F>

Performs the >> operation.

impl<F> Shr<i128> for Wrapping<F> where
    F: Shr<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the >> operator.

fn shr(self, other: i128) -> Wrapping<F>

Performs the >> operation.

impl<'a, F> Shr<i128> for &'a Wrapping<F> where
    &'a F: Shr<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the >> operator.

fn shr(self, other: i128) -> Wrapping<F>

Performs the >> operation.

impl<F> Shr<i16> for Wrapping<F> where
    F: Shr<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the >> operator.

fn shr(self, other: i16) -> Wrapping<F>

Performs the >> operation.

impl<'a, F> Shr<i16> for &'a Wrapping<F> where
    &'a F: Shr<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the >> operator.

fn shr(self, other: i16) -> Wrapping<F>

Performs the >> operation.

impl<F> Shr<i32> for Wrapping<F> where
    F: Shr<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the >> operator.

fn shr(self, other: i32) -> Wrapping<F>

Performs the >> operation.

impl<'a, F> Shr<i32> for &'a Wrapping<F> where
    &'a F: Shr<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the >> operator.

fn shr(self, other: i32) -> Wrapping<F>

Performs the >> operation.

impl<F> Shr<i64> for Wrapping<F> where
    F: Shr<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the >> operator.

fn shr(self, other: i64) -> Wrapping<F>

Performs the >> operation.

impl<'a, F> Shr<i64> for &'a Wrapping<F> where
    &'a F: Shr<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the >> operator.

fn shr(self, other: i64) -> Wrapping<F>

Performs the >> operation.

impl<F> Shr<i8> for Wrapping<F> where
    F: Shr<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the >> operator.

fn shr(self, other: i8) -> Wrapping<F>

Performs the >> operation.

impl<'a, F> Shr<i8> for &'a Wrapping<F> where
    &'a F: Shr<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the >> operator.

fn shr(self, other: i8) -> Wrapping<F>

Performs the >> operation.

impl<F> Shr<isize> for Wrapping<F> where
    F: Shr<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the >> operator.

fn shr(self, other: isize) -> Wrapping<F>

Performs the >> operation.

impl<'a, F> Shr<isize> for &'a Wrapping<F> where
    &'a F: Shr<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the >> operator.

fn shr(self, other: isize) -> Wrapping<F>

Performs the >> operation.

impl<F> Shr<u128> for Wrapping<F> where
    F: Shr<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the >> operator.

fn shr(self, other: u128) -> Wrapping<F>

Performs the >> operation.

impl<'a, F> Shr<u128> for &'a Wrapping<F> where
    &'a F: Shr<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the >> operator.

fn shr(self, other: u128) -> Wrapping<F>

Performs the >> operation.

impl<F> Shr<u16> for Wrapping<F> where
    F: Shr<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the >> operator.

fn shr(self, other: u16) -> Wrapping<F>

Performs the >> operation.

impl<'a, F> Shr<u16> for &'a Wrapping<F> where
    &'a F: Shr<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the >> operator.

fn shr(self, other: u16) -> Wrapping<F>

Performs the >> operation.

impl<F> Shr<u32> for Wrapping<F> where
    F: Shr<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the >> operator.

fn shr(self, other: u32) -> Wrapping<F>

Performs the >> operation.

impl<'a, F> Shr<u32> for &'a Wrapping<F> where
    &'a F: Shr<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the >> operator.

fn shr(self, other: u32) -> Wrapping<F>

Performs the >> operation.

impl<F> Shr<u64> for Wrapping<F> where
    F: Shr<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the >> operator.

fn shr(self, other: u64) -> Wrapping<F>

Performs the >> operation.

impl<'a, F> Shr<u64> for &'a Wrapping<F> where
    &'a F: Shr<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the >> operator.

fn shr(self, other: u64) -> Wrapping<F>

Performs the >> operation.

impl<F> Shr<u8> for Wrapping<F> where
    F: Shr<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the >> operator.

fn shr(self, other: u8) -> Wrapping<F>

Performs the >> operation.

impl<'a, F> Shr<u8> for &'a Wrapping<F> where
    &'a F: Shr<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the >> operator.

fn shr(self, other: u8) -> Wrapping<F>

Performs the >> operation.

impl<F> Shr<usize> for Wrapping<F> where
    F: Shr<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the >> operator.

fn shr(self, other: usize) -> Wrapping<F>

Performs the >> operation.

impl<'a, F> Shr<usize> for &'a Wrapping<F> where
    &'a F: Shr<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the >> operator.

fn shr(self, other: usize) -> Wrapping<F>

Performs the >> operation.

impl<'a, F> ShrAssign<&'a i128> for Wrapping<F> where
    F: ShrAssign<u32>, 

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

Performs the >>= operation.

impl<'a, F> ShrAssign<&'a i16> for Wrapping<F> where
    F: ShrAssign<u32>, 

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

Performs the >>= operation.

impl<'a, F> ShrAssign<&'a i32> for Wrapping<F> where
    F: ShrAssign<u32>, 

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

Performs the >>= operation.

impl<'a, F> ShrAssign<&'a i64> for Wrapping<F> where
    F: ShrAssign<u32>, 

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

Performs the >>= operation.

impl<'a, F> ShrAssign<&'a i8> for Wrapping<F> where
    F: ShrAssign<u32>, 

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

Performs the >>= operation.

impl<'a, F> ShrAssign<&'a isize> for Wrapping<F> where
    F: ShrAssign<u32>, 

fn shr_assign(&mut self, other: &isize)

Performs the >>= operation.

impl<'a, F> ShrAssign<&'a u128> for Wrapping<F> where
    F: ShrAssign<u32>, 

fn shr_assign(&mut self, other: &u128)

Performs the >>= operation.

impl<'a, F> ShrAssign<&'a u16> for Wrapping<F> where
    F: ShrAssign<u32>, 

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

Performs the >>= operation.

impl<'a, F> ShrAssign<&'a u32> for Wrapping<F> where
    F: ShrAssign<u32>, 

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

Performs the >>= operation.

impl<'a, F> ShrAssign<&'a u64> for Wrapping<F> where
    F: ShrAssign<u32>, 

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

Performs the >>= operation.

impl<'a, F> ShrAssign<&'a u8> for Wrapping<F> where
    F: ShrAssign<u32>, 

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

Performs the >>= operation.

impl<'a, F> ShrAssign<&'a usize> for Wrapping<F> where
    F: ShrAssign<u32>, 

fn shr_assign(&mut self, other: &usize)

Performs the >>= operation.

impl<F> ShrAssign<i128> for Wrapping<F> where
    F: ShrAssign<u32>, 

fn shr_assign(&mut self, other: i128)

Performs the >>= operation.

impl<F> ShrAssign<i16> for Wrapping<F> where
    F: ShrAssign<u32>, 

fn shr_assign(&mut self, other: i16)

Performs the >>= operation.

impl<F> ShrAssign<i32> for Wrapping<F> where
    F: ShrAssign<u32>, 

fn shr_assign(&mut self, other: i32)

Performs the >>= operation.

impl<F> ShrAssign<i64> for Wrapping<F> where
    F: ShrAssign<u32>, 

fn shr_assign(&mut self, other: i64)

Performs the >>= operation.

impl<F> ShrAssign<i8> for Wrapping<F> where
    F: ShrAssign<u32>, 

fn shr_assign(&mut self, other: i8)

Performs the >>= operation.

impl<F> ShrAssign<isize> for Wrapping<F> where
    F: ShrAssign<u32>, 

fn shr_assign(&mut self, other: isize)

Performs the >>= operation.

impl<F> ShrAssign<u128> for Wrapping<F> where
    F: ShrAssign<u32>, 

fn shr_assign(&mut self, other: u128)

Performs the >>= operation.

impl<F> ShrAssign<u16> for Wrapping<F> where
    F: ShrAssign<u32>, 

fn shr_assign(&mut self, other: u16)

Performs the >>= operation.

impl<F> ShrAssign<u32> for Wrapping<F> where
    F: ShrAssign<u32>, 

fn shr_assign(&mut self, other: u32)

Performs the >>= operation.

impl<F> ShrAssign<u64> for Wrapping<F> where
    F: ShrAssign<u32>, 

fn shr_assign(&mut self, other: u64)

Performs the >>= operation.

impl<F> ShrAssign<u8> for Wrapping<F> where
    F: ShrAssign<u32>, 

fn shr_assign(&mut self, other: u8)

Performs the >>= operation.

impl<F> ShrAssign<usize> for Wrapping<F> where
    F: ShrAssign<u32>, 

fn shr_assign(&mut self, other: usize)

Performs the >>= operation.

impl<F> StructuralEq for Wrapping<F>

impl<F> StructuralPartialEq for Wrapping<F>

impl<'a, F: Fixed> Sub<&'a Wrapping<F>> for Wrapping<F>

type Output = Wrapping<F>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'a, 'b, F: Fixed> Sub<&'a Wrapping<F>> for &'b Wrapping<F>

type Output = Wrapping<F>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<F: Fixed> Sub<Wrapping<F>> for Wrapping<F>

type Output = Wrapping<F>

The resulting type after applying the - operator.

fn sub(self, other: Wrapping<F>) -> Wrapping<F>

Performs the - operation.

impl<'a, F: Fixed> Sub<Wrapping<F>> for &'a Wrapping<F>

type Output = Wrapping<F>

The resulting type after applying the - operator.

fn sub(self, other: Wrapping<F>) -> Wrapping<F>

Performs the - operation.

impl<'a, F: Fixed> SubAssign<&'a Wrapping<F>> for Wrapping<F>

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

Performs the -= operation.

impl<F: Fixed> SubAssign<Wrapping<F>> for Wrapping<F>

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

Performs the -= operation.

impl<'a, F: 'a + Fixed> Sum<&'a Wrapping<F>> for Wrapping<F>

fn sum<I>(iter: I) -> Wrapping<F> where
    I: Iterator<Item = &'a Wrapping<F>>, 

Method which takes an iterator and generates Self from the elements by "summing up" the items.

impl<F: Fixed> Sum<Wrapping<F>> for Wrapping<F>

fn sum<I>(iter: I) -> Wrapping<F> where
    I: Iterator<Item = Wrapping<F>>, 

Method which takes an iterator and generates Self from the elements by "summing up" the items.