Struct substrate_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 substrate_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);

Tuple Fields

0: F

Implementations

impl<F: Fixed> Wrapping<F>

pub fn min_value() -> Wrapping<F>

Returns the smallest value that can be represented.

Examples

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

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

Rounding is to the nearest, with ties rounded to even.

Examples

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

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

Rounding is to the nearest, with ties rounded to even.

Examples

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

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

Rounding is to the nearest, with ties rounded to even.

Examples

use substrate_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 substrate_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 substrate_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 substrate_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 substrate_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 substrate_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 substrate_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 substrate_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 substrate_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 substrate_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 substrate_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 substrate_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 substrate_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 substrate_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 substrate_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 substrate_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 substrate_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 substrate_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 substrate_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 substrate_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 substrate_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 substrate_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 substrate_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 substrate_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, '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<'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, 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<F: Fixed> Add 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> AddAssign<&'a Wrapping<F>> for Wrapping<F>

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

Performs the += operation.

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

fn add_assign(&mut self, other: 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<'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, 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<F> BitAnd 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> 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 for Wrapping<F>where F: BitAndAssign<F>,

fn bitand_assign(&mut self, other: 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<'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, 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<F> BitOr 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> 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 for Wrapping<F>where F: BitOrAssign<F>,

fn bitor_assign(&mut self, other: 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<'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, 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<F> BitXor 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> 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 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: 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: 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: 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: 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: 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<'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: 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<F: Fixed> Display for Wrapping<F>

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

Formats the value using the given formatter.

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

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

Performs the /= operation.

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

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

Wraps a fixed-point number.

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

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

Parses a string slice containing decimal digits to return a fixed-point number.

Rounding is to the nearest, with ties rounded to even.

type Err = ParseFixedError

The associated error which can be returned from parsing.

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, Self: Sized,

Feeds a slice of this type into the given Hasher.

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

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

Performs the *= 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: 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> 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> 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<F: Ord> Ord for Wrapping<F>

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

This method returns an Ordering between self and other.

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

Compares and returns the maximum of two values.

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

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl<F: PartialEq> PartialEq 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: &Rhs) -> bool

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

impl<F: PartialOrd> PartialOrd 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: &Rhs) -> bool

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

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

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

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

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

fn ge(&self, other: &Rhs) -> 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 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, '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, 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, 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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<'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, 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<'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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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<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<F: Fixed> Rem 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> 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<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<F: Fixed> RemAssign for Wrapping<F>

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

Performs the %= operation.

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

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

Performs the -= operation.

impl<F: Fixed> SubAssign 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 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.

impl<F> TypeInfo for Wrapping<F>where F: TypeInfo + 'static,

type Identity = Wrapping<F>

The type identifying for which type info is provided.

fn type_info() -> Type

Returns the static type identifier for Self.

impl<F: Copy> Copy for Wrapping<F>

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

impl<F> StructuralEq for Wrapping<F>

impl<F> StructuralPartialEq for Wrapping<F>