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

#![feature(generic_const_exprs)]

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

Tuple Fields

0: F

Implementations

impl<F: Fixed> Wrapping<F>

pub const ZERO: Wrapping<F> = _

Zero.

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

Examples

#![feature(generic_const_exprs)]

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

#![feature(generic_const_exprs)]

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

#![feature(generic_const_exprs)]

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

#![feature(generic_const_exprs)]

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

pub const IS_SIGNED: bool = F::IS_SIGNED

true if the type is signed.

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

Examples

#![feature(generic_const_exprs)]

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

pub const INT_BITS: i32 = F::INT_BITS

The number of integer bits.

See also FixedI32::INT_BITS and FixedU32::INT_BITS.

Examples

#![feature(generic_const_exprs)]

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

pub const FRAC_BITS: i32 = F::FRAC_BITS

The number of fractional bits.

See also FixedI32::FRAC_BITS and FixedU32::FRAC_BITS.

Examples

#![feature(generic_const_exprs)]

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

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

#![feature(generic_const_exprs)]

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

#![feature(generic_const_exprs)]

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

#![feature(generic_const_exprs)]

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

#![feature(generic_const_exprs)]

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

#![feature(generic_const_exprs)]

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

#![feature(generic_const_exprs)]

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

#![feature(generic_const_exprs)]

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: [u8; { _ }]) -> 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

#![feature(generic_const_exprs)]

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: [u8; { _ }]) -> 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

#![feature(generic_const_exprs)]

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: [u8; { _ }]) -> 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

#![feature(generic_const_exprs)]

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) -> [u8; { _ }]

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

#![feature(generic_const_exprs)]

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) -> [u8; { _ }]

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

#![feature(generic_const_exprs)]

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) -> [u8; { _ }]

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

#![feature(generic_const_exprs)]

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 F128. 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::wrapping_from_num and FixedU32::wrapping_from_num.

Panics

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

Examples

#![feature(generic_const_exprs)]

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 F128. 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::wrapping_to_num and FixedU32::wrapping_to_num.

Examples

#![feature(generic_const_exprs)]

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

#![feature(generic_const_exprs)]

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

#![feature(generic_const_exprs)]

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

#![feature(generic_const_exprs)]

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::wrapping_ceil and FixedU32::wrapping_ceil.

Examples

#![feature(generic_const_exprs)]

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::wrapping_floor and FixedU32::wrapping_floor.

Examples

#![feature(generic_const_exprs)]

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::wrapping_round and FixedU32::wrapping_round.

Examples

#![feature(generic_const_exprs)]

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::wrapping_round_ties_to_even and FixedU32::wrapping_round_ties_to_even.

Examples

#![feature(generic_const_exprs)]

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

#![feature(generic_const_exprs)]

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

#![feature(generic_const_exprs)]

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

#![feature(generic_const_exprs)]

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

#![feature(generic_const_exprs)]

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

#![feature(generic_const_exprs)]

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

#![feature(generic_const_exprs)]

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

#![feature(generic_const_exprs)]

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

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

#![feature(generic_const_exprs)]

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

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

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

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

Examples

#![feature(generic_const_exprs)]

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

pub fn is_zero(self) -> bool

Returns true if the number is zero.

See also FixedI32::is_zero and FixedU32::is_zero.

Examples

#![feature(generic_const_exprs)]

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

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

Returns the distance from self to other.

See also FixedI32::wrapping_dist and FixedU32::wrapping_dist.

Examples

#![feature(generic_const_exprs)]

use fixed::{types::I16F16, Wrapping};
type Wr = Wrapping<I16F16>;
assert_eq!(Wr::from_num(-1).dist(Wr::from_num(4)), Wr::from_num(5));
assert_eq!(Wr::MIN.dist(Wr::MAX), -Wr::DELTA);

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

Returns the mean of self and other.

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

Examples

#![feature(generic_const_exprs)]

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 next_multiple_of(self, other: Wrapping<F>) -> Wrapping<F>

Returns the next multiple of other.

See also FixedI32::wrapping_next_multiple_of and FixedU32::wrapping_next_multiple_of.

Panics

Panics if other is zero.

Examples

#![feature(generic_const_exprs)]

use fixed::{types::I16F16, Wrapping};
let one_point_5 = Wrapping::<I16F16>::from_num(1.5);
let four = Wrapping::<I16F16>::from_num(4);
let four_point_5 = Wrapping::<I16F16>::from_num(4.5);
assert_eq!(four.next_multiple_of(one_point_5), four_point_5);

let max = Wrapping::<I16F16>::MAX;
let max_minus_delta = max - Wrapping::<I16F16>::DELTA;
assert_eq!(max.next_multiple_of(max_minus_delta), max_minus_delta * 2);

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

Multiply and add. Returns self × mul + add.

See also FixedI32::wrapping_mul_add and FixedU32::wrapping_mul_add.

Examples

#![feature(generic_const_exprs)]

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), max * 4);

pub fn add_prod(self, a: Wrapping<F>, b: Wrapping<F>) -> Wrapping<F>

Adds self to the product a × b.

See also FixedI32::wrapping_add_prod and FixedU32::wrapping_add_prod.

Examples

#![feature(generic_const_exprs)]

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!(four.add_prod(three, half), Wrapping(I16F16::from_num(5.5)));
assert_eq!(max.add_prod(max, three), max * 4);

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

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

See also FixedI32::wrapping_mul_acc and FixedU32::wrapping_mul_acc.

Examples

#![feature(generic_const_exprs)]

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

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

#![feature(generic_const_exprs)]

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

impl<F: FixedStrict> Wrapping<F>

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::wrapping_from_str_binary and FixedU32::wrapping_from_str_binary.

Examples

#![feature(generic_const_exprs)]

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::wrapping_from_str_octal and FixedU32::wrapping_from_str_octal.

Examples

#![feature(generic_const_exprs)]

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::wrapping_from_str_hex and FixedU32::wrapping_from_str_hex.

Examples

#![feature(generic_const_exprs)]

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

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

Returns the reciprocal (inverse), 1/self.

See also FixedI32::wrapping_recip and FixedU32::wrapping_recip.

Panics

Panics if self is zero.

Examples

#![feature(generic_const_exprs)]

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

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

Euclidean division.

See also FixedI32::wrapping_div_euclid and FixedU32::wrapping_div_euclid.

Panics

Panics if the divisor is zero.

Examples

#![feature(generic_const_exprs)]

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

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

Euclidean division by an integer.

See also FixedI32::wrapping_div_euclid_int and FixedU32::wrapping_div_euclid_int.

Panics

Panics if the divisor is zero.

Examples

#![feature(generic_const_exprs)]

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

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

Remainder for Euclidean division.

See also FixedI32::wrapping_rem_euclid_int and FixedU32::wrapping_rem_euclid_int.

Panics

Panics if the divisor is zero.

Examples

#![feature(generic_const_exprs)]

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

pub fn lerp(self, start: Wrapping<F>, end: Wrapping<F>) -> Wrapping<F>

Linear interpolation between start and end.

See also FixedI32::wrapping_lerp and FixedU32::wrapping_lerp.

Examples

#![feature(generic_const_exprs)]

use fixed::{types::I16F16, Wrapping};
type Wr = Wrapping<I16F16>;
assert_eq!(Wr::from_num(0.5).lerp(Wr::ZERO, Wr::MAX), Wr::MAX / 2);
assert_eq!(Wr::from_num(1.5).lerp(Wr::ZERO, Wr::MAX), Wr::MAX + Wr::MAX / 2);

pub fn inv_lerp(self, start: Wrapping<F>, end: Wrapping<F>) -> Wrapping<F>

