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::DELTA);
assert_eq!(I16F16::MIN, (max + delta).0);

Implementations

impl<F: Fixed> Wrapping<F>

pub const ZERO: Wrapping<F>

Zero.

See also FixedI32::ZERO and FixedU32::ZERO.

Examples

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

pub const DELTA: Wrapping<F>

The difference between any two successive representable numbers, Δ.

See also FixedI32::DELTA and FixedU32::DELTA.

Examples

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

pub const MIN: Wrapping<F>

The smallest value that can be represented.

See also FixedI32::MIN and FixedU32::MIN.

Examples

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

pub const MAX: Wrapping<F>

The largest value that can be represented.

See also FixedI32::MAX and FixedU32::MAX.

Examples

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

pub const IS_SIGNED: bool

true if the type is signed.

See also FixedI32::IS_SIGNED and FixedU32::IS_SIGNED.

Examples

use fixed::{
    types::{I16F16, U16F16},
    Wrapping,
};
assert!(Wrapping::<I16F16>::IS_SIGNED);
assert!(!Wrapping::<U16F16>::IS_SIGNED);

pub const INT_NBITS: u32

The number of integer bits.

See also FixedI32::INT_NBITS and FixedU32::INT_NBITS.

Examples

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

pub const FRAC_NBITS: u32

The number of fractional bits.

See also FixedI32::FRAC_NBITS and FixedU32::FRAC_NBITS.

Examples

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

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

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

See also FixedI32::from_bits and FixedU32::from_bits.

Examples

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

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

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

See also FixedI32::to_bits and FixedU32::to_bits.

Examples

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

pub fn from_be(w: Self) -> Self

Converts a fixed-point number from big endian to the target’s endianness.

See also FixedI32::from_be and FixedU32::from_be.

Examples

use fixed::{types::I16F16, Wrapping};
let w = Wrapping(I16F16::from_bits(0x1234_5678));
if cfg!(target_endian = "big") {
    assert_eq!(Wrapping::from_be(w), w);
} else {
    assert_eq!(Wrapping::from_be(w), w.swap_bytes());
}

pub fn from_le(w: Self) -> Self

Converts a fixed-point number from little endian to the target’s endianness.

See also FixedI32::from_le and FixedU32::from_le.

Examples

use fixed::{types::I16F16, Wrapping};
let w = Wrapping(I16F16::from_bits(0x1234_5678));
if cfg!(target_endian = "little") {
    assert_eq!(Wrapping::from_le(w), w);
} else {
    assert_eq!(Wrapping::from_le(w), w.swap_bytes());
}

pub fn to_be(self) -> Self

Converts self to big endian from the target’s endianness.

See also FixedI32::to_be and FixedU32::to_be.

Examples

use fixed::{types::I16F16, Wrapping};
let w = Wrapping(I16F16::from_bits(0x1234_5678));
if cfg!(target_endian = "big") {
    assert_eq!(w.to_be(), w);
} else {
    assert_eq!(w.to_be(), w.swap_bytes());
}

pub fn to_le(self) -> Self

Converts self to little endian from the target’s endianness.

See also FixedI32::to_le and FixedU32::to_le.

Examples

use fixed::{types::I16F16, Wrapping};
let w = Wrapping(I16F16::from_bits(0x1234_5678));
if cfg!(target_endian = "little") {
    assert_eq!(w.to_le(), w);
} else {
    assert_eq!(w.to_le(), w.swap_bytes());
}

pub fn swap_bytes(self) -> Self

Reverses the byte order of the fixed-point number.

See also FixedI32::swap_bytes and FixedU32::swap_bytes.

Examples

use fixed::{types::I16F16, Wrapping};
let w = Wrapping(I16F16::from_bits(0x1234_5678));
let swapped = Wrapping(I16F16::from_bits(0x7856_3412));
assert_eq!(w.swap_bytes(), swapped);

pub fn from_be_bytes(bytes: F::Bytes) -> Self

Creates a fixed-point number from its representation as a byte array in big endian.

