[][src]Struct fixed::Wrapping

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

Provides intentionally wrapped arithmetic on fixed-point numbers.

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

Examples

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

Implementations

impl<F: Fixed> Wrapping<F>[src]

pub const MIN: Wrapping<F>[src]

The smallest value that can be represented.

Examples

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

pub const MAX: Wrapping<F>[src]

The largest value that can be represented.

Examples

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

pub const INT_NBITS: u32[src]

The number of integer bits.

Examples

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

pub const FRAC_NBITS: u32[src]

The number of fractional bits.

Examples

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

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

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

Examples

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

pub fn to_bits(self) -> F::Bits[src]

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

Examples

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

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

Wrapping conversion from another number.

The other number can be:

Panics

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

Examples

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

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

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

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

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

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

Examples

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

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

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

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

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 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>[src]

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 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>[src]

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 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>[src]

Returns the integer part.

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

Examples

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

pub fn frac(self) -> Wrapping<F>[src]

Returns the fractional part.

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

Examples

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

pub fn round_to_zero(self) -> Wrapping<F>[src]

Rounds to the next integer towards 0.

Examples

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

pub fn ceil(self) -> Wrapping<F>[src]

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

Examples

use fixed::{types::I16F16, Wrapping};
let two_half = Wrapping(I16F16::from_num(5) / 2);
assert_eq!(two_half.ceil(), Wrapping(I16F16::from_num(3)));
assert_eq!(Wrapping(I16F16::MAX).ceil(), Wrapping(I16F16::MIN));

pub fn floor(self) -> Wrapping<F>[src]

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

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

Examples

use fixed::{
    types::{I0F32, I16F16},
    Wrapping,
};
let two_half = Wrapping(I16F16::from_num(5) / 2);
assert_eq!(two_half.floor(), Wrapping(I16F16::from_num(2)));
assert_eq!(Wrapping(I0F32::MIN).floor(), Wrapping(I0F32::from_num(0)));

pub fn round(self) -> Wrapping<F>[src]

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

Examples

use fixed::{types::I16F16, Wrapping};
let two_half = Wrapping(I16F16::from_num(5) / 2);
assert_eq!(two_half.round(), Wrapping(I16F16::from_num(3)));
assert_eq!((-two_half).round(), Wrapping(I16F16::from_num(-3)));
assert_eq!(Wrapping(I16F16::MAX).round(), Wrapping(I16F16::MIN));

pub fn round_ties_to_even(self) -> Wrapping<F>[src]

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

Examples

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

pub fn count_ones(self) -> u32[src]

Returns the number of ones in the binary representation.

Examples

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

pub fn count_zeros(self) -> u32[src]

Returns the number of zeros in the binary representation.

Examples

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

pub fn leading_ones(self) -> u32[src]

Returns the number of leading ones in the binary representation.

Examples

use fixed::{types::U16F16, Wrapping};
let w = Wrapping(U16F16::from_bits(0xFF00_00FF));
assert_eq!(w.leading_ones(), w.0.leading_ones());

pub fn leading_zeros(self) -> u32[src]

Returns the number of leading zeros in the binary representation.

Examples

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

pub fn trailing_ones(self) -> u32[src]

Returns the number of trailing ones in the binary representation.

Examples

use fixed::{types::U16F16, Wrapping};
let w = Wrapping(U16F16::from_bits(0xFF00_00FF));
assert_eq!(w.trailing_ones(), w.0.trailing_ones());

pub fn trailing_zeros(self) -> u32[src]

Returns the number of trailing zeros in the binary representation.

Examples

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

pub fn int_log2(self) -> i32[src]

Integer base-2 logarithm, rounded down.

Panics

Panics if the fixed-point number is ≤ 0.

pub fn int_log10(self) -> i32[src]

Integer base-10 logarithm, rounded down.

Panics

Panics if the fixed-point number is ≤ 0.

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

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

Examples

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

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

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

Examples

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

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

Euclidean division.

Panics

Panics if the divisor is zero.

Examples

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

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

Remainder for Euclidean division.

Panics

Panics if the divisor is zero.

Examples

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

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

Euclidean division by an integer.

Panics

Panics if the divisor is zero.

Examples

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

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

Remainder for Euclidean division.

Panics

Panics if the divisor is zero.

Examples

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

pub fn min_value() -> Wrapping<F>[src]

Deprecated since 0.5.5:

replaced by MIN

Returns the smallest value that can be represented.

pub fn max_value() -> Wrapping<F>[src]

Deprecated since 0.5.5:

replaced by MAX

Returns the largest value that can be represented.

pub fn int_nbits() -> u32[src]

Deprecated since 0.5.5:

replaced by INT_NBITS

Returns the number of integer bits.

pub fn frac_nbits() -> u32[src]

Deprecated since 0.5.5:

replaced by FRAC_NBITS

Returns the number of fractional bits.

impl<F: FixedSigned> Wrapping<F>[src]

pub fn is_positive(self) -> bool[src]

Returns true if the number is > 0.

Examples

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

pub fn is_negative(self) -> bool[src]

Returns true if the number is < 0.

Examples

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

pub fn abs(self) -> Wrapping<F>[src]

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

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