Inverse linear interpolation between start and end.

See also FixedI32::wrapping_inv_lerp and FixedU32::wrapping_inv_lerp.

Examples

#![feature(generic_const_exprs)]

use fixed::{types::I16F16, Wrapping};
type Wr = Wrapping<I16F16>;
assert_eq!(
    Wr::from_num(25).inv_lerp(Wr::from_num(20), Wr::from_num(40)),
    Wr::from_num(0.25)
);

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

#![feature(generic_const_exprs)]

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

#![feature(generic_const_exprs)]

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

#![feature(generic_const_exprs)]

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::wrapping_abs.

Examples

#![feature(generic_const_exprs)]

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::wrapping_signum.

Examples

#![feature(generic_const_exprs)]

use fixed::{
    types::{I0F32, I1F31, I16F16},
    Wrapping,
};
assert_eq!(Wrapping(<I16F16>::from_num(-3.9)).signum(), Wrapping(I16F16::NEG_ONE));
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::NEG_ONE));
assert_eq!(Wrapping(<I0F32>::from_num(0.25)).signum(), Wrapping(I0F32::ZERO));
assert_eq!(Wrapping(<I0F32>::from_num(-0.5)).signum(), Wrapping(I0F32::ZERO));

pub fn add_unsigned(self, rhs: F::Unsigned) -> Wrapping<F>

Addition with an unsigned fixed-point number.

See also FixedI32::wrapping_add_unsigned.

Examples

#![feature(generic_const_exprs)]

use fixed::{
    types::{I16F16, U16F16},
    Wrapping,
};
assert_eq!(
    Wrapping::<I16F16>::from_num(-5).add_unsigned(U16F16::from_num(3)),
    Wrapping::<I16F16>::from_num(-2)
);
assert_eq!(
    Wrapping::<I16F16>::ZERO.add_unsigned(U16F16::MAX),
    -Wrapping::<I16F16>::DELTA
);

pub fn sub_unsigned(self, rhs: F::Unsigned) -> Wrapping<F>

Subtraction with an unsigned fixed-point number.

See also FixedI32::wrapping_sub_unsigned.

Examples

#![feature(generic_const_exprs)]

use fixed::{
    types::{I16F16, U16F16},
    Wrapping,
};
assert_eq!(
    Wrapping::<I16F16>::from_num(3).sub_unsigned(U16F16::from_num(5)),
    Wrapping::<I16F16>::from_num(-2)
);
assert_eq!(
    Wrapping::<I16F16>::ZERO.sub_unsigned(U16F16::MAX),
    Wrapping::<I16F16>::DELTA
);

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

#![feature(generic_const_exprs)]

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

#![feature(generic_const_exprs)]

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

#![feature(generic_const_exprs)]

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::wrapping_next_power_of_two.

Examples

#![feature(generic_const_exprs)]

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

pub fn add_signed(self, rhs: F::Signed) -> Wrapping<F>

Addition with an signed fixed-point number.

See also FixedU32::wrapping_add_signed.

Examples

#![feature(generic_const_exprs)]

use fixed::{
    types::{I16F16, U16F16},
    Wrapping,
};
assert_eq!(
    Wrapping::<U16F16>::from_num(5).add_signed(I16F16::from_num(-3)),
    Wrapping::<U16F16>::from_num(2)
);
assert_eq!(
    Wrapping::<U16F16>::ZERO.add_signed(-I16F16::DELTA),
    Wrapping::<U16F16>::MAX
);

pub fn sub_signed(self, rhs: F::Signed) -> Wrapping<F>

Subtraction with an signed fixed-point number.

See also FixedU32::wrapping_sub_signed.

Examples

#![feature(generic_const_exprs)]

use fixed::{
    types::{I16F16, U16F16},
    Wrapping,
};
assert_eq!(
    Wrapping::<U16F16>::from_num(5).sub_signed(I16F16::from_num(-3)),
    Wrapping::<U16F16>::from_num(8)
);
assert_eq!(
    Wrapping::<U16F16>::ZERO.sub_signed(I16F16::DELTA),
    Wrapping::<U16F16>::MAX
);

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

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

fn add_assign(&mut self, other: F)

Performs the += operation.

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

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

Performs the += operation.

impl<'a, const FRAC: i32> Arbitrary<'a> for Wrapping<FixedI128<FRAC>> where
    If<{ _ }>: True, 