See also FixedI32::from_be_bytes and FixedU32::from_be_bytes.

Examples

use fixed::{types::I16F16, Wrapping};
let bytes = [0x12, 0x34, 0x56, 0x78];
assert_eq!(
    Wrapping::<I16F16>::from_be_bytes(bytes),
    Wrapping::<I16F16>::from_bits(0x1234_5678)
);

pub fn from_le_bytes(bytes: F::Bytes) -> Self

Creates a fixed-point number from its representation as a byte array in little endian.

See also FixedI32::from_le_bytes and FixedU32::from_le_bytes.

Examples

use fixed::{types::I16F16, Wrapping};
let bytes = [0x78, 0x56, 0x34, 0x12];
assert_eq!(
    Wrapping::<I16F16>::from_le_bytes(bytes),
    Wrapping::<I16F16>::from_bits(0x1234_5678)
);

pub fn from_ne_bytes(bytes: F::Bytes) -> Self

Creates a fixed-point number from its representation as a byte array in native endian.

See also FixedI32::from_ne_bytes and FixedU32::from_ne_bytes.

Examples

use fixed::{types::I16F16, Wrapping};
let bytes = if cfg!(target_endian = "big") {
    [0x12, 0x34, 0x56, 0x78]
} else {
    [0x78, 0x56, 0x34, 0x12]
};
assert_eq!(
    Wrapping::<I16F16>::from_ne_bytes(bytes),
    Wrapping::<I16F16>::from_bits(0x1234_5678)
);

pub fn to_be_bytes(self) -> F::Bytes

Returns the memory representation of this fixed-point number as a byte array in big-endian byte order.

See also FixedI32::to_be_bytes and FixedU32::to_be_bytes.

Examples

use fixed::{types::I16F16, Wrapping};
assert_eq!(
    Wrapping::<I16F16>::from_bits(0x1234_5678).to_be_bytes(),
    [0x12, 0x34, 0x56, 0x78]
);

pub fn to_le_bytes(self) -> F::Bytes

Returns the memory representation of this fixed-point number as a byte array in little-endian byte order.

See also FixedI32::to_le_bytes and FixedU32::to_le_bytes.

Examples

use fixed::{types::I16F16, Wrapping};
assert_eq!(
    Wrapping::<I16F16>::from_bits(0x1234_5678).to_le_bytes(),
    [0x78, 0x56, 0x34, 0x12]
);

pub fn to_ne_bytes(self) -> F::Bytes

Returns the memory representation of this fixed-point number as a byte array in native-endian byte order.

See also FixedI32::to_ne_bytes and FixedU32::to_ne_bytes.

Examples

use fixed::{types::I16F16, Wrapping};
let bytes = if cfg!(target_endian = "big") {
    [0x12, 0x34, 0x56, 0x78]
} else {
    [0x78, 0x56, 0x34, 0x12]
};
assert_eq!(
    Wrapping::<I16F16>::from_bits(0x1234_5678).to_ne_bytes(),
    bytes
);

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 discarded, which rounds towards −∞.
• An integer of type i8, i16, i32, i64, i128, isize, u8, u16, u32, u64, u128, or usize.
• A floating-point number of type f16, bf16, f32, f64 or F128Bits. 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()).

See also FixedI32::from_num and FixedU32::from_num.

Panics

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

Examples

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

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

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

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

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

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

The other number can be:

• Another fixed-point number. Any extra fractional bits are 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 f16, bf16, f32, f64 or F128Bits. 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).

See also FixedI32::to_num and FixedU32::to_num.

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>

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

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

See also FixedI32::from_str_binary and FixedU32::from_str_binary.

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>

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

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

See also FixedI32::from_str_octal and FixedU32::from_str_octal.

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>

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

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

See also FixedI32::from_str_hex and FixedU32::from_str_hex.

Examples

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

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

Returns the integer part.

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

See also FixedI32::int and FixedU32::int.

Examples

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

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

Returns the fractional part.

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

See also FixedI32::frac and FixedU32::frac.