Examples

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

pub fn signum(self) -> Wrapping<F>[src]

Returns a number representing the sign of self.

Warning

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

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

Examples

use fixed::{
    types::{I0F32, I1F31, 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)));

assert_eq!(Wrapping(<I1F31>::from_num(0.5)).signum(), Wrapping(I1F31::from_num(-1)));
assert_eq!(Wrapping(<I0F32>::from_num(0.25)).signum(), Wrapping(I0F32::from_num(0)));
assert_eq!(Wrapping(<I0F32>::from_num(-0.5)).signum(), Wrapping(I0F32::from_num(0)));

impl<F: FixedUnsigned> Wrapping<F>[src]

pub fn is_power_of_two(self) -> bool[src]

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

Examples

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

pub fn next_power_of_two(self) -> Wrapping<F>[src]

Returns the smallest power of two that is ≥ self.

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

Examples

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

Trait Implementations

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

type Output = Wrapping<F>

The resulting type after applying the + operator.

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

type Output = Wrapping<F>

The resulting type after applying the + operator.

impl<F: Fixed> Add<Wrapping<F>> for Wrapping<F>[src]

type Output = Wrapping<F>

The resulting type after applying the + operator.

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

type Output = Wrapping<F>

The resulting type after applying the + operator.

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

impl<F: Fixed> AddAssign<Wrapping<F>> for Wrapping<F>[src]

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

type Output = Wrapping<F>

The resulting type after applying the & operator.

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

type Output = Wrapping<F>

The resulting type after applying the & operator.

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

type Output = Wrapping<F>

The resulting type after applying the & operator.

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

type Output = Wrapping<F>

The resulting type after applying the & operator.

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

impl<F> BitAndAssign<Wrapping<F>> for Wrapping<F> where
    F: BitAndAssign<F>, 
[src]

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

type Output = Wrapping<F>

The resulting type after applying the | operator.

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

type Output = Wrapping<F>

The resulting type after applying the | operator.

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

type Output = Wrapping<F>

The resulting type after applying the | operator.

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

type Output = Wrapping<F>

The resulting type after applying the | operator.

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

impl<F> BitOrAssign<Wrapping<F>> for Wrapping<F> where
    F: BitOrAssign<F>, 
[src]

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

type Output = Wrapping<F>

The resulting type after applying the ^ operator.

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

type Output = Wrapping<F>

The resulting type after applying the ^ operator.

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

type Output = Wrapping<F>

The resulting type after applying the ^ operator.

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

type Output = Wrapping<F>

The resulting type after applying the ^ operator.

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

impl<F> BitXorAssign<Wrapping<F>> for Wrapping<F> where
    F: BitXorAssign<F>, 
[src]

impl<F: Clone> Clone for Wrapping<F>[src]

impl<F: Copy> Copy for Wrapping<F>[src]

impl<F: Debug> Debug for Wrapping<F>[src]

impl<F: Default> Default for Wrapping<F>[src]

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

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

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

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

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

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

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

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

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

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

impl<F: Fixed> Display for Wrapping<F>[src]

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

type Output = Wrapping<F>

The resulting type after applying the / operator.

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

type Output = Wrapping<F>

The resulting type after applying the / operator.

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

type Output = Wrapping<FixedI128<Frac>>

The resulting type after applying the / operator.

impl<'a, 'b, Frac> Div<&'a i128> for &'b Wrapping<FixedI128<Frac>>[src]

type Output = Wrapping<FixedI128<Frac>>

The resulting type after applying the / operator.

impl<'a, Frac> Div<&'a i16> for Wrapping<FixedI16<Frac>>[src]

type Output = Wrapping<FixedI16<Frac>>

The resulting type after applying the / operator.

impl<'a, 'b, Frac> Div<&'a i16> for &'b Wrapping<FixedI16<Frac>>[src]

type Output = Wrapping<FixedI16<Frac>>

The resulting type after applying the / operator.

impl<'a, Frac> Div<&'a i32> for Wrapping<FixedI32<Frac>>[src]

type Output = Wrapping<FixedI32<Frac>>

The resulting type after applying the / operator.

impl<'a, 'b, Frac> Div<&'a i32> for &'b Wrapping<FixedI32<Frac>>[src]

type Output = Wrapping<FixedI32<Frac>>

The resulting type after applying the / operator.

impl<'a, Frac> Div<&'a i64> for Wrapping<FixedI64<Frac>>[src]

type Output = Wrapping<FixedI64<Frac>>

The resulting type after applying the / operator.

impl<'a, 'b, Frac> Div<&'a i64> for &'b Wrapping<FixedI64<Frac>>[src]

type Output = Wrapping<FixedI64<Frac>>

The resulting type after applying the / operator.

impl<'a, Frac> Div<&'a i8> for Wrapping<FixedI8<Frac>>[src]

type Output = Wrapping<FixedI8<Frac>>

The resulting type after applying the / operator.

impl<'a, 'b, Frac> Div<&'a i8> for &'b Wrapping<FixedI8<Frac>>[src]

type Output = Wrapping<FixedI8<Frac>>

The resulting type after applying the / operator.

impl<'a, Frac> Div<&'a u128> for Wrapping<FixedU128<Frac>>[src]