fn arbitrary(u: &mut Unstructured<'a>) -> ArbitraryResult<Self>

Generate an arbitrary value of Self from the given unstructured data.

fn size_hint(depth: usize) -> (usize, Option<usize>)

Get a size hint for how many bytes out of an Unstructured this type needs to construct itself.

fn arbitrary_take_rest(u: Unstructured<'a>) -> Result<Self, Error>

Generate an arbitrary value of Self from the entirety of the given unstructured data.

impl<'a, const FRAC: i32> Arbitrary<'a> for Wrapping<FixedI16<FRAC>> where
    If<{ _ }>: True, 

fn arbitrary(u: &mut Unstructured<'a>) -> ArbitraryResult<Self>

Generate an arbitrary value of Self from the given unstructured data.

fn size_hint(depth: usize) -> (usize, Option<usize>)

Get a size hint for how many bytes out of an Unstructured this type needs to construct itself.

fn arbitrary_take_rest(u: Unstructured<'a>) -> Result<Self, Error>

Generate an arbitrary value of Self from the entirety of the given unstructured data.

impl<'a, const FRAC: i32> Arbitrary<'a> for Wrapping<FixedI32<FRAC>> where
    If<{ _ }>: True, 

fn arbitrary(u: &mut Unstructured<'a>) -> ArbitraryResult<Self>

Generate an arbitrary value of Self from the given unstructured data.

fn size_hint(depth: usize) -> (usize, Option<usize>)

Get a size hint for how many bytes out of an Unstructured this type needs to construct itself.

fn arbitrary_take_rest(u: Unstructured<'a>) -> Result<Self, Error>

Generate an arbitrary value of Self from the entirety of the given unstructured data.

impl<'a, const FRAC: i32> Arbitrary<'a> for Wrapping<FixedI64<FRAC>> where
    If<{ _ }>: True, 

fn arbitrary(u: &mut Unstructured<'a>) -> ArbitraryResult<Self>

Generate an arbitrary value of Self from the given unstructured data.

fn size_hint(depth: usize) -> (usize, Option<usize>)

Get a size hint for how many bytes out of an Unstructured this type needs to construct itself.

fn arbitrary_take_rest(u: Unstructured<'a>) -> Result<Self, Error>

Generate an arbitrary value of Self from the entirety of the given unstructured data.

impl<'a, const FRAC: i32> Arbitrary<'a> for Wrapping<FixedI8<FRAC>> where
    If<{ _ }>: True, 

fn arbitrary(u: &mut Unstructured<'a>) -> ArbitraryResult<Self>

Generate an arbitrary value of Self from the given unstructured data.

fn size_hint(depth: usize) -> (usize, Option<usize>)

Get a size hint for how many bytes out of an Unstructured this type needs to construct itself.

fn arbitrary_take_rest(u: Unstructured<'a>) -> Result<Self, Error>

Generate an arbitrary value of Self from the entirety of the given unstructured data.

impl<'a, const FRAC: i32> Arbitrary<'a> for Wrapping<FixedU128<FRAC>> where
    If<{ _ }>: True, 

fn arbitrary(u: &mut Unstructured<'a>) -> ArbitraryResult<Self>

Generate an arbitrary value of Self from the given unstructured data.

fn size_hint(depth: usize) -> (usize, Option<usize>)

Get a size hint for how many bytes out of an Unstructured this type needs to construct itself.

fn arbitrary_take_rest(u: Unstructured<'a>) -> Result<Self, Error>

Generate an arbitrary value of Self from the entirety of the given unstructured data.

impl<'a, const FRAC: i32> Arbitrary<'a> for Wrapping<FixedU16<FRAC>> where
    If<{ _ }>: True, 

fn arbitrary(u: &mut Unstructured<'a>) -> ArbitraryResult<Self>

Generate an arbitrary value of Self from the given unstructured data.

fn size_hint(depth: usize) -> (usize, Option<usize>)

Get a size hint for how many bytes out of an Unstructured this type needs to construct itself.

fn arbitrary_take_rest(u: Unstructured<'a>) -> Result<Self, Error>

Generate an arbitrary value of Self from the entirety of the given unstructured data.

impl<'a, const FRAC: i32> Arbitrary<'a> for Wrapping<FixedU32<FRAC>> where
    If<{ _ }>: True, 

fn arbitrary(u: &mut Unstructured<'a>) -> ArbitraryResult<Self>

Generate an arbitrary value of Self from the given unstructured data.

fn size_hint(depth: usize) -> (usize, Option<usize>)

Get a size hint for how many bytes out of an Unstructured this type needs to construct itself.

fn arbitrary_take_rest(u: Unstructured<'a>) -> Result<Self, Error>

Generate an arbitrary value of Self from the entirety of the given unstructured data.

impl<'a, const FRAC: i32> Arbitrary<'a> for Wrapping<FixedU64<FRAC>> where
    If<{ _ }>: True, 

fn arbitrary(u: &mut Unstructured<'a>) -> ArbitraryResult<Self>

Generate an arbitrary value of Self from the given unstructured data.

fn size_hint(depth: usize) -> (usize, Option<usize>)

Get a size hint for how many bytes out of an Unstructured this type needs to construct itself.

fn arbitrary_take_rest(u: Unstructured<'a>) -> Result<Self, Error>

Generate an arbitrary value of Self from the entirety of the given unstructured data.

impl<'a, const FRAC: i32> Arbitrary<'a> for Wrapping<FixedU8<FRAC>> where
    If<{ _ }>: True, 

fn arbitrary(u: &mut Unstructured<'a>) -> ArbitraryResult<Self>

Generate an arbitrary value of Self from the given unstructured data.

fn size_hint(depth: usize) -> (usize, Option<usize>)

Get a size hint for how many bytes out of an Unstructured this type needs to construct itself.

fn arbitrary_take_rest(u: Unstructured<'a>) -> Result<Self, Error>

Generate an arbitrary value of Self from the entirety of the given unstructured data.

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

type Output = Wrapping<F>

The resulting type after applying the & operator.

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

Performs the & operation.

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

fn bitand_assign(&mut self, other: &F)

Performs the &= operation.

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

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

Performs the &= operation.

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

fn bitand_assign(&mut self, other: 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
    for<'a, 'b> &'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
    for<'a> 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
    for<'a> &'a F: BitOr<F, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the | operator.

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

Performs the | operation.

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

fn bitor_assign(&mut self, other: &F)

Performs the |= operation.

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

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

Performs the |= operation.

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

fn bitor_assign(&mut self, other: 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
    for<'a, 'b> &'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
    for<'a> 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
    for<'a> &'a F: BitXor<F, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

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

fn bitxor_assign(&mut self, other: &F)

Performs the ^= operation.

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

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

Performs the ^= operation.

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

fn bitxor_assign(&mut self, other: F)

Performs the ^= operation.

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

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

Performs the ^= operation.

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

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

Returns a copy of the value.

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

Performs copy-assignment from source.

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

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

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, const FRAC: i32> Deserialize<'de> for Wrapping<FixedI128<FRAC>> where
    If<{ _ }>: True, 

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

Deserialize this value from the given Serde deserializer.

impl<'de, const FRAC: i32> Deserialize<'de> for Wrapping<FixedI16<FRAC>> where
    If<{ _ }>: True, 

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

Deserialize this value from the given Serde deserializer.

impl<'de, const FRAC: i32> Deserialize<'de> for Wrapping<FixedI32<FRAC>> where
    If<{ _ }>: True, 

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

Deserialize this value from the given Serde deserializer.

impl<'de, const FRAC: i32> Deserialize<'de> for Wrapping<FixedI64<FRAC>> where
    If<{ _ }>: True, 

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

Deserialize this value from the given Serde deserializer.

impl<'de, const FRAC: i32> Deserialize<'de> for Wrapping<FixedI8<FRAC>> where
    If<{ _ }>: True, 

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

Deserialize this value from the given Serde deserializer.

impl<'de, const FRAC: i32> Deserialize<'de> for Wrapping<FixedU128<FRAC>> where
    If<{ _ }>: True, 

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

Deserialize this value from the given Serde deserializer.

impl<'de, const FRAC: i32> Deserialize<'de> for Wrapping<FixedU16<FRAC>> where
    If<{ _ }>: True, 

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

Deserialize this value from the given Serde deserializer.

impl<'de, const FRAC: i32> Deserialize<'de> for Wrapping<FixedU32<FRAC>> where
    If<{ _ }>: True, 

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

Deserialize this value from the given Serde deserializer.

impl<'de, const FRAC: i32> Deserialize<'de> for Wrapping<FixedU64<FRAC>> where
    If<{ _ }>: True, 

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

Deserialize this value from the given Serde deserializer.

impl<'de, const FRAC: i32> Deserialize<'de> for Wrapping<FixedU8<FRAC>> where
    If<{ _ }>: True, 

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

Deserialize this value from the given Serde deserializer.

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

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

Formats the value using the given formatter.

impl<F: FixedStrict> 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: FixedStrict> 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<const FRAC: i32> 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<const FRAC: i32> 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<const FRAC: i32> 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<const FRAC: i32> 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<const FRAC: i32> 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<const FRAC: i32> 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<const FRAC: i32> 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<const FRAC: i32> 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<const FRAC: i32> 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<const FRAC: i32> 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<const FRAC: i32> 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<const FRAC: i32> 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<const FRAC: i32> 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<const FRAC: i32> 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<const FRAC: i32> 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<const FRAC: i32> 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<const FRAC: i32> 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<const FRAC: i32> 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<const FRAC: i32> 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<const FRAC: i32> 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: FixedStrict> 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: FixedStrict> 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<const FRAC: i32> 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<const FRAC: i32> 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<const FRAC: i32> 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<const FRAC: i32> 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<const FRAC: i32> 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<const FRAC: i32> 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<const FRAC: i32> 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<const FRAC: i32> 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<const FRAC: i32> 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<const FRAC: i32> 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<const FRAC: i32> 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<const FRAC: i32> 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<const FRAC: i32> 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<const FRAC: i32> 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<const FRAC: i32> 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<const FRAC: i32> 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<const FRAC: i32> 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<const FRAC: i32> 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<const FRAC: i32> 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<const FRAC: i32> 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: FixedStrict> DivAssign<&F> for Wrapping<F>

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

Performs the /= operation.

impl<F: FixedStrict> DivAssign<&Wrapping<F>> for Wrapping<F>

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

Performs the /= operation.

impl<const FRAC: i32> DivAssign<&i128> for Wrapping<FixedI128<FRAC>>

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

Performs the /= operation.

impl<const FRAC: i32> DivAssign<&i16> for Wrapping<FixedI16<FRAC>>

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

Performs the /= operation.

impl<const FRAC: i32> DivAssign<&i32> for Wrapping<FixedI32<FRAC>>

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

Performs the /= operation.

impl<const FRAC: i32> DivAssign<&i64> for Wrapping<FixedI64<FRAC>>

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

Performs the /= operation.

impl<const FRAC: i32> DivAssign<&i8> for Wrapping<FixedI8<FRAC>>

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

Performs the /= operation.

impl<const FRAC: i32> DivAssign<&u128> for Wrapping<FixedU128<FRAC>>

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

Performs the /= operation.

impl<const FRAC: i32> DivAssign<&u16> for Wrapping<FixedU16<FRAC>>

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

Performs the /= operation.

impl<const FRAC: i32> DivAssign<&u32> for Wrapping<FixedU32<FRAC>>

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

Performs the /= operation.

impl<const FRAC: i32> DivAssign<&u64> for Wrapping<FixedU64<FRAC>>

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

Performs the /= operation.

impl<const FRAC: i32> DivAssign<&u8> for Wrapping<FixedU8<FRAC>>

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

Performs the /= operation.

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

fn div_assign(&mut self, other: F)

Performs the /= operation.

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

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

Performs the /= operation.

impl<const FRAC: i32> DivAssign<i128> for Wrapping<FixedI128<FRAC>>

fn div_assign(&mut self, other: i128)

Performs the /= operation.

impl<const FRAC: i32> DivAssign<i16> for Wrapping<FixedI16<FRAC>>

fn div_assign(&mut self, other: i16)

Performs the /= operation.

impl<const FRAC: i32> DivAssign<i32> for Wrapping<FixedI32<FRAC>>

fn div_assign(&mut self, other: i32)

Performs the /= operation.

impl<const FRAC: i32> DivAssign<i64> for Wrapping<FixedI64<FRAC>>

fn div_assign(&mut self, other: i64)

Performs the /= operation.

impl<const FRAC: i32> DivAssign<i8> for Wrapping<FixedI8<FRAC>>

fn div_assign(&mut self, other: i8)

Performs the /= operation.

impl<const FRAC: i32> DivAssign<u128> for Wrapping<FixedU128<FRAC>>

fn div_assign(&mut self, other: u128)

Performs the /= operation.

impl<const FRAC: i32> DivAssign<u16> for Wrapping<FixedU16<FRAC>>

fn div_assign(&mut self, other: u16)

Performs the /= operation.

impl<const FRAC: i32> DivAssign<u32> for Wrapping<FixedU32<FRAC>>

fn div_assign(&mut self, other: u32)

Performs the /= operation.

impl<const FRAC: i32> DivAssign<u64> for Wrapping<FixedU64<FRAC>>

fn div_assign(&mut self, other: u64)

Performs the /= operation.

impl<const FRAC: i32> DivAssign<u8> for Wrapping<FixedU8<FRAC>>

fn div_assign(&mut self, other: u8)

Performs the /= operation.

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

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

Wraps a fixed-point number.

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

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

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

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

type Err = ParseFixedError

The associated error which can be returned from parsing.

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

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

Feeds this value into the given Hasher.

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

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<const FRAC: i32> 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<const FRAC: i32> 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<const FRAC: i32> 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<const FRAC: i32> 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<const FRAC: i32> 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<const FRAC: i32> 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<const FRAC: i32> 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<const FRAC: i32> 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<const FRAC: i32> 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<const FRAC: i32> 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<const FRAC: i32> 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<const FRAC: i32> 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<const FRAC: i32> 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<const FRAC: i32> 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<const FRAC: i32> 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<const FRAC: i32> 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<const FRAC: i32> 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<const FRAC: i32> 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<const FRAC: i32> 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<const FRAC: i32> 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<const FRAC: i32> 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<const FRAC: i32> 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<const FRAC: i32> 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<const FRAC: i32> 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<const FRAC: i32> 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<const FRAC: i32> 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<const FRAC: i32> 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<const FRAC: i32> 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<const FRAC: i32> 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<const FRAC: i32> 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<const FRAC: i32> 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<const FRAC: i32> 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<const FRAC: i32> 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<const FRAC: i32> 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<const FRAC: i32> 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<const FRAC: i32> 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<const FRAC: i32> 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<const FRAC: i32> 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<const FRAC: i32> 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<const FRAC: i32> 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<&F> for Wrapping<F>

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

Performs the *= operation.

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

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

Performs the *= operation.

impl<const FRAC: i32> MulAssign<&i128> for Wrapping<FixedI128<FRAC>>

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

Performs the *= operation.

impl<const FRAC: i32> MulAssign<&i16> for Wrapping<FixedI16<FRAC>>

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

Performs the *= operation.

impl<const FRAC: i32> MulAssign<&i32> for Wrapping<FixedI32<FRAC>>

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

Performs the *= operation.

impl<const FRAC: i32> MulAssign<&i64> for Wrapping<FixedI64<FRAC>>

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

Performs the *= operation.

impl<const FRAC: i32> MulAssign<&i8> for Wrapping<FixedI8<FRAC>>

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

Performs the *= operation.

impl<const FRAC: i32> MulAssign<&u128> for Wrapping<FixedU128<FRAC>>

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

Performs the *= operation.

impl<const FRAC: i32> MulAssign<&u16> for Wrapping<FixedU16<FRAC>>

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

Performs the *= operation.

impl<const FRAC: i32> MulAssign<&u32> for Wrapping<FixedU32<FRAC>>

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

Performs the *= operation.

impl<const FRAC: i32> MulAssign<&u64> for Wrapping<FixedU64<FRAC>>

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

Performs the *= operation.

impl<const FRAC: i32> MulAssign<&u8> for Wrapping<FixedU8<FRAC>>

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

Performs the *= operation.

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

fn mul_assign(&mut self, other: F)

Performs the *= operation.

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

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

Performs the *= operation.

impl<const FRAC: i32> MulAssign<i128> for Wrapping<FixedI128<FRAC>>

fn mul_assign(&mut self, other: i128)

Performs the *= operation.

impl<const FRAC: i32> MulAssign<i16> for Wrapping<FixedI16<FRAC>>

fn mul_assign(&mut self, other: i16)

Performs the *= operation.

impl<const FRAC: i32> MulAssign<i32> for Wrapping<FixedI32<FRAC>>

fn mul_assign(&mut self, other: i32)

Performs the *= operation.

impl<const FRAC: i32> MulAssign<i64> for Wrapping<FixedI64<FRAC>>

fn mul_assign(&mut self, other: i64)

Performs the *= operation.

impl<const FRAC: i32> MulAssign<i8> for Wrapping<FixedI8<FRAC>>

fn mul_assign(&mut self, other: i8)

Performs the *= operation.

impl<const FRAC: i32> MulAssign<u128> for Wrapping<FixedU128<FRAC>>

fn mul_assign(&mut self, other: u128)

Performs the *= operation.

impl<const FRAC: i32> MulAssign<u16> for Wrapping<FixedU16<FRAC>>

fn mul_assign(&mut self, other: u16)

Performs the *= operation.

impl<const FRAC: i32> MulAssign<u32> for Wrapping<FixedU32<FRAC>>

fn mul_assign(&mut self, other: u32)

Performs the *= operation.

impl<const FRAC: i32> MulAssign<u64> for Wrapping<FixedU64<FRAC>>

fn mul_assign(&mut self, other: u64)

Performs the *= operation.

impl<const FRAC: i32> 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
    for<'a> &'a F: Not<Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the ! operator.

fn not(self) -> Wrapping<F>

Performs the unary ! operation.

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

type Output = Wrapping<F>

The resulting type after applying the ! operator.

fn not(self) -> Wrapping<F>

Performs the unary ! operation.

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

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

This method returns an Ordering between self and other.

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

Compares and returns the maximum of two values.

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

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self where
    Self: PartialOrd<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: &Rhs) -> bool

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<F: Fixed> Product<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<const FRAC: i32> Rem<&i128> for &Wrapping<FixedI128<FRAC>> where
    If<{ _ }>: True, 

type Output = Wrapping<FixedI128<FRAC>>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<const FRAC: i32> Rem<&i128> for Wrapping<FixedI128<FRAC>> where
    If<{ _ }>: True, 

type Output = Wrapping<FixedI128<FRAC>>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<const FRAC: i32> Rem<&i16> for &Wrapping<FixedI16<FRAC>> where
    If<{ _ }>: True, 

type Output = Wrapping<FixedI16<FRAC>>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<const FRAC: i32> Rem<&i16> for Wrapping<FixedI16<FRAC>> where
    If<{ _ }>: True, 

type Output = Wrapping<FixedI16<FRAC>>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<const FRAC: i32> Rem<&i32> for &Wrapping<FixedI32<FRAC>> where
    If<{ _ }>: True, 

type Output = Wrapping<FixedI32<FRAC>>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<const FRAC: i32> Rem<&i32> for Wrapping<FixedI32<FRAC>> where
    If<{ _ }>: True, 

type Output = Wrapping<FixedI32<FRAC>>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<const FRAC: i32> Rem<&i64> for &Wrapping<FixedI64<FRAC>> where
    If<{ _ }>: True, 

type Output = Wrapping<FixedI64<FRAC>>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<const FRAC: i32> Rem<&i64> for Wrapping<FixedI64<FRAC>> where
    If<{ _ }>: True, 

type Output = Wrapping<FixedI64<FRAC>>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<const FRAC: i32> Rem<&i8> for &Wrapping<FixedI8<FRAC>> where
    If<{ _ }>: True, 

type Output = Wrapping<FixedI8<FRAC>>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<const FRAC: i32> Rem<&i8> for Wrapping<FixedI8<FRAC>> where
    If<{ _ }>: True, 

type Output = Wrapping<FixedI8<FRAC>>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<const FRAC: i32> Rem<&u128> for &Wrapping<FixedU128<FRAC>> where
    If<{ _ }>: True, 

type Output = Wrapping<FixedU128<FRAC>>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<const FRAC: i32> Rem<&u128> for Wrapping<FixedU128<FRAC>> where
    If<{ _ }>: True, 

type Output = Wrapping<FixedU128<FRAC>>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<const FRAC: i32> Rem<&u16> for &Wrapping<FixedU16<FRAC>> where
    If<{ _ }>: True, 

type Output = Wrapping<FixedU16<FRAC>>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<const FRAC: i32> Rem<&u16> for Wrapping<FixedU16<FRAC>> where
    If<{ _ }>: True, 

type Output = Wrapping<FixedU16<FRAC>>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<const FRAC: i32> Rem<&u32> for &Wrapping<FixedU32<FRAC>> where
    If<{ _ }>: True, 

type Output = Wrapping<FixedU32<FRAC>>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<const FRAC: i32> Rem<&u32> for Wrapping<FixedU32<FRAC>> where
    If<{ _ }>: True, 

type Output = Wrapping<FixedU32<FRAC>>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<const FRAC: i32> Rem<&u64> for &Wrapping<FixedU64<FRAC>> where
    If<{ _ }>: True, 

type Output = Wrapping<FixedU64<FRAC>>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<const FRAC: i32> Rem<&u64> for Wrapping<FixedU64<FRAC>> where
    If<{ _ }>: True, 

type Output = Wrapping<FixedU64<FRAC>>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<const FRAC: i32> Rem<&u8> for &Wrapping<FixedU8<FRAC>> where
    If<{ _ }>: True, 

type Output = Wrapping<FixedU8<FRAC>>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<const FRAC: i32> Rem<&u8> for Wrapping<FixedU8<FRAC>> where
    If<{ _ }>: True, 

type Output = Wrapping<FixedU8<FRAC>>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<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<const FRAC: i32> Rem<i128> for &Wrapping<FixedI128<FRAC>> where
    If<{ _ }>: True, 

type Output = Wrapping<FixedI128<FRAC>>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<const FRAC: i32> Rem<i128> for Wrapping<FixedI128<FRAC>> where
    If<{ _ }>: True, 

type Output = Wrapping<FixedI128<FRAC>>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<const FRAC: i32> Rem<i16> for &Wrapping<FixedI16<FRAC>> where
    If<{ _ }>: True, 

type Output = Wrapping<FixedI16<FRAC>>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<const FRAC: i32> Rem<i16> for Wrapping<FixedI16<FRAC>> where
    If<{ _ }>: True, 

type Output = Wrapping<FixedI16<FRAC>>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<const FRAC: i32> Rem<i32> for &Wrapping<FixedI32<FRAC>> where
    If<{ _ }>: True, 

type Output = Wrapping<FixedI32<FRAC>>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<const FRAC: i32> Rem<i32> for Wrapping<FixedI32<FRAC>> where
    If<{ _ }>: True, 

type Output = Wrapping<FixedI32<FRAC>>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<const FRAC: i32> Rem<i64> for &Wrapping<FixedI64<FRAC>> where
    If<{ _ }>: True, 

type Output = Wrapping<FixedI64<FRAC>>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<const FRAC: i32> Rem<i64> for Wrapping<FixedI64<FRAC>> where
    If<{ _ }>: True, 

type Output = Wrapping<FixedI64<FRAC>>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<const FRAC: i32> Rem<i8> for &Wrapping<FixedI8<FRAC>> where
    If<{ _ }>: True, 

type Output = Wrapping<FixedI8<FRAC>>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<const FRAC: i32> Rem<i8> for Wrapping<FixedI8<FRAC>> where
    If<{ _ }>: True, 

type Output = Wrapping<FixedI8<FRAC>>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<const FRAC: i32> Rem<u128> for &Wrapping<FixedU128<FRAC>> where
    If<{ _ }>: True, 

type Output = Wrapping<FixedU128<FRAC>>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<const FRAC: i32> Rem<u128> for Wrapping<FixedU128<FRAC>> where
    If<{ _ }>: True, 

type Output = Wrapping<FixedU128<FRAC>>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<const FRAC: i32> Rem<u16> for &Wrapping<FixedU16<FRAC>> where
    If<{ _ }>: True, 

type Output = Wrapping<FixedU16<FRAC>>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<const FRAC: i32> Rem<u16> for Wrapping<FixedU16<FRAC>> where
    If<{ _ }>: True, 

type Output = Wrapping<FixedU16<FRAC>>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<const FRAC: i32> Rem<u32> for &Wrapping<FixedU32<FRAC>> where
    If<{ _ }>: True, 

type Output = Wrapping<FixedU32<FRAC>>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<const FRAC: i32> Rem<u32> for Wrapping<FixedU32<FRAC>> where
    If<{ _ }>: True, 

type Output = Wrapping<FixedU32<FRAC>>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<const FRAC: i32> Rem<u64> for &Wrapping<FixedU64<FRAC>> where
    If<{ _ }>: True, 

type Output = Wrapping<FixedU64<FRAC>>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<const FRAC: i32> Rem<u64> for Wrapping<FixedU64<FRAC>> where
    If<{ _ }>: True, 

type Output = Wrapping<FixedU64<FRAC>>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<const FRAC: i32> Rem<u8> for &Wrapping<FixedU8<FRAC>> where
    If<{ _ }>: True, 

type Output = Wrapping<FixedU8<FRAC>>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<const FRAC: i32> Rem<u8> for Wrapping<FixedU8<FRAC>> where
    If<{ _ }>: True, 

type Output = Wrapping<FixedU8<FRAC>>

The resulting type after applying the % operator.

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

Performs the % operation.

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

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

Performs the %= operation.

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

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

Performs the %= operation.

impl<const FRAC: i32> RemAssign<&i128> for Wrapping<FixedI128<FRAC>> where
    If<{ _ }>: True, 

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

Performs the %= operation.

impl<const FRAC: i32> RemAssign<&i16> for Wrapping<FixedI16<FRAC>> where
    If<{ _ }>: True, 

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

Performs the %= operation.

impl<const FRAC: i32> RemAssign<&i32> for Wrapping<FixedI32<FRAC>> where
    If<{ _ }>: True, 

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

Performs the %= operation.

impl<const FRAC: i32> RemAssign<&i64> for Wrapping<FixedI64<FRAC>> where
    If<{ _ }>: True, 

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

Performs the %= operation.

impl<const FRAC: i32> RemAssign<&i8> for Wrapping<FixedI8<FRAC>> where
    If<{ _ }>: True, 

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

Performs the %= operation.

impl<const FRAC: i32> RemAssign<&u128> for Wrapping<FixedU128<FRAC>> where
    If<{ _ }>: True, 

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

Performs the %= operation.

impl<const FRAC: i32> RemAssign<&u16> for Wrapping<FixedU16<FRAC>> where
    If<{ _ }>: True, 

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

Performs the %= operation.

impl<const FRAC: i32> RemAssign<&u32> for Wrapping<FixedU32<FRAC>> where
    If<{ _ }>: True, 

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

Performs the %= operation.

impl<const FRAC: i32> RemAssign<&u64> for Wrapping<FixedU64<FRAC>> where
    If<{ _ }>: True, 

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

Performs the %= operation.

impl<const FRAC: i32> RemAssign<&u8> for Wrapping<FixedU8<FRAC>> where
    If<{ _ }>: True, 

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

Performs the %= operation.

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

fn rem_assign(&mut self, other: F)

Performs the %= operation.

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

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

Performs the %= operation.

impl<const FRAC: i32> RemAssign<i128> for Wrapping<FixedI128<FRAC>> where
    If<{ _ }>: True, 

fn rem_assign(&mut self, other: i128)

Performs the %= operation.

impl<const FRAC: i32> RemAssign<i16> for Wrapping<FixedI16<FRAC>> where
    If<{ _ }>: True, 

fn rem_assign(&mut self, other: i16)

Performs the %= operation.

impl<const FRAC: i32> RemAssign<i32> for Wrapping<FixedI32<FRAC>> where
    If<{ _ }>: True, 

fn rem_assign(&mut self, other: i32)

Performs the %= operation.

impl<const FRAC: i32> RemAssign<i64> for Wrapping<FixedI64<FRAC>> where
    If<{ _ }>: True, 

fn rem_assign(&mut self, other: i64)

Performs the %= operation.

impl<const FRAC: i32> RemAssign<i8> for Wrapping<FixedI8<FRAC>> where
    If<{ _ }>: True, 

fn rem_assign(&mut self, other: i8)

Performs the %= operation.

impl<const FRAC: i32> RemAssign<u128> for Wrapping<FixedU128<FRAC>> where
    If<{ _ }>: True, 

fn rem_assign(&mut self, other: u128)

Performs the %= operation.

impl<const FRAC: i32> RemAssign<u16> for Wrapping<FixedU16<FRAC>> where
    If<{ _ }>: True, 

fn rem_assign(&mut self, other: u16)

Performs the %= operation.

impl<const FRAC: i32> RemAssign<u32> for Wrapping<FixedU32<FRAC>> where
    If<{ _ }>: True, 

fn rem_assign(&mut self, other: u32)

Performs the %= operation.

impl<const FRAC: i32> RemAssign<u64> for Wrapping<FixedU64<FRAC>> where
    If<{ _ }>: True, 

fn rem_assign(&mut self, other: u64)

Performs the %= operation.

impl<const FRAC: i32> RemAssign<u8> for Wrapping<FixedU8<FRAC>> where
    If<{ _ }>: True, 

fn rem_assign(&mut self, other: u8)

Performs the %= operation.

impl<const FRAC: i32> Serialize for Wrapping<FixedI128<FRAC>> where
    If<{ _ }>: True, 

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

Serialize this value into the given Serde serializer.

impl<const FRAC: i32> Serialize for Wrapping<FixedI16<FRAC>> where
    If<{ _ }>: True, 

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

Serialize this value into the given Serde serializer.

impl<const FRAC: i32> Serialize for Wrapping<FixedI32<FRAC>> where
    If<{ _ }>: True, 

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

Serialize this value into the given Serde serializer.

impl<const FRAC: i32> Serialize for Wrapping<FixedI64<FRAC>> where
    If<{ _ }>: True, 

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

Serialize this value into the given Serde serializer.

impl<const FRAC: i32> Serialize for Wrapping<FixedI8<FRAC>> where
    If<{ _ }>: True, 

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

Serialize this value into the given Serde serializer.

impl<const FRAC: i32> Serialize for Wrapping<FixedU128<FRAC>> where
    If<{ _ }>: True, 

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

Serialize this value into the given Serde serializer.

impl<const FRAC: i32> Serialize for Wrapping<FixedU16<FRAC>> where
    If<{ _ }>: True, 

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

Serialize this value into the given Serde serializer.

impl<const FRAC: i32> Serialize for Wrapping<FixedU32<FRAC>> where
    If<{ _ }>: True, 

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

Serialize this value into the given Serde serializer.

impl<const FRAC: i32> Serialize for Wrapping<FixedU64<FRAC>> where
    If<{ _ }>: True, 

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

Serialize this value into the given Serde serializer.

impl<const FRAC: i32> Serialize for Wrapping<FixedU8<FRAC>> where
    If<{ _ }>: True, 

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
    for<'a> &'a F: Shl<u32, Output = F>, 

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Wrapping<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Wrapping<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

fn sub_assign(&mut self, other: &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<F> for Wrapping<F>

fn sub_assign(&mut self, other: 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.

impl<const FRAC: i32> TransparentWrapper<FixedI128<FRAC>> for Wrapping<FixedI128<FRAC>> where
    If<{ _ }>: True, 

fn wrap(s: Inner) -> Self

Convert the inner type into the wrapper type.

fn wrap_ref(s: &Inner) -> &Self

Convert a reference to the inner type into a reference to the wrapper type.

fn wrap_mut(s: &mut Inner) -> &mut Self

Convert a mutable reference to the inner type into a mutable reference to the wrapper type.

fn wrap_slice(s: &[Inner]) -> &[Self]

Convert a slice to the inner type into a slice to the wrapper type.

fn wrap_slice_mut(s: &mut [Inner]) -> &mut [Self]

Convert a mutable slice to the inner type into a mutable slice to the wrapper type.

fn peel(s: Self) -> Inner

Convert the wrapper type into the inner type.

fn peel_ref(s: &Self) -> &Inner

Convert a reference to the wrapper type into a reference to the inner type.

fn peel_mut(s: &mut Self) -> &mut Inner

Convert a mutable reference to the wrapper type into a mutable reference to the inner type.

fn peel_slice(s: &[Self]) -> &[Inner]

Convert a slice to the wrapped type into a slice to the inner type.

fn peel_slice_mut(s: &mut [Self]) -> &mut [Inner]

Convert a mutable slice to the wrapped type into a mutable slice to the inner type.

impl<const FRAC: i32> TransparentWrapper<FixedI16<FRAC>> for Wrapping<FixedI16<FRAC>> where
    If<{ _ }>: True, 

fn wrap(s: Inner) -> Self

Convert the inner type into the wrapper type.

fn wrap_ref(s: &Inner) -> &Self

Convert a reference to the inner type into a reference to the wrapper type.

fn wrap_mut(s: &mut Inner) -> &mut Self

Convert a mutable reference to the inner type into a mutable reference to the wrapper type.

fn wrap_slice(s: &[Inner]) -> &[Self]

Convert a slice to the inner type into a slice to the wrapper type.

fn wrap_slice_mut(s: &mut [Inner]) -> &mut [Self]

Convert a mutable slice to the inner type into a mutable slice to the wrapper type.

fn peel(s: Self) -> Inner

Convert the wrapper type into the inner type.

fn peel_ref(s: &Self) -> &Inner

Convert a reference to the wrapper type into a reference to the inner type.

fn peel_mut(s: &mut Self) -> &mut Inner

Convert a mutable reference to the wrapper type into a mutable reference to the inner type.

fn peel_slice(s: &[Self]) -> &[Inner]

Convert a slice to the wrapped type into a slice to the inner type.

fn peel_slice_mut(s: &mut [Self]) -> &mut [Inner]

Convert a mutable slice to the wrapped type into a mutable slice to the inner type.

impl<const FRAC: i32> TransparentWrapper<FixedI32<FRAC>> for Wrapping<FixedI32<FRAC>> where
    If<{ _ }>: True, 

fn wrap(s: Inner) -> Self

Convert the inner type into the wrapper type.

fn wrap_ref(s: &Inner) -> &Self

Convert a reference to the inner type into a reference to the wrapper type.

fn wrap_mut(s: &mut Inner) -> &mut Self

Convert a mutable reference to the inner type into a mutable reference to the wrapper type.

fn wrap_slice(s: &[Inner]) -> &[Self]

Convert a slice to the inner type into a slice to the wrapper type.

fn wrap_slice_mut(s: &mut [Inner]) -> &mut [Self]

Convert a mutable slice to the inner type into a mutable slice to the wrapper type.

fn peel(s: Self) -> Inner

Convert the wrapper type into the inner type.

fn peel_ref(s: &Self) -> &Inner

Convert a reference to the wrapper type into a reference to the inner type.

fn peel_mut(s: &mut Self) -> &mut Inner

Convert a mutable reference to the wrapper type into a mutable reference to the inner type.

fn peel_slice(s: &[Self]) -> &[Inner]

Convert a slice to the wrapped type into a slice to the inner type.

fn peel_slice_mut(s: &mut [Self]) -> &mut [Inner]

Convert a mutable slice to the wrapped type into a mutable slice to the inner type.

impl<const FRAC: i32> TransparentWrapper<FixedI64<FRAC>> for Wrapping<FixedI64<FRAC>> where
    If<{ _ }>: True, 

fn wrap(s: Inner) -> Self

Convert the inner type into the wrapper type.

fn wrap_ref(s: &Inner) -> &Self

Convert a reference to the inner type into a reference to the wrapper type.

fn wrap_mut(s: &mut Inner) -> &mut Self

Convert a mutable reference to the inner type into a mutable reference to the wrapper type.

fn wrap_slice(s: &[Inner]) -> &[Self]

Convert a slice to the inner type into a slice to the wrapper type.

fn wrap_slice_mut(s: &mut [Inner]) -> &mut [Self]

Convert a mutable slice to the inner type into a mutable slice to the wrapper type.

fn peel(s: Self) -> Inner

Convert the wrapper type into the inner type.

fn peel_ref(s: &Self) -> &Inner

Convert a reference to the wrapper type into a reference to the inner type.

fn peel_mut(s: &mut Self) -> &mut Inner

Convert a mutable reference to the wrapper type into a mutable reference to the inner type.

fn peel_slice(s: &[Self]) -> &[Inner]

Convert a slice to the wrapped type into a slice to the inner type.

fn peel_slice_mut(s: &mut [Self]) -> &mut [Inner]

Convert a mutable slice to the wrapped type into a mutable slice to the inner type.

impl<const FRAC: i32> TransparentWrapper<FixedI8<FRAC>> for Wrapping<FixedI8<FRAC>> where
    If<{ _ }>: True, 

fn wrap(s: Inner) -> Self

Convert the inner type into the wrapper type.

fn wrap_ref(s: &Inner) -> &Self

Convert a reference to the inner type into a reference to the wrapper type.

fn wrap_mut(s: &mut Inner) -> &mut Self

Convert a mutable reference to the inner type into a mutable reference to the wrapper type.

fn wrap_slice(s: &[Inner]) -> &[Self]

Convert a slice to the inner type into a slice to the wrapper type.

fn wrap_slice_mut(s: &mut [Inner]) -> &mut [Self]

Convert a mutable slice to the inner type into a mutable slice to the wrapper type.

fn peel(s: Self) -> Inner

Convert the wrapper type into the inner type.

fn peel_ref(s: &Self) -> &Inner

Convert a reference to the wrapper type into a reference to the inner type.

fn peel_mut(s: &mut Self) -> &mut Inner

Convert a mutable reference to the wrapper type into a mutable reference to the inner type.

fn peel_slice(s: &[Self]) -> &[Inner]

Convert a slice to the wrapped type into a slice to the inner type.

fn peel_slice_mut(s: &mut [Self]) -> &mut [Inner]

Convert a mutable slice to the wrapped type into a mutable slice to the inner type.

impl<const FRAC: i32> TransparentWrapper<FixedU128<FRAC>> for Wrapping<FixedU128<FRAC>> where
    If<{ _ }>: True, 

fn wrap(s: Inner) -> Self

Convert the inner type into the wrapper type.

fn wrap_ref(s: &Inner) -> &Self

Convert a reference to the inner type into a reference to the wrapper type.

fn wrap_mut(s: &mut Inner) -> &mut Self

Convert a mutable reference to the inner type into a mutable reference to the wrapper type.

fn wrap_slice(s: &[Inner]) -> &[Self]

Convert a slice to the inner type into a slice to the wrapper type.

fn wrap_slice_mut(s: &mut [Inner]) -> &mut [Self]

Convert a mutable slice to the inner type into a mutable slice to the wrapper type.

fn peel(s: Self) -> Inner

Convert the wrapper type into the inner type.

fn peel_ref(s: &Self) -> &Inner

Convert a reference to the wrapper type into a reference to the inner type.

fn peel_mut(s: &mut Self) -> &mut Inner

Convert a mutable reference to the wrapper type into a mutable reference to the inner type.

fn peel_slice(s: &[Self]) -> &[Inner]

Convert a slice to the wrapped type into a slice to the inner type.

fn peel_slice_mut(s: &mut [Self]) -> &mut [Inner]

Convert a mutable slice to the wrapped type into a mutable slice to the inner type.

impl<const FRAC: i32> TransparentWrapper<FixedU16<FRAC>> for Wrapping<FixedU16<FRAC>> where
    If<{ _ }>: True, 

fn wrap(s: Inner) -> Self

Convert the inner type into the wrapper type.

fn wrap_ref(s: &Inner) -> &Self

Convert a reference to the inner type into a reference to the wrapper type.

fn wrap_mut(s: &mut Inner) -> &mut Self

Convert a mutable reference to the inner type into a mutable reference to the wrapper type.

fn wrap_slice(s: &[Inner]) -> &[Self]

Convert a slice to the inner type into a slice to the wrapper type.

fn wrap_slice_mut(s: &mut [Inner]) -> &mut [Self]

Convert a mutable slice to the inner type into a mutable slice to the wrapper type.

fn peel(s: Self) -> Inner

Convert the wrapper type into the inner type.

fn peel_ref(s: &Self) -> &Inner

Convert a reference to the wrapper type into a reference to the inner type.

fn peel_mut(s: &mut Self) -> &mut Inner

Convert a mutable reference to the wrapper type into a mutable reference to the inner type.

fn peel_slice(s: &[Self]) -> &[Inner]

Convert a slice to the wrapped type into a slice to the inner type.

fn peel_slice_mut(s: &mut [Self]) -> &mut [Inner]

Convert a mutable slice to the wrapped type into a mutable slice to the inner type.

impl<const FRAC: i32> TransparentWrapper<FixedU32<FRAC>> for Wrapping<FixedU32<FRAC>> where
    If<{ _ }>: True, 

fn wrap(s: Inner) -> Self

Convert the inner type into the wrapper type.

fn wrap_ref(s: &Inner) -> &Self

Convert a reference to the inner type into a reference to the wrapper type.

fn wrap_mut(s: &mut Inner) -> &mut Self

Convert a mutable reference to the inner type into a mutable reference to the wrapper type.

fn wrap_slice(s: &[Inner]) -> &[Self]

Convert a slice to the inner type into a slice to the wrapper type.

fn wrap_slice_mut(s: &mut [Inner]) -> &mut [Self]

Convert a mutable slice to the inner type into a mutable slice to the wrapper type.

fn peel(s: Self) -> Inner

Convert the wrapper type into the inner type.

fn peel_ref(s: &Self) -> &Inner

Convert a reference to the wrapper type into a reference to the inner type.

fn peel_mut(s: &mut Self) -> &mut Inner

Convert a mutable reference to the wrapper type into a mutable reference to the inner type.

fn peel_slice(s: &[Self]) -> &[Inner]

Convert a slice to the wrapped type into a slice to the inner type.

fn peel_slice_mut(s: &mut [Self]) -> &mut [Inner]

Convert a mutable slice to the wrapped type into a mutable slice to the inner type.

impl<const FRAC: i32> TransparentWrapper<FixedU64<FRAC>> for Wrapping<FixedU64<FRAC>> where
    If<{ _ }>: True, 

fn wrap(s: Inner) -> Self

Convert the inner type into the wrapper type.

fn wrap_ref(s: &Inner) -> &Self

Convert a reference to the inner type into a reference to the wrapper type.

fn wrap_mut(s: &mut Inner) -> &mut Self

Convert a mutable reference to the inner type into a mutable reference to the wrapper type.

fn wrap_slice(s: &[Inner]) -> &[Self]

Convert a slice to the inner type into a slice to the wrapper type.

fn wrap_slice_mut(s: &mut [Inner]) -> &mut [Self]

Convert a mutable slice to the inner type into a mutable slice to the wrapper type.

fn peel(s: Self) -> Inner

Convert the wrapper type into the inner type.

fn peel_ref(s: &Self) -> &Inner

Convert a reference to the wrapper type into a reference to the inner type.

fn peel_mut(s: &mut Self) -> &mut Inner

Convert a mutable reference to the wrapper type into a mutable reference to the inner type.

fn peel_slice(s: &[Self]) -> &[Inner]

Convert a slice to the wrapped type into a slice to the inner type.

fn peel_slice_mut(s: &mut [Self]) -> &mut [Inner]

Convert a mutable slice to the wrapped type into a mutable slice to the inner type.

impl<const FRAC: i32> TransparentWrapper<FixedU8<FRAC>> for Wrapping<FixedU8<FRAC>> where
    If<{ _ }>: True, 

fn wrap(s: Inner) -> Self

Convert the inner type into the wrapper type.

fn wrap_ref(s: &Inner) -> &Self

Convert a reference to the inner type into a reference to the wrapper type.

fn wrap_mut(s: &mut Inner) -> &mut Self

Convert a mutable reference to the inner type into a mutable reference to the wrapper type.

fn wrap_slice(s: &[Inner]) -> &[Self]

Convert a slice to the inner type into a slice to the wrapper type.

fn wrap_slice_mut(s: &mut [Inner]) -> &mut [Self]

Convert a mutable slice to the inner type into a mutable slice to the wrapper type.

fn peel(s: Self) -> Inner

Convert the wrapper type into the inner type.

fn peel_ref(s: &Self) -> &Inner

Convert a reference to the wrapper type into a reference to the inner type.

fn peel_mut(s: &mut Self) -> &mut Inner

Convert a mutable reference to the wrapper type into a mutable reference to the inner type.

fn peel_slice(s: &[Self]) -> &[Inner]

Convert a slice to the wrapped type into a slice to the inner type.

fn peel_slice_mut(s: &mut [Self]) -> &mut [Inner]

Convert a mutable slice to the wrapped type into a mutable slice to the inner type.

impl<const FRAC: i32> Zeroable for Wrapping<FixedI128<FRAC>> where
    If<{ _ }>: True, 

fn zeroed() -> Self

Calls zeroed.

impl<const FRAC: i32> Zeroable for Wrapping<FixedI16<FRAC>> where
    If<{ _ }>: True, 

fn zeroed() -> Self

Calls zeroed.

impl<const FRAC: i32> Zeroable for Wrapping<FixedI32<FRAC>> where
    If<{ _ }>: True, 

fn zeroed() -> Self

Calls zeroed.

impl<const FRAC: i32> Zeroable for Wrapping<FixedI64<FRAC>> where
    If<{ _ }>: True, 

fn zeroed() -> Self

Calls zeroed.

impl<const FRAC: i32> Zeroable for Wrapping<FixedI8<FRAC>> where
    If<{ _ }>: True, 

fn zeroed() -> Self

Calls zeroed.

impl<const FRAC: i32> Zeroable for Wrapping<FixedU128<FRAC>> where
    If<{ _ }>: True, 

fn zeroed() -> Self

Calls zeroed.

impl<const FRAC: i32> Zeroable for Wrapping<FixedU16<FRAC>> where
    If<{ _ }>: True, 

fn zeroed() -> Self

Calls zeroed.

impl<const FRAC: i32> Zeroable for Wrapping<FixedU32<FRAC>> where
    If<{ _ }>: True, 

fn zeroed() -> Self

Calls zeroed.

impl<const FRAC: i32> Zeroable for Wrapping<FixedU64<FRAC>> where
    If<{ _ }>: True, 

fn zeroed() -> Self

Calls zeroed.

impl<const FRAC: i32> Zeroable for Wrapping<FixedU8<FRAC>> where
    If<{ _ }>: True, 

fn zeroed() -> Self

Calls zeroed.

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

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

impl<const FRAC: i32> Pod for Wrapping<FixedI128<FRAC>> where
    If<{ _ }>: True, 

impl<const FRAC: i32> Pod for Wrapping<FixedI16<FRAC>> where
    If<{ _ }>: True, 

impl<const FRAC: i32> Pod for Wrapping<FixedI32<FRAC>> where
    If<{ _ }>: True, 

impl<const FRAC: i32> Pod for Wrapping<FixedI64<FRAC>> where
    If<{ _ }>: True, 

impl<const FRAC: i32> Pod for Wrapping<FixedI8<FRAC>> where
    If<{ _ }>: True, 

impl<const FRAC: i32> Pod for Wrapping<FixedU128<FRAC>> where
    If<{ _ }>: True, 

impl<const FRAC: i32> Pod for Wrapping<FixedU16<FRAC>> where
    If<{ _ }>: True, 

impl<const FRAC: i32> Pod for Wrapping<FixedU32<FRAC>> where
    If<{ _ }>: True, 

impl<const FRAC: i32> Pod for Wrapping<FixedU64<FRAC>> where
    If<{ _ }>: True, 

impl<const FRAC: i32> Pod for Wrapping<FixedU8<FRAC>> where
    If<{ _ }>: True, 

impl<F> StructuralEq for Wrapping<F>

impl<F> StructuralPartialEq for Wrapping<F>