Examples

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

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

Rounds to the next integer towards 0.

See also FixedI32::round_to_zero and FixedU32::round_to_zero.

Examples

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

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

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

See also FixedI32::ceil and FixedU32::ceil.

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>

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

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

See also FixedI32::floor and FixedU32::floor.

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::ZERO));

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.

See also FixedI32::round and FixedU32::round.

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>

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

See also FixedI32::round_ties_to_even and FixedU32::round_ties_to_even.

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

Returns the number of ones in the binary representation.

See also FixedI32::count_ones and FixedU32::count_ones.

Examples

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

pub fn count_zeros(self) -> u32

Returns the number of zeros in the binary representation.

See also FixedI32::count_zeros and FixedU32::count_zeros.

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

Returns the number of leading ones in the binary representation.

See also FixedI32::leading_ones and FixedU32::leading_ones.

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

Returns the number of leading zeros in the binary representation.

See also FixedI32::leading_zeros and FixedU32::leading_zeros.

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

Returns the number of trailing ones in the binary representation.

See also FixedI32::trailing_ones and FixedU32::trailing_ones.

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

Returns the number of trailing zeros in the binary representation.

See also FixedI32::trailing_zeros and FixedU32::trailing_zeros.

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

Integer base-2 logarithm, rounded down.

See also FixedI32::int_log2 and FixedU32::int_log2.

Panics

Panics if the fixed-point number is ≤ 0.

pub fn int_log10(self) -> i32

Integer base-10 logarithm, rounded down.

See also FixedI32::int_log10 and FixedU32::int_log10.

Panics

Panics if the fixed-point number is ≤ 0.

#[must_use = "this returns the result of the operation, without modifying the original"]

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

Reverses the order of the bits of the fixed-point number.

See also FixedI32::reverse_bits and FixedU32::reverse_bits.

Examples

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

#[must_use = "this returns the result of the operation, without modifying the original"]

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

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

See also FixedI32::rotate_left and FixedU32::rotate_left.

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

#[must_use = "this returns the result of the operation, without modifying the original"]

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

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

See also FixedI32::rotate_right and FixedU32::rotate_right.

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

#[must_use = "this returns the result of the operation, without modifying the original"]

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

Returns the mean of self and other.

See also FixedI32::mean and FixedU32::mean.

Examples

use fixed::{types::I16F16, Wrapping};
let three = Wrapping(I16F16::from_num(3));
let four = Wrapping(I16F16::from_num(4));
assert_eq!(three.mean(four), Wrapping(I16F16::from_num(3.5)));
assert_eq!(three.mean(-four), Wrapping(I16F16::from_num(-0.5)));

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

Returns the reciprocal (inverse), 1/self.

See also FixedI32::recip and FixedU32::recip.

Panics

Panics if self is zero.

Examples

use fixed::{types::I8F24, Wrapping};
let quarter = Wrapping(I8F24::from_num(0.25));
let frac_1_512 = Wrapping(I8F24::ONE / 512);
assert_eq!(quarter.recip(), Wrapping(I8F24::from_num(4)));
assert_eq!(frac_1_512.recip(), Wrapping(I8F24::ZERO));

#[must_use = "this returns the result of the operation, without modifying the original"]

pub fn mul_add(self, mul: Wrapping<F>, add: Wrapping<F>) -> Wrapping<F>

Multiply and add. Returns self × mul + add.

See also FixedI32::mul_add and FixedU32::mul_add.

Examples

use fixed::{types::I16F16, Wrapping};
let half = Wrapping(I16F16::from_num(0.5));
let three = Wrapping(I16F16::from_num(3));
let four = Wrapping(I16F16::from_num(4));
let max = Wrapping(I16F16::MAX);
assert_eq!(three.mul_add(half, four), Wrapping(I16F16::from_num(5.5)));
assert_eq!(max.mul_add(three, max), Wrapping(I16F16::from_bits(!0 << 2)));

pub fn mul_acc(&mut self, a: Wrapping<F>, b: Wrapping<F>)