type Output = Wrapping<FixedU128<Frac>>

The resulting type after applying the / operator.

impl<'a, 'b, Frac> Div<&'a u128> for &'b Wrapping<FixedU128<Frac>>[src]

type Output = Wrapping<FixedU128<Frac>>

The resulting type after applying the / operator.

impl<'a, Frac> Div<&'a u16> for Wrapping<FixedU16<Frac>>[src]

type Output = Wrapping<FixedU16<Frac>>

The resulting type after applying the / operator.

impl<'a, 'b, Frac> Div<&'a u16> for &'b Wrapping<FixedU16<Frac>>[src]

type Output = Wrapping<FixedU16<Frac>>

The resulting type after applying the / operator.

impl<'a, Frac> Div<&'a u32> for Wrapping<FixedU32<Frac>>[src]

type Output = Wrapping<FixedU32<Frac>>

The resulting type after applying the / operator.

impl<'a, 'b, Frac> Div<&'a u32> for &'b Wrapping<FixedU32<Frac>>[src]

type Output = Wrapping<FixedU32<Frac>>

The resulting type after applying the / operator.

impl<'a, Frac> Div<&'a u64> for Wrapping<FixedU64<Frac>>[src]

type Output = Wrapping<FixedU64<Frac>>

The resulting type after applying the / operator.

impl<'a, 'b, Frac> Div<&'a u64> for &'b Wrapping<FixedU64<Frac>>[src]

type Output = Wrapping<FixedU64<Frac>>

The resulting type after applying the / operator.

impl<'a, Frac> Div<&'a u8> for Wrapping<FixedU8<Frac>>[src]

type Output = Wrapping<FixedU8<Frac>>

The resulting type after applying the / operator.

impl<'a, 'b, Frac> Div<&'a u8> for &'b Wrapping<FixedU8<Frac>>[src]

type Output = Wrapping<FixedU8<Frac>>

The resulting type after applying the / operator.

impl<F: Fixed> Div<Wrapping<F>> for Wrapping<F>[src]

type Output = Wrapping<F>

The resulting type after applying the / operator.

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

type Output = Wrapping<F>

The resulting type after applying the / operator.

impl<Frac> Div<i128> for Wrapping<FixedI128<Frac>>[src]

type Output = Wrapping<FixedI128<Frac>>

The resulting type after applying the / operator.

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

type Output = Wrapping<FixedI128<Frac>>

The resulting type after applying the / operator.

impl<Frac> Div<i16> for Wrapping<FixedI16<Frac>>[src]

type Output = Wrapping<FixedI16<Frac>>

The resulting type after applying the / operator.

impl<'a, Frac> Div<i16> for &'a Wrapping<FixedI16<Frac>>[src]

type Output = Wrapping<FixedI16<Frac>>

The resulting type after applying the / operator.

impl<Frac> Div<i32> for Wrapping<FixedI32<Frac>>[src]

type Output = Wrapping<FixedI32<Frac>>

The resulting type after applying the / operator.

impl<'a, Frac> Div<i32> for &'a Wrapping<FixedI32<Frac>>[src]

type Output = Wrapping<FixedI32<Frac>>

The resulting type after applying the / operator.

impl<Frac> Div<i64> for Wrapping<FixedI64<Frac>>[src]

type Output = Wrapping<FixedI64<Frac>>

The resulting type after applying the / operator.

impl<'a, Frac> Div<i64> for &'a Wrapping<FixedI64<Frac>>[src]

type Output = Wrapping<FixedI64<Frac>>

The resulting type after applying the / operator.

impl<Frac> Div<i8> for Wrapping<FixedI8<Frac>>[src]

type Output = Wrapping<FixedI8<Frac>>

The resulting type after applying the / operator.

impl<'a, Frac> Div<i8> for &'a Wrapping<FixedI8<Frac>>[src]

type Output = Wrapping<FixedI8<Frac>>

The resulting type after applying the / operator.

impl<Frac> Div<u128> for Wrapping<FixedU128<Frac>>[src]

type Output = Wrapping<FixedU128<Frac>>

The resulting type after applying the / operator.

impl<'a, Frac> Div<u128> for &'a Wrapping<FixedU128<Frac>>[src]

type Output = Wrapping<FixedU128<Frac>>

The resulting type after applying the / operator.

impl<Frac> Div<u16> for Wrapping<FixedU16<Frac>>[src]

type Output = Wrapping<FixedU16<Frac>>

The resulting type after applying the / operator.

impl<'a, Frac> Div<u16> for &'a Wrapping<FixedU16<Frac>>[src]

type Output = Wrapping<FixedU16<Frac>>

The resulting type after applying the / operator.

impl<Frac> Div<u32> for Wrapping<FixedU32<Frac>>[src]

type Output = Wrapping<FixedU32<Frac>>

The resulting type after applying the / operator.

impl<'a, Frac> Div<u32> for &'a Wrapping<FixedU32<Frac>>[src]

type Output = Wrapping<FixedU32<Frac>>

The resulting type after applying the / operator.

impl<Frac> Div<u64> for Wrapping<FixedU64<Frac>>[src]