Multiply and accumulate. Adds (a × b) to self.

See also FixedI32::mul_acc and FixedU32::mul_acc.

Examples

use fixed::{types::I16F16, Wrapping};
let mut acc = Wrapping(I16F16::from_num(3));
acc.mul_acc(Wrapping(I16F16::from_num(4)), Wrapping(I16F16::from_num(0.5)));
assert_eq!(acc, Wrapping(I16F16::from_num(5)));

acc = Wrapping(I16F16::MAX);
acc.mul_acc(Wrapping(I16F16::MAX), Wrapping(I16F16::from_num(3)));
assert_eq!(acc, Wrapping(I16F16::MAX) * 4);

#[must_use = "this returns the result of the operation, without modifying the original"]

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

Euclidean division.

See also FixedI32::div_euclid and FixedU32::div_euclid.

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(I16F16::MAX) * 4i32).round_to_zero();
assert_eq!(Wrapping(I16F16::MAX).div_euclid(quarter), check);

#[must_use = "this returns the result of the operation, without modifying the original"]

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

Remainder for Euclidean division.

See also FixedI32::rem_euclid and FixedU32::rem_euclid.

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

#[must_use = "this returns the result of the operation, without modifying the original"]

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

Euclidean division by an integer.

See also FixedI32::div_euclid_int and FixedU32::div_euclid_int.

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

#[must_use = "this returns the result of the operation, without modifying the original"]

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

Remainder for Euclidean division.

See also FixedI32::rem_euclid_int and FixedU32::rem_euclid_int.

Panics

Panics if the divisor is zero.

Examples

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

impl<F: FixedSigned> Wrapping<F>

pub fn signed_bits(self) -> u32

Returns the number of bits required to represent the value.

The number of bits required includes an initial one for negative numbers, and an initial zero for non-negative numbers.

See also FixedI32::signed_bits.

Examples

use fixed::{types::I4F4, Wrapping};
assert_eq!(Wrapping(I4F4::from_num(-3)).signed_bits(), 7);      // “_101.0000”
assert_eq!(Wrapping(I4F4::from_num(-1)).signed_bits(), 5);      // “___1.0000”
assert_eq!(Wrapping(I4F4::from_num(-0.0625)).signed_bits(), 1); // “____.___1”
assert_eq!(Wrapping(I4F4::from_num(0)).signed_bits(), 1);       // “____.___0”
assert_eq!(Wrapping(I4F4::from_num(0.0625)).signed_bits(), 2);  // “____.__01”
assert_eq!(Wrapping(I4F4::from_num(1)).signed_bits(), 6);       // “__01.0000”
assert_eq!(Wrapping(I4F4::from_num(3)).signed_bits(), 7);       // “_011.0000”

pub fn is_positive(self) -> bool

Returns true if the number is > 0.

See also FixedI32::is_positive.

Examples

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

pub fn is_negative(self) -> bool

Returns true if the number is < 0.

See also FixedI32::is_negative.

Examples

use fixed::{types::I16F16, Wrapping};
assert!(!Wrapping(I16F16::from_num(4.3)).is_negative());
assert!(!Wrapping(I16F16::ZERO).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.

See also FixedI32::abs.

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>

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.

See also FixedI32::signum.

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>::ZERO).signum(), Wrapping(I16F16::ZERO));
assert_eq!(Wrapping(<I16F16>::from_num(3.9)).signum(), Wrapping(I16F16::ONE));

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::ZERO));
assert_eq!(Wrapping(<I0F32>::from_num(-0.5)).signum(), Wrapping(I0F32::ZERO));

impl<F: FixedUnsigned> Wrapping<F>

pub fn significant_bits(self) -> u32

Returns the number of bits required to represent the value.

See also FixedU32::significant_bits.

Examples