type Output = Wrapping<FixedU64<Frac>>

The resulting type after applying the / operator.

impl<'a, Frac> Div<u64> for &'a Wrapping<FixedU64<Frac>>[src]

type Output = Wrapping<FixedU64<Frac>>

The resulting type after applying the / operator.

impl<Frac> Div<u8> for Wrapping<FixedU8<Frac>>[src]

type Output = Wrapping<FixedU8<Frac>>

The resulting type after applying the / operator.

impl<'a, Frac> Div<u8> for &'a Wrapping<FixedU8<Frac>>[src]

type Output = Wrapping<FixedU8<Frac>>

The resulting type after applying the / operator.

impl<'a, F: Fixed> DivAssign<&'a Wrapping<F>> for Wrapping<F>[src]

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

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

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

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

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

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

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

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

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

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

impl<F: Fixed> DivAssign<Wrapping<F>> for Wrapping<F>[src]

impl<Frac> DivAssign<i128> for Wrapping<FixedI128<Frac>>[src]

impl<Frac> DivAssign<i16> for Wrapping<FixedI16<Frac>>[src]

impl<Frac> DivAssign<i32> for Wrapping<FixedI32<Frac>>[src]

impl<Frac> DivAssign<i64> for Wrapping<FixedI64<Frac>>[src]

impl<Frac> DivAssign<i8> for Wrapping<FixedI8<Frac>>[src]

impl<Frac> DivAssign<u128> for Wrapping<FixedU128<Frac>>[src]

impl<Frac> DivAssign<u16> for Wrapping<FixedU16<Frac>>[src]

impl<Frac> DivAssign<u32> for Wrapping<FixedU32<Frac>>[src]

impl<Frac> DivAssign<u64> for Wrapping<FixedU64<Frac>>[src]

impl<Frac> DivAssign<u8> for Wrapping<FixedU8<Frac>>[src]

impl<F: Eq> Eq for Wrapping<F>[src]

impl<F: Fixed> From<F> for Wrapping<F>[src]

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

Wraps a fixed-point number.

impl<F: Fixed> FromStr for Wrapping<F>[src]

type Err = ParseFixedError

The associated error which can be returned from parsing.

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

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

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

impl<F: Hash> Hash for Wrapping<F>[src]

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

type Output = Wrapping<F>

The resulting type after applying the * operator.

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

type Output = Wrapping<F>

The resulting type after applying the * operator.

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

type Output = Wrapping<FixedI128<Frac>>

The resulting type after applying the * operator.

impl<'a, 'b, Frac> Mul<&'a i128> for &'b Wrapping<FixedI128<Frac>>[src]

type Output = Wrapping<FixedI128<Frac>>

The resulting type after applying the * operator.

impl<'a, Frac> Mul<&'a i16> for Wrapping<FixedI16<Frac>>[src]

type Output = Wrapping<FixedI16<Frac>>

The resulting type after applying the * operator.

impl<'a, 'b, Frac> Mul<&'a i16> for &'b Wrapping<FixedI16<Frac>>[src]

type Output = Wrapping<FixedI16<Frac>>

The resulting type after applying the * operator.

impl<'a, Frac> Mul<&'a i32> for Wrapping<FixedI32<Frac>>[src]

type Output = Wrapping<FixedI32<Frac>>

The resulting type after applying the * operator.

impl<'a, 'b, Frac> Mul<&'a i32> for &'b Wrapping<FixedI32<Frac>>[src]

type Output = Wrapping<FixedI32<Frac>>

The resulting type after applying the * operator.

impl<'a, Frac> Mul<&'a i64> for Wrapping<FixedI64<Frac>>[src]

type Output = Wrapping<FixedI64<Frac>>

The resulting type after applying the * operator.

impl<'a, 'b, Frac> Mul<&'a i64> for &'b Wrapping<FixedI64<Frac>>[src]

type Output = Wrapping<FixedI64<Frac>>

The resulting type after applying the * operator.

impl<'a, Frac> Mul<&'a i8> for Wrapping<FixedI8<Frac>>[src]

type Output = Wrapping<FixedI8<Frac>>

The resulting type after applying the * operator.

impl<'a, 'b, Frac> Mul<&'a i8> for &'b Wrapping<FixedI8<Frac>>[src]

type Output = Wrapping<FixedI8<Frac>>

The resulting type after applying the * operator.

impl<'a, Frac> Mul<&'a u128> for Wrapping<FixedU128<Frac>>[src]

type Output = Wrapping<FixedU128<Frac>>

The resulting type after applying the * operator.

impl<'a, 'b, Frac> Mul<&'a u128> for &'b Wrapping<FixedU128<Frac>>[src]

type Output = Wrapping<FixedU128<Frac>>

The resulting type after applying the * operator.

impl<'a, Frac> Mul<&'a u16> for Wrapping<FixedU16<Frac>>[src]

type Output = Wrapping<FixedU16<Frac>>

The resulting type after applying the * operator.

impl<'a, 'b, Frac> Mul<&'a u16> for &'b Wrapping<FixedU16<Frac>>[src]

type Output = Wrapping<FixedU16<Frac>>

The resulting type after applying the * operator.

impl<'a, Frac> Mul<&'a u32> for Wrapping<FixedU32<Frac>>[src]

type Output = Wrapping<FixedU32<Frac>>

The resulting type after applying the * operator.

impl<'a, 'b, Frac> Mul<&'a u32> for &'b Wrapping<FixedU32<Frac>>[src]

type Output = Wrapping<FixedU32<Frac>>

The resulting type after applying the * operator.

impl<'a, Frac> Mul<&'a u64> for Wrapping<FixedU64<Frac>>[src]

type Output = Wrapping<FixedU64<Frac>>

The resulting type after applying the * operator.

impl<'a, 'b, Frac> Mul<&'a u64> for &'b Wrapping<FixedU64<Frac>>[src]

type Output = Wrapping<FixedU64<Frac>>

The resulting type after applying the * operator.

impl<'a, Frac> Mul<&'a u8> for Wrapping<FixedU8<Frac>>[src]

type Output = Wrapping<FixedU8<Frac>>

The resulting type after applying the * operator.

impl<'a, 'b, Frac> Mul<&'a u8> for &'b Wrapping<FixedU8<Frac>>[src]

type Output = Wrapping<FixedU8<Frac>>

The resulting type after applying the * operator.

impl<F: Fixed> Mul<Wrapping<F>> for Wrapping<F>[src]

type Output = Wrapping<F>

The resulting type after applying the * operator.

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

type Output = Wrapping<F>

The resulting type after applying the * operator.

impl<Frac> Mul<i128> for Wrapping<FixedI128<Frac>>[src]

type Output = Wrapping<FixedI128<Frac>>

The resulting type after applying the * operator.

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

type Output = Wrapping<FixedI128<Frac>>

The resulting type after applying the * operator.

impl<Frac> Mul<i16> for Wrapping<FixedI16<Frac>>[src]

type Output = Wrapping<FixedI16<Frac>>

The resulting type after applying the * operator.

impl<'a, Frac> Mul<i16> for &'a Wrapping<FixedI16<Frac>>[src]

type Output = Wrapping<FixedI16<Frac>>

The resulting type after applying the * operator.

impl<Frac> Mul<i32> for Wrapping<FixedI32<Frac>>[src]

type Output = Wrapping<FixedI32<Frac>>

The resulting type after applying the * operator.

impl<'a, Frac> Mul<i32> for &'a Wrapping<FixedI32<Frac>>[src]

type Output = Wrapping<FixedI32<Frac>>

The resulting type after applying the * operator.

impl<Frac> Mul<i64> for Wrapping<FixedI64<Frac>>[src]

type Output = Wrapping<FixedI64<Frac>>

The resulting type after applying the * operator.

impl<'a, Frac> Mul<i64> for &'a Wrapping<FixedI64<Frac>>[src]

type Output = Wrapping<FixedI64<Frac>>

The resulting type after applying the * operator.

impl<Frac> Mul<i8> for Wrapping<FixedI8<Frac>>[src]

type Output = Wrapping<FixedI8<Frac>>

The resulting type after applying the * operator.

impl<'a, Frac> Mul<i8> for &'a Wrapping<FixedI8<Frac>>[src]

type Output = Wrapping<FixedI8<Frac>>

The resulting type after applying the * operator.

impl<Frac> Mul<u128> for Wrapping<FixedU128<Frac>>[src]

type Output = Wrapping<FixedU128<Frac>>

The resulting type after applying the * operator.

impl<'a, Frac> Mul<u128> for &'a Wrapping<FixedU128<Frac>>[src]

type Output = Wrapping<FixedU128<Frac>>

The resulting type after applying the * operator.

impl<Frac> Mul<u16> for Wrapping<FixedU16<Frac>>[src]

type Output = Wrapping<FixedU16<Frac>>

The resulting type after applying the * operator.

impl<'a, Frac> Mul<u16> for &'a Wrapping<FixedU16<Frac>>[src]

type Output = Wrapping<FixedU16<Frac>>

The resulting type after applying the * operator.

impl<Frac> Mul<u32> for Wrapping<FixedU32<Frac>>[src]

type Output = Wrapping<FixedU32<Frac>>

The resulting type after applying the * operator.

impl<'a, Frac> Mul<u32> for &'a Wrapping<FixedU32<Frac>>[src]

type Output = Wrapping<FixedU32<Frac>>

The resulting type after applying the * operator.

impl<Frac> Mul<u64> for Wrapping<FixedU64<Frac>>[src]

type Output = Wrapping<FixedU64<Frac>>

The resulting type after applying the * operator.

impl<'a, Frac> Mul<u64> for &'a Wrapping<FixedU64<Frac>>[src]

type Output = Wrapping<FixedU64<Frac>>

The resulting type after applying the * operator.

impl<Frac> Mul<u8> for Wrapping<FixedU8<Frac>>[src]

type Output = Wrapping<FixedU8<Frac>>

The resulting type after applying the * operator.

impl<'a, Frac> Mul<u8> for &'a Wrapping<FixedU8<Frac>>[src]

type Output = Wrapping<FixedU8<Frac>>

The resulting type after applying the * operator.