use fixed::{types::U4F4, Wrapping};
assert_eq!(Wrapping(U4F4::from_num(0)).significant_bits(), 0);      // “____.____”
assert_eq!(Wrapping(U4F4::from_num(0.0625)).significant_bits(), 1); // “____.___1”
assert_eq!(Wrapping(U4F4::from_num(1)).significant_bits(), 5);      // “___1.0000”
assert_eq!(Wrapping(U4F4::from_num(3)).significant_bits(), 6);      // “__11.0000”

pub fn is_power_of_two(self) -> bool

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

See also FixedU32::is_power_of_two.

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 highest_one(self) -> Wrapping<F>

Returns the highest one in the binary representation, or zero if self is zero.

If self > 0, the highest one is equal to the largest power of two that is ≤ self.

See also FixedU32::highest_one.

Examples

use fixed::{types::U16F16, Wrapping};
type T = Wrapping<U16F16>;
assert_eq!(T::from_bits(0b11_0010).highest_one(), T::from_bits(0b10_0000));
assert_eq!(T::from_num(0.3).highest_one(), T::from_num(0.25));
assert_eq!(T::from_num(4).highest_one(), T::from_num(4));
assert_eq!(T::from_num(6.5).highest_one(), T::from_num(4));
assert_eq!(T::ZERO.highest_one(), T::ZERO);

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.

See also FixedU32::next_power_of_two.

Examples

use fixed::{types::U16F16, Wrapping};
type T = Wrapping<U16F16>;
assert_eq!(T::from_bits(0b11_0010).next_power_of_two(), T::from_bits(0b100_0000));
assert_eq!(T::from_num(0.3).next_power_of_two(), T::from_num(0.5));
assert_eq!(T::from_num(4).next_power_of_two(), T::from_num(4));
assert_eq!(T::from_num(6.5).next_power_of_two(), T::from_num(8));
// if the next power of two is too large, it is wrapped to zero
assert_eq!(T::MAX.next_power_of_two(), T::ZERO);

Trait Implementations

impl<F: Fixed> Add<&'_ Wrapping<F>> for Wrapping<F>

type Output = Wrapping<F>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<F: Fixed> Add<&'_ Wrapping<F>> for &Wrapping<F>

type Output = Wrapping<F>

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = Wrapping<F>

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = Wrapping<F>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<F: Fixed> AddAssign<&'_ Wrapping<F>> for Wrapping<F>

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

Performs the += operation.

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

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

Performs the += operation.

impl<F> BitAnd<&'_ 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: &Wrapping<F>) -> Wrapping<F>

Performs the & operation.

impl<F> BitAnd<&'_ Wrapping<F>> for &Wrapping<F> where
    &'a F: BitAnd<&'b 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<Wrapping<F>> for Wrapping<F> where
    F: BitAnd<F, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the & operator.

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

Performs the & operation.

impl<F> BitAnd<Wrapping<F>> for &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> BitAndAssign<&'_ Wrapping<F>> for Wrapping<F> where
    F: BitAndAssign<&'a F>, 

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

Performs the &= operation.

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

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

Performs the &= operation.

impl<F> BitOr<&'_ 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: &Wrapping<F>) -> Wrapping<F>

Performs the | operation.

impl<F> BitOr<&'_ Wrapping<F>> for &Wrapping<F> where
    &'a F: BitOr<&'b 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<Wrapping<F>> for Wrapping<F> where
    F: BitOr<F, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the | operator.

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

Performs the | operation.

impl<F> BitOr<Wrapping<F>> for &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> BitOrAssign<&'_ Wrapping<F>> for Wrapping<F> where
    F: BitOrAssign<&'a F>, 

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

Performs the |= operation.

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

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

Performs the |= operation.

impl<F> BitXor<&'_ 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: &Wrapping<F>) -> Wrapping<F>

Performs the ^ operation.

impl<F> BitXor<&'_ Wrapping<F>> for &Wrapping<F> where
    &'a F: BitXor<&'b 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<Wrapping<F>> for Wrapping<F> where
    F: BitXor<F, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<F> BitXor<Wrapping<F>> for &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> BitXorAssign<&'_ Wrapping<F>> for Wrapping<F> where
    F: BitXorAssign<&'a F>, 

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