impl<'a, F: Fixed> MulAssign<&'a Wrapping<F>> for Wrapping<F>[src]

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

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

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

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

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

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

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

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

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

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

impl<F: Fixed> MulAssign<Wrapping<F>> for Wrapping<F>[src]

impl<Frac> MulAssign<i128> for Wrapping<FixedI128<Frac>>[src]

impl<Frac> MulAssign<i16> for Wrapping<FixedI16<Frac>>[src]

impl<Frac> MulAssign<i32> for Wrapping<FixedI32<Frac>>[src]

impl<Frac> MulAssign<i64> for Wrapping<FixedI64<Frac>>[src]

impl<Frac> MulAssign<i8> for Wrapping<FixedI8<Frac>>[src]

impl<Frac> MulAssign<u128> for Wrapping<FixedU128<Frac>>[src]

impl<Frac> MulAssign<u16> for Wrapping<FixedU16<Frac>>[src]

impl<Frac> MulAssign<u32> for Wrapping<FixedU32<Frac>>[src]

impl<Frac> MulAssign<u64> for Wrapping<FixedU64<Frac>>[src]

impl<Frac> MulAssign<u8> for Wrapping<FixedU8<Frac>>[src]

impl<F: Fixed> Neg for Wrapping<F>[src]

type Output = Wrapping<F>

The resulting type after applying the - operator.

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

type Output = Wrapping<F>

The resulting type after applying the - operator.

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

type Output = Wrapping<F>

The resulting type after applying the ! operator.

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

type Output = Wrapping<F>

The resulting type after applying the ! operator.

impl<F: Ord> Ord for Wrapping<F>[src]

impl<F: PartialEq> PartialEq<Wrapping<F>> for Wrapping<F>[src]

impl<F: PartialOrd> PartialOrd<Wrapping<F>> for Wrapping<F>[src]

impl<'a, F: 'a + Fixed> Product<&'a Wrapping<F>> for Wrapping<F>[src]

impl<F: Fixed> Product<Wrapping<F>> for Wrapping<F>[src]

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

type Output = Wrapping<F>

The resulting type after applying the % operator.

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

type Output = Wrapping<F>

The resulting type after applying the % operator.

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

type Output = Wrapping<FixedI128<Frac>>

The resulting type after applying the % operator.

impl<'a, 'b, Frac: LeEqU128> Rem<&'a i128> for &'b Wrapping<FixedI128<Frac>>[src]

type Output = Wrapping<FixedI128<Frac>>

The resulting type after applying the % operator.

impl<'a, Frac: LeEqU16> Rem<&'a i16> for Wrapping<FixedI16<Frac>>[src]

type Output = Wrapping<FixedI16<Frac>>

The resulting type after applying the % operator.

impl<'a, 'b, Frac: LeEqU16> Rem<&'a i16> for &'b Wrapping<FixedI16<Frac>>[src]

type Output = Wrapping<FixedI16<Frac>>

The resulting type after applying the % operator.

impl<'a, Frac: LeEqU32> Rem<&'a i32> for Wrapping<FixedI32<Frac>>[src]

type Output = Wrapping<FixedI32<Frac>>

The resulting type after applying the % operator.

impl<'a, 'b, Frac: LeEqU32> Rem<&'a i32> for &'b Wrapping<FixedI32<Frac>>[src]

type Output = Wrapping<FixedI32<Frac>>

The resulting type after applying the % operator.

impl<'a, Frac: LeEqU64> Rem<&'a i64> for Wrapping<FixedI64<Frac>>[src]

type Output = Wrapping<FixedI64<Frac>>

The resulting type after applying the % operator.

impl<'a, 'b, Frac: LeEqU64> Rem<&'a i64> for &'b Wrapping<FixedI64<Frac>>[src]

type Output = Wrapping<FixedI64<Frac>>

The resulting type after applying the % operator.

impl<'a, Frac: LeEqU8> Rem<&'a i8> for Wrapping<FixedI8<Frac>>[src]

type Output = Wrapping<FixedI8<Frac>>

The resulting type after applying the % operator.

impl<'a, 'b, Frac: LeEqU8> Rem<&'a i8> for &'b Wrapping<FixedI8<Frac>>[src]

type Output = Wrapping<FixedI8<Frac>>

The resulting type after applying the % operator.

impl<'a, Frac: LeEqU128> Rem<&'a u128> for Wrapping<FixedU128<Frac>>[src]

type Output = Wrapping<FixedU128<Frac>>

The resulting type after applying the % operator.

impl<'a, 'b, Frac: LeEqU128> Rem<&'a u128> for &'b Wrapping<FixedU128<Frac>>[src]

type Output = Wrapping<FixedU128<Frac>>

The resulting type after applying the % operator.

impl<'a, Frac: LeEqU16> Rem<&'a u16> for Wrapping<FixedU16<Frac>>[src]

type Output = Wrapping<FixedU16<Frac>>

The resulting type after applying the % operator.

impl<'a, 'b, Frac: LeEqU16> Rem<&'a u16> for &'b Wrapping<FixedU16<Frac>>[src]

type Output = Wrapping<FixedU16<Frac>>

The resulting type after applying the % operator.

impl<'a, Frac: LeEqU32> Rem<&'a u32> for Wrapping<FixedU32<Frac>>[src]

type Output = Wrapping<FixedU32<Frac>>

The resulting type after applying the % operator.

impl<'a, 'b, Frac: LeEqU32> Rem<&'a u32> for &'b Wrapping<FixedU32<Frac>>[src]

type Output = Wrapping<FixedU32<Frac>>

The resulting type after applying the % operator.

impl<'a, Frac: LeEqU64> Rem<&'a u64> for Wrapping<FixedU64<Frac>>[src]

type Output = Wrapping<FixedU64<Frac>>

The resulting type after applying the % operator.

impl<'a, 'b, Frac: LeEqU64> Rem<&'a u64> for &'b Wrapping<FixedU64<Frac>>[src]

type Output = Wrapping<FixedU64<Frac>>

The resulting type after applying the % operator.

impl<'a, Frac: LeEqU8> Rem<&'a u8> for Wrapping<FixedU8<Frac>>[src]

type Output = Wrapping<FixedU8<Frac>>

The resulting type after applying the % operator.

impl<'a, 'b, Frac: LeEqU8> Rem<&'a u8> for &'b Wrapping<FixedU8<Frac>>[src]

type Output = Wrapping<FixedU8<Frac>>

The resulting type after applying the % operator.

impl<F: Fixed> Rem<Wrapping<F>> for Wrapping<F>[src]

type Output = Wrapping<F>

The resulting type after applying the % operator.

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

type Output = Wrapping<F>

The resulting type after applying the % operator.

impl<Frac: LeEqU128> Rem<i128> for Wrapping<FixedI128<Frac>>[src]

type Output = Wrapping<FixedI128<Frac>>

The resulting type after applying the % operator.

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

type Output = Wrapping<FixedI128<Frac>>

The resulting type after applying the % operator.

impl<Frac: LeEqU16> Rem<i16> for Wrapping<FixedI16<Frac>>[src]

type Output = Wrapping<FixedI16<Frac>>

The resulting type after applying the % operator.

impl<'a, Frac: LeEqU16> Rem<i16> for &'a Wrapping<FixedI16<Frac>>[src]

type Output = Wrapping<FixedI16<Frac>>

The resulting type after applying the % operator.

impl<Frac: LeEqU32> Rem<i32> for Wrapping<FixedI32<Frac>>[src]

type Output = Wrapping<FixedI32<Frac>>

The resulting type after applying the % operator.

impl<'a, Frac: LeEqU32> Rem<i32> for &'a Wrapping<FixedI32<Frac>>[src]

type Output = Wrapping<FixedI32<Frac>>

The resulting type after applying the % operator.

impl<Frac: LeEqU64> Rem<i64> for Wrapping<FixedI64<Frac>>[src]

type Output = Wrapping<FixedI64<Frac>>

The resulting type after applying the % operator.

impl<'a, Frac: LeEqU64> Rem<i64> for &'a Wrapping<FixedI64<Frac>>[src]

type Output = Wrapping<FixedI64<Frac>>

The resulting type after applying the % operator.

impl<Frac: LeEqU8> Rem<i8> for Wrapping<FixedI8<Frac>>[src]

type Output = Wrapping<FixedI8<Frac>>

The resulting type after applying the % operator.

impl<'a, Frac: LeEqU8> Rem<i8> for &'a Wrapping<FixedI8<Frac>>[src]

type Output = Wrapping<FixedI8<Frac>>

The resulting type after applying the % operator.

impl<Frac: LeEqU128> Rem<u128> for Wrapping<FixedU128<Frac>>[src]

type Output = Wrapping<FixedU128<Frac>>

The resulting type after applying the % operator.

impl<'a, Frac: LeEqU128> Rem<u128> for &'a Wrapping<FixedU128<Frac>>[src]

type Output = Wrapping<FixedU128<Frac>>

The resulting type after applying the % operator.

impl<Frac: LeEqU16> Rem<u16> for Wrapping<FixedU16<Frac>>[src]

type Output = Wrapping<FixedU16<Frac>>

The resulting type after applying the % operator.

impl<'a, Frac: LeEqU16> Rem<u16> for &'a Wrapping<FixedU16<Frac>>[src]

type Output = Wrapping<FixedU16<Frac>>

The resulting type after applying the % operator.

impl<Frac: LeEqU32> Rem<u32> for Wrapping<FixedU32<Frac>>[src]

type Output = Wrapping<FixedU32<Frac>>

The resulting type after applying the % operator.

impl<'a, Frac: LeEqU32> Rem<u32> for &'a Wrapping<FixedU32<Frac>>[src]

type Output = Wrapping<FixedU32<Frac>>

The resulting type after applying the % operator.

impl<Frac: LeEqU64> Rem<u64> for Wrapping<FixedU64<Frac>>[src]

type Output = Wrapping<FixedU64<Frac>>

The resulting type after applying the % operator.

impl<'a, Frac: LeEqU64> Rem<u64> for &'a Wrapping<FixedU64<Frac>>[src]

type Output = Wrapping<FixedU64<Frac>>

The resulting type after applying the % operator.

impl<Frac: LeEqU8> Rem<u8> for Wrapping<FixedU8<Frac>>[src]