Performs the ^= operation.

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

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

Performs the ^= operation.

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

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

Returns a copy of the value.

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

Performs copy-assignment from source.

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

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

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

Formats the value using the given formatter.

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

fn default() -> Wrapping<F>

Returns the “default value” for a type.

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

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

Deserialize this value from the given Serde deserializer.

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

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

Deserialize this value from the given Serde deserializer.

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

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

Deserialize this value from the given Serde deserializer.

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

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

Deserialize this value from the given Serde deserializer.

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

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

Deserialize this value from the given Serde deserializer.

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

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

Deserialize this value from the given Serde deserializer.

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

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

Deserialize this value from the given Serde deserializer.

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

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

Deserialize this value from the given Serde deserializer.

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

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

Deserialize this value from the given Serde deserializer.

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

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

Deserialize this value from the given Serde deserializer.

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

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

Formats the value using the given formatter.

impl<F: Fixed> Div<&'_ Wrapping<F>> for Wrapping<F>

type Output = Wrapping<F>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<F: Fixed> Div<&'_ Wrapping<F>> for &Wrapping<F>

type Output = Wrapping<F>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<F: Fixed> Div<Wrapping<F>> for &Wrapping<F>

type Output = Wrapping<F>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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> DivAssign<&'_ Wrapping<F>> for Wrapping<F>

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

Performs the /= operation.

impl<Frac> DivAssign<&'_ i128> for Wrapping<FixedI128<Frac>>

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

Performs the /= operation.

impl<Frac> DivAssign<&'_ i16> for Wrapping<FixedI16<Frac>>

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

Performs the /= operation.

impl<Frac> DivAssign<&'_ i32> for Wrapping<FixedI32<Frac>>

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

Performs the /= operation.

impl<Frac> DivAssign<&'_ i64> for Wrapping<FixedI64<Frac>>

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

Performs the /= operation.

impl<Frac> DivAssign<&'_ i8> for Wrapping<FixedI8<Frac>>

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

Performs the /= operation.

impl<Frac> DivAssign<&'_ u128> for Wrapping<FixedU128<Frac>>

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

Performs the /= operation.

impl<Frac> DivAssign<&'_ u16> for Wrapping<FixedU16<Frac>>

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

Performs the /= operation.

impl<Frac> DivAssign<&'_ u32> for Wrapping<FixedU32<Frac>>

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

Performs the /= operation.

impl<Frac> DivAssign<&'_ u64> for Wrapping<FixedU64<Frac>>

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

Performs the /= operation.

impl<Frac> DivAssign<&'_ u8> for Wrapping<FixedU8<Frac>>

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

Performs the /= operation.

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

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

Performs the /= operation.

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

fn div_assign(&mut self, other: i128)

Performs the /= operation.

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

fn div_assign(&mut self, other: i16)

Performs the /= operation.

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

fn div_assign(&mut self, other: i32)

Performs the /= operation.

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

fn div_assign(&mut self, other: i64)

Performs the /= operation.

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

fn div_assign(&mut self, other: i8)

Performs the /= operation.

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

fn div_assign(&mut self, other: u128)

Performs the /= operation.

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

fn div_assign(&mut self, other: u16)

Performs the /= operation.

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

fn div_assign(&mut self, other: u32)

Performs the /= operation.

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

fn div_assign(&mut self, other: u64)

Performs the /= operation.

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

fn div_assign(&mut self, other: u8)

Performs the /= operation.

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

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

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

Wraps a fixed-point number.

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

type Err = ParseFixedError

The associated error which can be returned from parsing.

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

Parses a string 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>

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

Feeds this value into the given Hasher.

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

Feeds a slice of this type into the given Hasher.

impl<F: Fixed> Mul<&'_ Wrapping<F>> for Wrapping<F>

type Output = Wrapping<F>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<F: Fixed> Mul<&'_ Wrapping<F>> for &Wrapping<F>

type Output = Wrapping<F>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<F: Fixed> Mul<Wrapping<F>> for &Wrapping<F>

type Output = Wrapping<F>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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> MulAssign<&'_ Wrapping<F>> for Wrapping<F>

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

Performs the *= operation.

impl<Frac> MulAssign<&'_ i128> for Wrapping<FixedI128<Frac>>

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

Performs the *= operation.

impl<Frac> MulAssign<&'_ i16> for Wrapping<FixedI16<Frac>>

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

Performs the *= operation.

impl<Frac> MulAssign<&'_ i32> for Wrapping<FixedI32<Frac>>

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

Performs the *= operation.

impl<Frac> MulAssign<&'_ i64> for Wrapping<FixedI64<Frac>>

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

Performs the *= operation.

impl<Frac> MulAssign<&'_ i8> for Wrapping<FixedI8<Frac>>

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

Performs the *= operation.

impl<Frac> MulAssign<&'_ u128> for Wrapping<FixedU128<Frac>>

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

Performs the *= operation.

impl<Frac> MulAssign<&'_ u16> for Wrapping<FixedU16<Frac>>

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

Performs the *= operation.

impl<Frac> MulAssign<&'_ u32> for Wrapping<FixedU32<Frac>>

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

Performs the *= operation.

impl<Frac> MulAssign<&'_ u64> for Wrapping<FixedU64<Frac>>

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

Performs the *= operation.

impl<Frac> MulAssign<&'_ u8> for Wrapping<FixedU8<Frac>>

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

Performs the *= operation.

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

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

Performs the *= operation.

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

fn mul_assign(&mut self, other: i128)

Performs the *= operation.

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

fn mul_assign(&mut self, other: i16)

Performs the *= operation.

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

fn mul_assign(&mut self, other: i32)

Performs the *= operation.

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

fn mul_assign(&mut self, other: i64)

Performs the *= operation.

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

fn mul_assign(&mut self, other: i8)

Performs the *= operation.

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

fn mul_assign(&mut self, other: u128)

Performs the *= operation.

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

fn mul_assign(&mut self, other: u16)

Performs the *= operation.

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

fn mul_assign(&mut self, other: u32)

Performs the *= operation.

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

fn mul_assign(&mut self, other: u64)

Performs the *= operation.

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

fn mul_assign(&mut self, other: u8)

Performs the *= operation.

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

type Output = Wrapping<F>

The resulting type after applying the - operator.

fn neg(self) -> Wrapping<F>

Performs the unary - operation.

impl<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<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> Not for &Wrapping<F> where
    &'a F: Not<Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the ! operator.

fn not(self) -> Wrapping<F>

Performs the unary ! operation.

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

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

This method returns an Ordering between self and other.

#[must_use]

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

Compares and returns the maximum of two values.

#[must_use]

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

Compares and returns the minimum of two values.

#[must_use]

pub fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to a certain interval.

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

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

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

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

This method tests for !=.

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

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

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

#[must_use]

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

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

#[must_use]

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

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

#[must_use]

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

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

#[must_use]

pub 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<Wrapping<F>> for Wrapping<F>

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

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

impl<F: Fixed> Rem<&'_ Wrapping<F>> for Wrapping<F>

type Output = Wrapping<F>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<F: Fixed> Rem<&'_ Wrapping<F>> for &Wrapping<F>

type Output = Wrapping<F>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<F: Fixed> Rem<Wrapping<F>> for &Wrapping<F>

type Output = Wrapping<F>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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> RemAssign<&'_ Wrapping<F>> for Wrapping<F>

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

Performs the %= operation.

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

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

Performs the %= operation.

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

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

Performs the %= operation.

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

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

Performs the %= operation.

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

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

Performs the %= operation.

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

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

Performs the %= operation.

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

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

Performs the %= operation.

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

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

Performs the %= operation.

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

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

Performs the %= operation.

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

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

Performs the %= operation.

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

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

Performs the %= operation.

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

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

Performs the %= operation.

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

fn rem_assign(&mut self, other: i128)