type Output = Wrapping<FixedU8<Frac>>

The resulting type after applying the % operator.

impl<'a, Frac: LeEqU8> Rem<u8> for &'a Wrapping<FixedU8<Frac>>[src]

type Output = Wrapping<FixedU8<Frac>>

The resulting type after applying the % operator.

impl<'a, F: Fixed> RemAssign<&'a Wrapping<F>> for Wrapping<F>[src]

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

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

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

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

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

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

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

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

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

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

impl<F: Fixed> RemAssign<Wrapping<F>> for Wrapping<F>[src]

impl<Frac: LeEqU128> RemAssign<i128> for Wrapping<FixedI128<Frac>>[src]

impl<Frac: LeEqU16> RemAssign<i16> for Wrapping<FixedI16<Frac>>[src]

impl<Frac: LeEqU32> RemAssign<i32> for Wrapping<FixedI32<Frac>>[src]

impl<Frac: LeEqU64> RemAssign<i64> for Wrapping<FixedI64<Frac>>[src]

impl<Frac: LeEqU8> RemAssign<i8> for Wrapping<FixedI8<Frac>>[src]

impl<Frac: LeEqU128> RemAssign<u128> for Wrapping<FixedU128<Frac>>[src]

impl<Frac: LeEqU16> RemAssign<u16> for Wrapping<FixedU16<Frac>>[src]

impl<Frac: LeEqU32> RemAssign<u32> for Wrapping<FixedU32<Frac>>[src]

impl<Frac: LeEqU64> RemAssign<u64> for Wrapping<FixedU64<Frac>>[src]

impl<Frac: LeEqU8> RemAssign<u8> for Wrapping<FixedU8<Frac>>[src]

impl<Frac: LeEqU8> Serialize for Wrapping<FixedI8<Frac>>[src]

impl<Frac: LeEqU16> Serialize for Wrapping<FixedI16<Frac>>[src]

impl<Frac: LeEqU32> Serialize for Wrapping<FixedI32<Frac>>[src]

impl<Frac: LeEqU64> Serialize for Wrapping<FixedI64<Frac>>[src]

impl<Frac: LeEqU128> Serialize for Wrapping<FixedI128<Frac>>[src]

impl<Frac: LeEqU8> Serialize for Wrapping<FixedU8<Frac>>[src]

impl<Frac: LeEqU16> Serialize for Wrapping<FixedU16<Frac>>[src]

impl<Frac: LeEqU32> Serialize for Wrapping<FixedU32<Frac>>[src]

impl<Frac: LeEqU64> Serialize for Wrapping<FixedU64<Frac>>[src]

impl<Frac: LeEqU128> Serialize for Wrapping<FixedU128<Frac>>[src]

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<F> ShlAssign<u32> for Wrapping<F> where
    F: ShlAssign<u32>, 
[src]

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

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

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

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<F> ShrAssign<u32> for Wrapping<F> where
    F: ShrAssign<u32>, 
[src]

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

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

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

impl<F> StructuralEq for Wrapping<F>[src]

impl<F> StructuralPartialEq for Wrapping<F>[src]

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

type Output = Wrapping<F>

The resulting type after applying the - operator.

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

type Output = Wrapping<F>

The resulting type after applying the - operator.

impl<F: Fixed> Sub<Wrapping<F>> for Wrapping<F>[src]

type Output = Wrapping<F>

The resulting type after applying the - operator.

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

type Output = Wrapping<F>

The resulting type after applying the - operator.

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

impl<F: Fixed> SubAssign<Wrapping<F>> for Wrapping<F>[src]

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

impl<F: Fixed> Sum<Wrapping<F>> for Wrapping<F>[src]

Auto Trait Implementations

impl<F> RefUnwindSafe for Wrapping<F> where
    F: RefUnwindSafe

impl<F> Send for Wrapping<F> where
    F: Send

impl<F> Sync for Wrapping<F> where
    F: Sync

impl<F> Unpin for Wrapping<F> where
    F: Unpin

impl<F> UnwindSafe for Wrapping<F> where
    F: UnwindSafe

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized
[src]

impl<T> Az for T[src]

impl<T> Borrow<T> for T where
    T: ?Sized
[src]

impl<T> BorrowMut<T> for T where
    T: ?Sized
[src]

impl<T> CheckedAs for T[src]

impl<T> DeserializeOwned for T where
    T: for<'de> Deserialize<'de>, 
[src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, 
[src]

impl<Src, Dst> LosslessTryInto<Dst> for Src where
    Dst: LosslessTryFrom<Src>, 
[src]

impl<Src, Dst> LossyInto<Dst> for Src where
    Dst: LossyFrom<Src>, 
[src]

impl<T> OverflowingAs for T[src]

impl<T> Same<T> for T[src]

type Output = T

Should always be Self

impl<T> SaturatingAs for T[src]

impl<T> StaticAs for T[src]

impl<T> ToOwned for T where
    T: Clone
[src]

type Owned = T

The resulting type after obtaining ownership.

impl<T> ToString for T where
    T: Display + ?Sized
[src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, 
[src]

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, 
[src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

impl<T> WrappingAs for T[src]