Performs the %= operation.

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

fn rem_assign(&mut self, other: i16)

Performs the %= operation.

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

fn rem_assign(&mut self, other: i32)

Performs the %= operation.

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

fn rem_assign(&mut self, other: i64)

Performs the %= operation.

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

fn rem_assign(&mut self, other: i8)

Performs the %= operation.

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

fn rem_assign(&mut self, other: u128)

Performs the %= operation.

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

fn rem_assign(&mut self, other: u16)

Performs the %= operation.

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

fn rem_assign(&mut self, other: u32)

Performs the %= operation.

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

fn rem_assign(&mut self, other: u64)

Performs the %= operation.

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

fn rem_assign(&mut self, other: u8)

Performs the %= operation.

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

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

Serialize this value into the given Serde serializer.

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

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

Serialize this value into the given Serde serializer.

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

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

Serialize this value into the given Serde serializer.

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

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

Serialize this value into the given Serde serializer.

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

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

Serialize this value into the given Serde serializer.

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

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

Serialize this value into the given Serde serializer.

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

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

Serialize this value into the given Serde serializer.

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

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

Serialize this value into the given Serde serializer.

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

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

Serialize this value into the given Serde serializer.

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

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

Serialize this value into the given Serde serializer.

impl<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<F> Shl<&'_ i128> for &Wrapping<F> where
    &'a F: Shl<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

Performs the << operation.

impl<F> Shl<&'_ usize> for &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<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<F> Shl<i128> for &Wrapping<F> where
    &'a F: Shl<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

Performs the << operation.

impl<F> Shl<usize> for &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> 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<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<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<F> Shr<&'_ i128> for &Wrapping<F> where
    &'a F: Shr<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl<F> Shr<&'_ usize> for &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<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<F> Shr<i128> for &Wrapping<F> where
    &'a F: Shr<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl<F> Shr<usize> for &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> ShrAssign<&'_ i128> for Wrapping<F> where
    F: ShrAssign<u32>, 

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

Performs the >>= operation.

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

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

Performs the >>= operation.

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

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

Performs the >>= operation.

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

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

Performs the >>= operation.

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

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

Performs the >>= operation.

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

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

Performs the >>= operation.

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

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

Performs the >>= operation.

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

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

Performs the >>= operation.

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

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

Performs the >>= operation.

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

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

Performs the >>= operation.

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

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

Performs the >>= operation.

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

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

Performs the >>= operation.

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

fn shr_assign(&mut self, other: i128)

Performs the >>= operation.

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

fn shr_assign(&mut self, other: i16)

Performs the >>= operation.

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

fn shr_assign(&mut self, other: i32)

Performs the >>= operation.

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

fn shr_assign(&mut self, other: i64)

Performs the >>= operation.

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

fn shr_assign(&mut self, other: i8)

Performs the >>= operation.

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

fn shr_assign(&mut self, other: isize)

Performs the >>= operation.

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

fn shr_assign(&mut self, other: u128)

Performs the >>= operation.

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

fn shr_assign(&mut self, other: u16)

Performs the >>= operation.

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

fn shr_assign(&mut self, other: u32)

Performs the >>= operation.

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

fn shr_assign(&mut self, other: u64)

Performs the >>= operation.

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

fn shr_assign(&mut self, other: u8)

Performs the >>= operation.

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

fn shr_assign(&mut self, other: usize)

Performs the >>= operation.

impl<F> StructuralEq for Wrapping<F>

impl<F> StructuralPartialEq for Wrapping<F>

impl<F: Fixed> Sub<&'_ Wrapping<F>> for Wrapping<F>

type Output = Wrapping<F>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<F: Fixed> Sub<&'_ Wrapping<F>> for &Wrapping<F>

type Output = Wrapping<F>

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = Wrapping<F>

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = Wrapping<F>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<F: Fixed> SubAssign<&'_ Wrapping<F>> for Wrapping<F>

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

Performs the -= operation.

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

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

Performs the -= operation.

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

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

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

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

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

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