Struct fixed::Unwrapped

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

Provides arithmetic operations that panic on overflow even when debug assertions are disabled.

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

Examples

This panics even when debug assertions are disabled.

use fixed::{types::I16F16, Unwrapped};
let max = Unwrapped(I16F16::MAX);
let delta = Unwrapped(I16F16::DELTA);
let _overflow = max + delta;

Tuple Fields

0: F

Implementations

impl<F: Fixed> Unwrapped<F>

pub const ZERO: Unwrapped<F> = _

Zero.

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

Examples

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

pub const DELTA: Unwrapped<F> = _

The difference between any two successive representable numbers, Δ.

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

Examples

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

pub const MIN: Unwrapped<F> = _

The smallest value that can be represented.

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

Examples

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

pub const MAX: Unwrapped<F> = _

The largest value that can be represented.

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

Examples

use fixed::{types::I16F16, Unwrapped};
assert_eq!(Unwrapped::<I16F16>::MAX, Unwrapped(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

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

pub const INT_NBITS: u32 = F::INT_NBITS

The number of integer bits.

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

Examples

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

pub const FRAC_NBITS: u32 = F::FRAC_NBITS

The number of fractional bits.

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

Examples

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

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

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

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

Examples

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

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

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

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

Examples

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

pub fn from_be(w: Self) -> Self

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

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

Examples

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

pub fn from_le(w: Self) -> Self

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

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

Examples

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

pub fn to_be(self) -> Self

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

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

Examples

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

pub fn to_le(self) -> Self

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

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

Examples

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

pub fn swap_bytes(self) -> Self

Reverses the byte order of the fixed-point number.

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

Examples

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

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

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

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

Examples

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

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

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

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

Examples

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

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

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

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

Examples

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

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

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

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

Examples

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

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

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

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

Examples

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

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

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

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

Examples

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

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

Unwrapped conversion from another number.

The other number can be:

• A fixed-point number. Any extra fractional bits are discarded, which rounds towards −∞.
• An integer of type i8, i16, i32, i64, i128, isize, u8, u16, u32, u64, u128, or usize.
• A floating-point number of type f16, bf16, f32, f64 or F128Bits. For this conversion, the method rounds to the nearest, with ties rounding to even.
• Any other number src for which ToFixed is implemented, in which case this method returns Unwrapped(src.unwrapped_to_fixed()).

See also FixedI32::unwrapped_from_num and FixedU32::unwrapped_from_num.

Panics

Panics if the value does not fit.

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

Examples

use fixed::{
    types::{I4F4, I16F16},
    Unwrapped,
};
let src = I16F16::from_num(1.75);
let dst = Unwrapped::<I4F4>::from_num(src);
assert_eq!(dst, Unwrapped(I4F4::from_num(1.75)));

The following panics even when debug assertions are disabled.

use fixed::{
    types::{I4F4, I16F16},
    Unwrapped,
};
let src = I16F16::from_bits(0x1234_5678);
let _overflow = Unwrapped::<I4F4>::from_num(src);

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

Converts a fixed-point number to another number, panicking on overflow.

The other number can be:

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

See also FixedI32::unwrapped_to_num and FixedU32::unwrapped_to_num.

Examples

use fixed::{
    types::{I16F16, I4F4},
    Unwrapped,
};
let src = Unwrapped(I4F4::from_num(1.75));
assert_eq!(src.to_num::<I16F16>(), I16F16::from_num(1.75));

The following panics even when debug assertions are disabled.

use fixed::{
    types::{I2F6, I4F4},
    Unwrapped,
};
let src = Unwrapped(I4F4::MAX);
let _overflow = src.to_num::<I2F6>();

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

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

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

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

Examples

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

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

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

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

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

Examples

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

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

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

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

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

Examples

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

pub fn int(self) -> Unwrapped<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 Unwrapped<I0F16>, where the return value is always zero.

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

Examples

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

pub fn frac(self) -> Unwrapped<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 Unwrapped<I0F16>, where the return value is always equal to self.

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

Examples

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

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

Rounds to the next integer towards 0.

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

Examples

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

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

Unwrapped ceil. Rounds to the next integer towards +∞, panicking on overflow.

See also FixedI32::unwrapped_ceil and FixedU32::unwrapped_ceil.

Panics

Panics if the result does not fit.

Examples

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

The following panics because of overflow.

use fixed::{types::I16F16, Unwrapped};
let _overflow = Unwrapped(I16F16::MAX).ceil();

pub fn floor(self) -> Unwrapped<F>

Unwrapped floor. Rounds to the next integer towards −∞, panicking on overflow.

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

See also FixedI32::unwrapped_floor and FixedU32::unwrapped_floor.

Panics

Panics if the result does not fit.

Examples

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

The following panics because of overflow.

use fixed::{types::I0F32, Unwrapped};
let _overflow = Unwrapped(I0F32::MIN).floor();

pub fn round(self) -> Unwrapped<F>

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

See also FixedI32::unwrapped_round and FixedU32::unwrapped_round.

Panics

Panics if the result does not fit.

Examples

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

The following panics because of overflow.

use fixed::{types::I16F16, Unwrapped};
let _overflow = Unwrapped(I16F16::MAX).round();

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

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

See also FixedI32::unwrapped_round_ties_to_even and FixedU32::unwrapped_round_ties_to_even.

Panics

Panics if the result does not fit.

Examples

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

The following panics because of overflow.

use fixed::{types::I16F16, Unwrapped};
let max = Unwrapped(I16F16::MAX);
let _overflow = max.round_ties_to_even();

pub fn count_ones(self) -> u32

Returns the number of ones in the binary representation.

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

Examples

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

pub fn count_zeros(self) -> u32

Returns the number of zeros in the binary representation.

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

Examples

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

pub fn leading_ones(self) -> u32

Returns the number of leading ones in the binary representation.

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

Examples

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

pub fn leading_zeros(self) -> u32

Returns the number of leading zeros in the binary representation.

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

Examples

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

pub fn trailing_ones(self) -> u32

Returns the number of trailing ones in the binary representation.

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

Examples

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

pub fn trailing_zeros(self) -> u32

Returns the number of trailing zeros in the binary representation.

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

Examples

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

pub fn int_log2(self) -> i32

Integer base-2 logarithm, rounded down.

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

Panics

Panics if the fixed-point number is ≤ 0.

pub fn int_log10(self) -> i32

Integer base-10 logarithm, rounded down.

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

Panics

Panics if the fixed-point number is ≤ 0.

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

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

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

Examples

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

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

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

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

Examples

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

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

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

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

Examples

use fixed::{types::I16F16, Unwrapped};
let i = I16F16::from_bits(0x00FF_FF00);
assert_eq!(Unwrapped(i).rotate_right(12), Unwrapped(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

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

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

Returns the distance from self to other.

See also FixedI32::unwrapped_dist and FixedU32::unwrapped_dist.

Panics

Panics on overflow.

Examples

use fixed::{types::I16F16, Unwrapped};
type Unwr = Unwrapped<I16F16>;
assert_eq!(Unwr::from_num(-1).dist(Unwr::from_num(4)), Unwr::from_num(5));

The following panics because of overflow.

use fixed::{types::I16F16, Unwrapped};
type Unwr = Unwrapped<I16F16>;
let _overflow = Unwr::MIN.dist(Unwr::ZERO);

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

Returns the mean of self and other.

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

Examples

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

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

Returns the reciprocal (inverse), 1/self.

See also FixedI32::unwrapped_recip and FixedU32::unwrapped_recip.

Panics

Panics if self is zero or on overflow.

Examples

use fixed::{types::I8F24, Unwrapped};
let quarter = Unwrapped(I8F24::from_num(0.25));
assert_eq!(quarter.recip(), Unwrapped(I8F24::from_num(4)));

The following panics because of overflow.

use fixed::{types::I8F24, Unwrapped};
let frac_1_512 = Unwrapped(I8F24::ONE / 512);
let _overflow = frac_1_512.recip();

pub fn next_multiple_of(self, other: Unwrapped<F>) -> Unwrapped<F>

Returns the next multiple of other.

See also FixedI32::unwrapped_next_multiple_of and FixedU32::unwrapped_next_multiple_of.

Panics

Panics if other is zero or on overflow.

Examples

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

The following panics because of overflow.

use fixed::{types::I16F16, Unwrapped};
let two = Unwrapped::<I16F16>::from_num(2);
let max = Unwrapped::<I16F16>::MAX;
let _overflow = max.next_multiple_of(two);

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

Multiply and add. Returns self × mul + add.

See also FixedI32::unwrapped_mul_add and FixedU32::unwrapped_mul_add.

Panics

Panics if the result does not fit.

Examples

use fixed::{types::I16F16, Unwrapped};
let half = Unwrapped(I16F16::from_num(0.5));
let three = Unwrapped(I16F16::from_num(3));
let four = Unwrapped(I16F16::from_num(4));
assert_eq!(three.mul_add(half, four), Unwrapped(I16F16::from_num(5.5)));
// max × 1.5 - max = max / 2, which does not overflow
let max = Unwrapped(I16F16::MAX);
assert_eq!(max.mul_add(Unwrapped(I16F16::from_num(1.5)), -max), max / 2);

The following panics because of overflow.

use fixed::{types::I16F16, Unwrapped};
let one = Unwrapped(I16F16::ONE);
let max = Unwrapped(I16F16::MAX);
let _overflow = max.mul_add(one, one);

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

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

See also FixedI32::unwrapped_mul_acc and FixedU32::unwrapped_mul_acc.

Panics

Panics if the result does not fit.

Examples

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

The following panics because of overflow.

use fixed::{types::I16F16, Unwrapped};
let mut acc = Unwrapped(I16F16::MAX);
acc.mul_acc(Unwrapped(I16F16::MAX), Unwrapped(I16F16::from_num(3)));

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

Euclidean division.

See also FixedI32::unwrapped_div_euclid and FixedU32::unwrapped_div_euclid.

Panics

Panics if the divisor is zero, or if the division results in overflow.

Examples

use fixed::{types::I16F16, Unwrapped};
let num = Unwrapped(I16F16::from_num(7.5));
let den = Unwrapped(I16F16::from_num(2));
assert_eq!(num.div_euclid(den), Unwrapped(I16F16::from_num(3)));

The following panics because of overflow.

use fixed::{types::I16F16, Unwrapped};
let quarter = Unwrapped(I16F16::from_num(0.25));
let _overflow = Unwrapped(I16F16::MAX).div_euclid(quarter);

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

Remainder for Euclidean division.

See also FixedI32::unwrapped_rem_euclid and FixedU32::unwrapped_rem_euclid.

Panics

Panics if the divisor is zero.

Examples

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

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

Euclidean division by an integer.

See also FixedI32::unwrapped_div_euclid_int and FixedU32::unwrapped_div_euclid_int.

Panics

Panics if the divisor is zero or if the division results in overflow.

Examples

use fixed::{types::I16F16, Unwrapped};
let num = Unwrapped(I16F16::from_num(7.5));
assert_eq!(num.div_euclid_int(2), Unwrapped(I16F16::from_num(3)));

The following panics because of overflow.

use fixed::{types::I16F16, Unwrapped};
let min = Unwrapped(I16F16::MIN);
let _overflow = min.div_euclid_int(-1);

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

Remainder for Euclidean division.

See also FixedI32::unwrapped_rem_euclid_int and FixedU32::unwrapped_rem_euclid_int.

Panics

Panics if the divisor is zero.

Examples

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

The following panics because of overflow.

use fixed::{types::I8F8, Unwrapped};
let num = Unwrapped(I8F8::from_num(-7.5));
// -128 ≤ Fix < 128, so the answer 192.5 overflows
let _overflow = num.rem_euclid_int(200);

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

Linear interpolation between start and end.

See also FixedI32::unwrapped_lerp and FixedU32::unwrapped_lerp.

Panics

Panics on overflow.

Examples

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

The following panics because of overflow.

use fixed::{types::I16F16, Unwrapped};
type Unwr = Unwrapped<I16F16>;
let _overflow = Unwr::from_num(1.5).lerp(Unwr::ZERO, Unwr::MAX);

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

Inverse linear interpolation between start and end.

See also FixedI32::unwrapped_inv_lerp and FixedU32::unwrapped_inv_lerp.

Panics

Panics when start = end or when the results overflows.

Examples

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

The following panics because start = end.

use fixed::{types::I16F16, Unwrapped};
type Unwr = Unwrapped<I16F16>;
let two = Unwr::from_num(2);
let _zero_range = two.inv_lerp(two, two);

The following panics because of overflow.

use fixed::{types::I16F16, Unwrapped};
type Unwr = Unwrapped<I16F16>;
let _overflow = Unwr::MAX.inv_lerp(Unwr::ZERO, Unwr::from_num(0.5));

impl<F: FixedSigned> Unwrapped<F>

pub fn signed_bits(self) -> u32

Returns the number of bits required to represent the value.

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

See also FixedI32::signed_bits.

Examples

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

pub fn is_positive(self) -> bool

Returns true if the number is > 0.

See also FixedI32::is_positive.

Examples

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

pub fn is_negative(self) -> bool

Returns true if the number is < 0.

See also FixedI32::is_negative.

Examples

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

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

Unwrapped absolute value. Returns the absolute value, panicking on overflow.

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

See also FixedI32::unwrapped_abs.

Panics

Panics if the result does not fit.

Examples

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

The following panics because of overflow.

use fixed::{types::I16F16, Unwrapped};
let _overflow = Unwrapped(I16F16::MIN).abs();

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

Returns a number representing the sign of self.

See also FixedI32::unwrapped_signum.

Panics

Panics

• if the value is positive and the fixed-point number has zero or one integer bits such that it cannot hold the value 1.
• if the value is negative and the fixed-point number has zero integer bits, such that it cannot hold the value −1.

Examples

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

The following panics because of overflow.

use fixed::{types::I1F31, Unwrapped};
let _overflow = Unwrapped(<I1F31>::from_num(0.5)).signum();

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

Addition with an unsigned fixed-point number.

See also FixedI32::unwrapped_add_unsigned.

Panics

Panics if the result does not fit.

Examples

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

The following panics because of overflow.

use fixed::{
    types::{I16F16, U16F16},
    Unwrapped,
};
let _overflow = Unwrapped::<I16F16>::ZERO.add_unsigned(U16F16::MAX);

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

Subtraction with an unsigned fixed-point number.

See also FixedI32::unwrapped_sub_unsigned.

Panics

Panics if the result does not fit.

Examples

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

The following panics because of overflow.

use fixed::{
    types::{I16F16, U16F16},
    Unwrapped,
};
let _overflow = Unwrapped::<I16F16>::ZERO.sub_unsigned(U16F16::MAX);

impl<F: FixedUnsigned> Unwrapped<F>

pub fn significant_bits(self) -> u32

Returns the number of bits required to represent the value.

See also FixedU32::significant_bits.

Examples

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

pub fn is_power_of_two(self) -> bool

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

See also FixedU32::is_power_of_two.

Examples

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

pub fn highest_one(self) -> Unwrapped<F>

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

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

See also FixedU32::highest_one.

Examples

use fixed::{types::U16F16, Unwrapped};
type T = Unwrapped<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) -> Unwrapped<F>

Returns the smallest power of two that is ≥ self.

See also FixedU32::unwrapped_next_power_of_two.

Panics

Panics if the next power of two is too large to fit.

Examples

use fixed::{types::U16F16, Unwrapped};
type T = Unwrapped<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));

The following panics because of overflow.

use fixed::{types::U16F16, Unwrapped};
let _overflow = Unwrapped(U16F16::MAX).next_power_of_two();

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

Addition with an signed fixed-point number.

See also FixedU32::unwrapped_add_signed.

Panics

Panics if the result does not fit.

Examples

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

The following panics because of overflow.

use fixed::{
    types::{I16F16, U16F16},
    Unwrapped,
};
let _overflow = Unwrapped::<U16F16>::ZERO.add_signed(-I16F16::DELTA);

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

Subtraction with an signed fixed-point number.

See also FixedU32::unwrapped_sub_signed.

Panics

Panics if the result does not fit.

Examples

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

The following panics because of overflow.

use fixed::{
    types::{I16F16, U16F16},
    Unwrapped,
};
let _overflow = Unwrapped::<U16F16>::ZERO.sub_signed(I16F16::DELTA);

Trait Implementations

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

type Output = Unwrapped<F>

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = Unwrapped<F>

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = Unwrapped<F>

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = Unwrapped<F>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<F: Fixed> AddAssign<&F> for Unwrapped<F>

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

Performs the += operation.

impl<F: Fixed> AddAssign<&Unwrapped<F>> for Unwrapped<F>

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

Performs the += operation.

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

fn add_assign(&mut self, other: F)

Performs the += operation.

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

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

Performs the += operation.

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

type Output = Unwrapped<F>

The resulting type after applying the & operator.

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

Performs the & operation.

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

type Output = Unwrapped<F>

The resulting type after applying the & operator.

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

Performs the & operation.

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

type Output = Unwrapped<F>

The resulting type after applying the & operator.

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

Performs the & operation.

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

type Output = Unwrapped<F>

The resulting type after applying the & operator.

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

Performs the & operation.

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

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

Performs the &= operation.

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

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

Performs the &= operation.

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

fn bitand_assign(&mut self, other: F)

Performs the &= operation.

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

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

Performs the &= operation.

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

type Output = Unwrapped<F>

The resulting type after applying the | operator.

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

Performs the | operation.

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

type Output = Unwrapped<F>

The resulting type after applying the | operator.

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

Performs the | operation.

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

type Output = Unwrapped<F>

The resulting type after applying the | operator.

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

Performs the | operation.

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

type Output = Unwrapped<F>

The resulting type after applying the | operator.

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

Performs the | operation.

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

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

Performs the |= operation.

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

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

Performs the |= operation.

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

fn bitor_assign(&mut self, other: F)

Performs the |= operation.

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

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

Performs the |= operation.

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

type Output = Unwrapped<F>

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

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

type Output = Unwrapped<F>

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

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

type Output = Unwrapped<F>

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

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

type Output = Unwrapped<F>

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

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

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

Performs the ^= operation.

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

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

Performs the ^= operation.

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

fn bitxor_assign(&mut self, other: F)

Performs the ^= operation.

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

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

Performs the ^= operation.

impl<F: Clone> Clone for Unwrapped<F>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<F: Fixed> Debug for Unwrapped<F>

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

Formats the value using the given formatter.

impl<F: Default> Default for Unwrapped<F>

fn default() -> Unwrapped<F>

Returns the “default value” for a type.

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

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

Formats the value using the given formatter.

impl<F: Fixed> Div<&Unwrapped<F>> for &Unwrapped<F>

type Output = Unwrapped<F>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<F: Fixed> Div<&Unwrapped<F>> for Unwrapped<F>

type Output = Unwrapped<F>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<Frac> Div<&i128> for &Unwrapped<FixedI128<Frac>>

type Output = Unwrapped<FixedI128<Frac>>

The resulting type after applying the / operator.

fn div(self, other: &i128) -> Unwrapped<FixedI128<Frac>>

Performs the / operation.

impl<Frac> Div<&i128> for Unwrapped<FixedI128<Frac>>

type Output = Unwrapped<FixedI128<Frac>>

The resulting type after applying the / operator.

fn div(self, other: &i128) -> Unwrapped<FixedI128<Frac>>

Performs the / operation.

impl<Frac> Div<&i16> for &Unwrapped<FixedI16<Frac>>

type Output = Unwrapped<FixedI16<Frac>>

The resulting type after applying the / operator.

fn div(self, other: &i16) -> Unwrapped<FixedI16<Frac>>

Performs the / operation.

impl<Frac> Div<&i16> for Unwrapped<FixedI16<Frac>>

type Output = Unwrapped<FixedI16<Frac>>

The resulting type after applying the / operator.

fn div(self, other: &i16) -> Unwrapped<FixedI16<Frac>>

Performs the / operation.

impl<Frac> Div<&i32> for &Unwrapped<FixedI32<Frac>>

type Output = Unwrapped<FixedI32<Frac>>

The resulting type after applying the / operator.

fn div(self, other: &i32) -> Unwrapped<FixedI32<Frac>>

Performs the / operation.

impl<Frac> Div<&i32> for Unwrapped<FixedI32<Frac>>

type Output = Unwrapped<FixedI32<Frac>>

The resulting type after applying the / operator.

fn div(self, other: &i32) -> Unwrapped<FixedI32<Frac>>

Performs the / operation.

impl<Frac> Div<&i64> for &Unwrapped<FixedI64<Frac>>

type Output = Unwrapped<FixedI64<Frac>>

The resulting type after applying the / operator.

fn div(self, other: &i64) -> Unwrapped<FixedI64<Frac>>

Performs the / operation.

impl<Frac> Div<&i64> for Unwrapped<FixedI64<Frac>>

type Output = Unwrapped<FixedI64<Frac>>

The resulting type after applying the / operator.

fn div(self, other: &i64) -> Unwrapped<FixedI64<Frac>>

Performs the / operation.

impl<Frac> Div<&i8> for &Unwrapped<FixedI8<Frac>>

type Output = Unwrapped<FixedI8<Frac>>

The resulting type after applying the / operator.

fn div(self, other: &i8) -> Unwrapped<FixedI8<Frac>>

Performs the / operation.

impl<Frac> Div<&i8> for Unwrapped<FixedI8<Frac>>

type Output = Unwrapped<FixedI8<Frac>>

The resulting type after applying the / operator.

fn div(self, other: &i8) -> Unwrapped<FixedI8<Frac>>

Performs the / operation.

impl<Frac> Div<&u128> for &Unwrapped<FixedU128<Frac>>

type Output = Unwrapped<FixedU128<Frac>>

The resulting type after applying the / operator.

fn div(self, other: &u128) -> Unwrapped<FixedU128<Frac>>

Performs the / operation.

impl<Frac> Div<&u128> for Unwrapped<FixedU128<Frac>>

type Output = Unwrapped<FixedU128<Frac>>

The resulting type after applying the / operator.

fn div(self, other: &u128) -> Unwrapped<FixedU128<Frac>>

Performs the / operation.

impl<Frac> Div<&u16> for &Unwrapped<FixedU16<Frac>>

type Output = Unwrapped<FixedU16<Frac>>

The resulting type after applying the / operator.

fn div(self, other: &u16) -> Unwrapped<FixedU16<Frac>>

Performs the / operation.

impl<Frac> Div<&u16> for Unwrapped<FixedU16<Frac>>

type Output = Unwrapped<FixedU16<Frac>>

The resulting type after applying the / operator.

fn div(self, other: &u16) -> Unwrapped<FixedU16<Frac>>

Performs the / operation.

impl<Frac> Div<&u32> for &Unwrapped<FixedU32<Frac>>

type Output = Unwrapped<FixedU32<Frac>>

The resulting type after applying the / operator.

fn div(self, other: &u32) -> Unwrapped<FixedU32<Frac>>

Performs the / operation.

impl<Frac> Div<&u32> for Unwrapped<FixedU32<Frac>>

type Output = Unwrapped<FixedU32<Frac>>

The resulting type after applying the / operator.

fn div(self, other: &u32) -> Unwrapped<FixedU32<Frac>>

Performs the / operation.

impl<Frac> Div<&u64> for &Unwrapped<FixedU64<Frac>>

type Output = Unwrapped<FixedU64<Frac>>

The resulting type after applying the / operator.

fn div(self, other: &u64) -> Unwrapped<FixedU64<Frac>>

Performs the / operation.

impl<Frac> Div<&u64> for Unwrapped<FixedU64<Frac>>

type Output = Unwrapped<FixedU64<Frac>>

The resulting type after applying the / operator.

fn div(self, other: &u64) -> Unwrapped<FixedU64<Frac>>

Performs the / operation.

impl<Frac> Div<&u8> for &Unwrapped<FixedU8<Frac>>

type Output = Unwrapped<FixedU8<Frac>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<Frac> Div<&u8> for Unwrapped<FixedU8<Frac>>

type Output = Unwrapped<FixedU8<Frac>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<F: Fixed> Div<Unwrapped<F>> for &Unwrapped<F>

type Output = Unwrapped<F>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Unwrapped<F>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<Frac> Div<i128> for &Unwrapped<FixedI128<Frac>>

type Output = Unwrapped<FixedI128<Frac>>

The resulting type after applying the / operator.

fn div(self, other: i128) -> Unwrapped<FixedI128<Frac>>

Performs the / operation.

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

type Output = Unwrapped<FixedI128<Frac>>

The resulting type after applying the / operator.

fn div(self, other: i128) -> Unwrapped<FixedI128<Frac>>

Performs the / operation.

impl<Frac> Div<i16> for &Unwrapped<FixedI16<Frac>>

type Output = Unwrapped<FixedI16<Frac>>

The resulting type after applying the / operator.

fn div(self, other: i16) -> Unwrapped<FixedI16<Frac>>

Performs the / operation.

impl<Frac> Div<i16> for Unwrapped<FixedI16<Frac>>

type Output = Unwrapped<FixedI16<Frac>>

The resulting type after applying the / operator.

fn div(self, other: i16) -> Unwrapped<FixedI16<Frac>>

Performs the / operation.

impl<Frac> Div<i32> for &Unwrapped<FixedI32<Frac>>

type Output = Unwrapped<FixedI32<Frac>>

The resulting type after applying the / operator.

fn div(self, other: i32) -> Unwrapped<FixedI32<Frac>>

Performs the / operation.

impl<Frac> Div<i32> for Unwrapped<FixedI32<Frac>>

type Output = Unwrapped<FixedI32<Frac>>

The resulting type after applying the / operator.

fn div(self, other: i32) -> Unwrapped<FixedI32<Frac>>

Performs the / operation.

impl<Frac> Div<i64> for &Unwrapped<FixedI64<Frac>>

type Output = Unwrapped<FixedI64<Frac>>

The resulting type after applying the / operator.

fn div(self, other: i64) -> Unwrapped<FixedI64<Frac>>

Performs the / operation.

impl<Frac> Div<i64> for Unwrapped<FixedI64<Frac>>

type Output = Unwrapped<FixedI64<Frac>>

The resulting type after applying the / operator.

fn div(self, other: i64) -> Unwrapped<FixedI64<Frac>>

Performs the / operation.

impl<Frac> Div<i8> for &Unwrapped<FixedI8<Frac>>

type Output = Unwrapped<FixedI8<Frac>>

The resulting type after applying the / operator.

fn div(self, other: i8) -> Unwrapped<FixedI8<Frac>>

Performs the / operation.

impl<Frac> Div<i8> for Unwrapped<FixedI8<Frac>>

type Output = Unwrapped<FixedI8<Frac>>

The resulting type after applying the / operator.

fn div(self, other: i8) -> Unwrapped<FixedI8<Frac>>

Performs the / operation.

impl<Frac> Div<u128> for &Unwrapped<FixedU128<Frac>>

type Output = Unwrapped<FixedU128<Frac>>

The resulting type after applying the / operator.

fn div(self, other: u128) -> Unwrapped<FixedU128<Frac>>

Performs the / operation.

impl<Frac> Div<u128> for Unwrapped<FixedU128<Frac>>

type Output = Unwrapped<FixedU128<Frac>>

The resulting type after applying the / operator.

fn div(self, other: u128) -> Unwrapped<FixedU128<Frac>>

Performs the / operation.

impl<Frac> Div<u16> for &Unwrapped<FixedU16<Frac>>

type Output = Unwrapped<FixedU16<Frac>>

The resulting type after applying the / operator.

fn div(self, other: u16) -> Unwrapped<FixedU16<Frac>>

Performs the / operation.

impl<Frac> Div<u16> for Unwrapped<FixedU16<Frac>>

type Output = Unwrapped<FixedU16<Frac>>

The resulting type after applying the / operator.

fn div(self, other: u16) -> Unwrapped<FixedU16<Frac>>

Performs the / operation.

impl<Frac> Div<u32> for &Unwrapped<FixedU32<Frac>>

type Output = Unwrapped<FixedU32<Frac>>

The resulting type after applying the / operator.

fn div(self, other: u32) -> Unwrapped<FixedU32<Frac>>

Performs the / operation.

impl<Frac> Div<u32> for Unwrapped<FixedU32<Frac>>

type Output = Unwrapped<FixedU32<Frac>>

The resulting type after applying the / operator.

fn div(self, other: u32) -> Unwrapped<FixedU32<Frac>>

Performs the / operation.

impl<Frac> Div<u64> for &Unwrapped<FixedU64<Frac>>

type Output = Unwrapped<FixedU64<Frac>>

The resulting type after applying the / operator.

fn div(self, other: u64) -> Unwrapped<FixedU64<Frac>>

Performs the / operation.

impl<Frac> Div<u64> for Unwrapped<FixedU64<Frac>>

type Output = Unwrapped<FixedU64<Frac>>

The resulting type after applying the / operator.

fn div(self, other: u64) -> Unwrapped<FixedU64<Frac>>

Performs the / operation.

impl<Frac> Div<u8> for &Unwrapped<FixedU8<Frac>>

type Output = Unwrapped<FixedU8<Frac>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<Frac> Div<u8> for Unwrapped<FixedU8<Frac>>

type Output = Unwrapped<FixedU8<Frac>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<F: Fixed> DivAssign<&F> for Unwrapped<F>

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

Performs the /= operation.

impl<F: Fixed> DivAssign<&Unwrapped<F>> for Unwrapped<F>

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

Performs the /= operation.

impl<Frac> DivAssign<&i128> for Unwrapped<FixedI128<Frac>>

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

Performs the /= operation.

impl<Frac> DivAssign<&i16> for Unwrapped<FixedI16<Frac>>

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

Performs the /= operation.

impl<Frac> DivAssign<&i32> for Unwrapped<FixedI32<Frac>>

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

Performs the /= operation.

impl<Frac> DivAssign<&i64> for Unwrapped<FixedI64<Frac>>

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

Performs the /= operation.

impl<Frac> DivAssign<&i8> for Unwrapped<FixedI8<Frac>>

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

Performs the /= operation.

impl<Frac> DivAssign<&u128> for Unwrapped<FixedU128<Frac>>

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

Performs the /= operation.

impl<Frac> DivAssign<&u16> for Unwrapped<FixedU16<Frac>>

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

Performs the /= operation.

impl<Frac> DivAssign<&u32> for Unwrapped<FixedU32<Frac>>

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

Performs the /= operation.

impl<Frac> DivAssign<&u64> for Unwrapped<FixedU64<Frac>>

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

Performs the /= operation.

impl<Frac> DivAssign<&u8> for Unwrapped<FixedU8<Frac>>

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

Performs the /= operation.

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

fn div_assign(&mut self, other: F)

Performs the /= operation.

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

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

Performs the /= operation.

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

fn div_assign(&mut self, other: i128)

Performs the /= operation.

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

fn div_assign(&mut self, other: i16)

Performs the /= operation.

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

fn div_assign(&mut self, other: i32)

Performs the /= operation.

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

fn div_assign(&mut self, other: i64)

Performs the /= operation.

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

fn div_assign(&mut self, other: i8)

Performs the /= operation.

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

fn div_assign(&mut self, other: u128)

Performs the /= operation.

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

fn div_assign(&mut self, other: u16)

Performs the /= operation.

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

fn div_assign(&mut self, other: u32)

Performs the /= operation.

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

fn div_assign(&mut self, other: u64)

Performs the /= operation.

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

fn div_assign(&mut self, other: u8)

Performs the /= operation.

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

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

Wraps a fixed-point number.

impl<F: Fixed> FromStr for Unwrapped<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 Unwrapped<F>

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

Feeds this value into the given Hasher.

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

Feeds a slice of this type into the given Hasher.

impl<F: Fixed> Mul<&Unwrapped<F>> for &Unwrapped<F>

type Output = Unwrapped<F>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<F: Fixed> Mul<&Unwrapped<F>> for Unwrapped<F>

type Output = Unwrapped<F>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<Frac> Mul<&i128> for &Unwrapped<FixedI128<Frac>>

type Output = Unwrapped<FixedI128<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: &i128) -> Unwrapped<FixedI128<Frac>>

Performs the * operation.

impl<Frac> Mul<&i128> for Unwrapped<FixedI128<Frac>>

type Output = Unwrapped<FixedI128<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: &i128) -> Unwrapped<FixedI128<Frac>>

Performs the * operation.

impl<Frac> Mul<&i16> for &Unwrapped<FixedI16<Frac>>

type Output = Unwrapped<FixedI16<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: &i16) -> Unwrapped<FixedI16<Frac>>

Performs the * operation.

impl<Frac> Mul<&i16> for Unwrapped<FixedI16<Frac>>

type Output = Unwrapped<FixedI16<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: &i16) -> Unwrapped<FixedI16<Frac>>

Performs the * operation.

impl<Frac> Mul<&i32> for &Unwrapped<FixedI32<Frac>>

type Output = Unwrapped<FixedI32<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: &i32) -> Unwrapped<FixedI32<Frac>>

Performs the * operation.

impl<Frac> Mul<&i32> for Unwrapped<FixedI32<Frac>>

type Output = Unwrapped<FixedI32<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: &i32) -> Unwrapped<FixedI32<Frac>>

Performs the * operation.

impl<Frac> Mul<&i64> for &Unwrapped<FixedI64<Frac>>

type Output = Unwrapped<FixedI64<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: &i64) -> Unwrapped<FixedI64<Frac>>

Performs the * operation.

impl<Frac> Mul<&i64> for Unwrapped<FixedI64<Frac>>

type Output = Unwrapped<FixedI64<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: &i64) -> Unwrapped<FixedI64<Frac>>

Performs the * operation.

impl<Frac> Mul<&i8> for &Unwrapped<FixedI8<Frac>>

type Output = Unwrapped<FixedI8<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: &i8) -> Unwrapped<FixedI8<Frac>>

Performs the * operation.

impl<Frac> Mul<&i8> for Unwrapped<FixedI8<Frac>>

type Output = Unwrapped<FixedI8<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: &i8) -> Unwrapped<FixedI8<Frac>>

Performs the * operation.

impl<Frac> Mul<&u128> for &Unwrapped<FixedU128<Frac>>

type Output = Unwrapped<FixedU128<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: &u128) -> Unwrapped<FixedU128<Frac>>

Performs the * operation.

impl<Frac> Mul<&u128> for Unwrapped<FixedU128<Frac>>

type Output = Unwrapped<FixedU128<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: &u128) -> Unwrapped<FixedU128<Frac>>

Performs the * operation.

impl<Frac> Mul<&u16> for &Unwrapped<FixedU16<Frac>>

type Output = Unwrapped<FixedU16<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: &u16) -> Unwrapped<FixedU16<Frac>>

Performs the * operation.

impl<Frac> Mul<&u16> for Unwrapped<FixedU16<Frac>>

type Output = Unwrapped<FixedU16<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: &u16) -> Unwrapped<FixedU16<Frac>>

Performs the * operation.

impl<Frac> Mul<&u32> for &Unwrapped<FixedU32<Frac>>

type Output = Unwrapped<FixedU32<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: &u32) -> Unwrapped<FixedU32<Frac>>

Performs the * operation.

impl<Frac> Mul<&u32> for Unwrapped<FixedU32<Frac>>

type Output = Unwrapped<FixedU32<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: &u32) -> Unwrapped<FixedU32<Frac>>

Performs the * operation.

impl<Frac> Mul<&u64> for &Unwrapped<FixedU64<Frac>>

type Output = Unwrapped<FixedU64<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: &u64) -> Unwrapped<FixedU64<Frac>>

Performs the * operation.

impl<Frac> Mul<&u64> for Unwrapped<FixedU64<Frac>>

type Output = Unwrapped<FixedU64<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: &u64) -> Unwrapped<FixedU64<Frac>>

Performs the * operation.

impl<Frac> Mul<&u8> for &Unwrapped<FixedU8<Frac>>

type Output = Unwrapped<FixedU8<Frac>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<Frac> Mul<&u8> for Unwrapped<FixedU8<Frac>>

type Output = Unwrapped<FixedU8<Frac>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<F: Fixed> Mul<Unwrapped<F>> for &Unwrapped<F>

type Output = Unwrapped<F>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Unwrapped<F>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<Frac> Mul<i128> for &Unwrapped<FixedI128<Frac>>

type Output = Unwrapped<FixedI128<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: i128) -> Unwrapped<FixedI128<Frac>>

Performs the * operation.

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

type Output = Unwrapped<FixedI128<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: i128) -> Unwrapped<FixedI128<Frac>>

Performs the * operation.

impl<Frac> Mul<i16> for &Unwrapped<FixedI16<Frac>>

type Output = Unwrapped<FixedI16<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: i16) -> Unwrapped<FixedI16<Frac>>

Performs the * operation.

impl<Frac> Mul<i16> for Unwrapped<FixedI16<Frac>>

type Output = Unwrapped<FixedI16<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: i16) -> Unwrapped<FixedI16<Frac>>

Performs the * operation.

impl<Frac> Mul<i32> for &Unwrapped<FixedI32<Frac>>

type Output = Unwrapped<FixedI32<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: i32) -> Unwrapped<FixedI32<Frac>>

Performs the * operation.

impl<Frac> Mul<i32> for Unwrapped<FixedI32<Frac>>

type Output = Unwrapped<FixedI32<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: i32) -> Unwrapped<FixedI32<Frac>>

Performs the * operation.

impl<Frac> Mul<i64> for &Unwrapped<FixedI64<Frac>>

type Output = Unwrapped<FixedI64<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: i64) -> Unwrapped<FixedI64<Frac>>

Performs the * operation.

impl<Frac> Mul<i64> for Unwrapped<FixedI64<Frac>>

type Output = Unwrapped<FixedI64<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: i64) -> Unwrapped<FixedI64<Frac>>

Performs the * operation.

impl<Frac> Mul<i8> for &Unwrapped<FixedI8<Frac>>

type Output = Unwrapped<FixedI8<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: i8) -> Unwrapped<FixedI8<Frac>>

Performs the * operation.

impl<Frac> Mul<i8> for Unwrapped<FixedI8<Frac>>

type Output = Unwrapped<FixedI8<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: i8) -> Unwrapped<FixedI8<Frac>>

Performs the * operation.

impl<Frac> Mul<u128> for &Unwrapped<FixedU128<Frac>>

type Output = Unwrapped<FixedU128<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: u128) -> Unwrapped<FixedU128<Frac>>

Performs the * operation.

impl<Frac> Mul<u128> for Unwrapped<FixedU128<Frac>>

type Output = Unwrapped<FixedU128<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: u128) -> Unwrapped<FixedU128<Frac>>

Performs the * operation.

impl<Frac> Mul<u16> for &Unwrapped<FixedU16<Frac>>

type Output = Unwrapped<FixedU16<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: u16) -> Unwrapped<FixedU16<Frac>>

Performs the * operation.

impl<Frac> Mul<u16> for Unwrapped<FixedU16<Frac>>

type Output = Unwrapped<FixedU16<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: u16) -> Unwrapped<FixedU16<Frac>>

Performs the * operation.

impl<Frac> Mul<u32> for &Unwrapped<FixedU32<Frac>>

type Output = Unwrapped<FixedU32<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: u32) -> Unwrapped<FixedU32<Frac>>

Performs the * operation.

impl<Frac> Mul<u32> for Unwrapped<FixedU32<Frac>>

type Output = Unwrapped<FixedU32<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: u32) -> Unwrapped<FixedU32<Frac>>

Performs the * operation.

impl<Frac> Mul<u64> for &Unwrapped<FixedU64<Frac>>

type Output = Unwrapped<FixedU64<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: u64) -> Unwrapped<FixedU64<Frac>>

Performs the * operation.

impl<Frac> Mul<u64> for Unwrapped<FixedU64<Frac>>

type Output = Unwrapped<FixedU64<Frac>>

The resulting type after applying the * operator.

fn mul(self, other: u64) -> Unwrapped<FixedU64<Frac>>

Performs the * operation.

impl<Frac> Mul<u8> for &Unwrapped<FixedU8<Frac>>

type Output = Unwrapped<FixedU8<Frac>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<Frac> Mul<u8> for Unwrapped<FixedU8<Frac>>

type Output = Unwrapped<FixedU8<Frac>>

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

Performs the *= operation.

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

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

Performs the *= operation.

impl<Frac> MulAssign<&i128> for Unwrapped<FixedI128<Frac>>

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

Performs the *= operation.

impl<Frac> MulAssign<&i16> for Unwrapped<FixedI16<Frac>>

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

Performs the *= operation.

impl<Frac> MulAssign<&i32> for Unwrapped<FixedI32<Frac>>

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

Performs the *= operation.

impl<Frac> MulAssign<&i64> for Unwrapped<FixedI64<Frac>>

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

Performs the *= operation.

impl<Frac> MulAssign<&i8> for Unwrapped<FixedI8<Frac>>

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

Performs the *= operation.

impl<Frac> MulAssign<&u128> for Unwrapped<FixedU128<Frac>>

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

Performs the *= operation.

impl<Frac> MulAssign<&u16> for Unwrapped<FixedU16<Frac>>

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

Performs the *= operation.

impl<Frac> MulAssign<&u32> for Unwrapped<FixedU32<Frac>>

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

Performs the *= operation.

impl<Frac> MulAssign<&u64> for Unwrapped<FixedU64<Frac>>

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

Performs the *= operation.

impl<Frac> MulAssign<&u8> for Unwrapped<FixedU8<Frac>>

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

Performs the *= operation.

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

fn mul_assign(&mut self, other: F)

Performs the *= operation.

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

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

Performs the *= operation.

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

fn mul_assign(&mut self, other: i128)

Performs the *= operation.

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

fn mul_assign(&mut self, other: i16)

Performs the *= operation.

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

fn mul_assign(&mut self, other: i32)

Performs the *= operation.

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

fn mul_assign(&mut self, other: i64)

Performs the *= operation.

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

fn mul_assign(&mut self, other: i8)

Performs the *= operation.

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

fn mul_assign(&mut self, other: u128)

Performs the *= operation.

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

fn mul_assign(&mut self, other: u16)

Performs the *= operation.

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

fn mul_assign(&mut self, other: u32)

Performs the *= operation.

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

fn mul_assign(&mut self, other: u64)

Performs the *= operation.

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

fn mul_assign(&mut self, other: u8)

Performs the *= operation.

impl<F: Fixed> Neg for &Unwrapped<F>

type Output = Unwrapped<F>

The resulting type after applying the - operator.

fn neg(self) -> Unwrapped<F>

Performs the unary - operation.

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

type Output = Unwrapped<F>

The resulting type after applying the - operator.

fn neg(self) -> Unwrapped<F>

Performs the unary - operation.

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

type Output = Unwrapped<F>

The resulting type after applying the ! operator.

fn not(self) -> Unwrapped<F>

Performs the unary ! operation.

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

type Output = Unwrapped<F>

The resulting type after applying the ! operator.

fn not(self) -> Unwrapped<F>

Performs the unary ! operation.

impl<F: Ord> Ord for Unwrapped<F>

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

This method returns an Ordering between self and other.

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

Compares and returns the maximum of two values.

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

Compares and returns the minimum of two values.

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

Restrict a value to a certain interval.

impl<F: PartialEq> PartialEq<Unwrapped<F>> for Unwrapped<F>

fn eq(&self, other: &Unwrapped<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<Unwrapped<F>> for Unwrapped<F>

fn partial_cmp(&self, other: &Unwrapped<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 Unwrapped<F>> for Unwrapped<F>

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

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

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

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

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

impl<F: Fixed> Rem<&Unwrapped<F>> for &Unwrapped<F>

type Output = Unwrapped<F>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<F: Fixed> Rem<&Unwrapped<F>> for Unwrapped<F>

type Output = Unwrapped<F>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<Frac: LeEqU128> Rem<&i128> for &Unwrapped<FixedI128<Frac>>

type Output = Unwrapped<FixedI128<Frac>>

The resulting type after applying the % operator.

fn rem(self, other: &i128) -> Unwrapped<FixedI128<Frac>>

Performs the % operation.

impl<Frac: LeEqU128> Rem<&i128> for Unwrapped<FixedI128<Frac>>

type Output = Unwrapped<FixedI128<Frac>>

The resulting type after applying the % operator.

fn rem(self, other: &i128) -> Unwrapped<FixedI128<Frac>>

Performs the % operation.

impl<Frac: LeEqU16> Rem<&i16> for &Unwrapped<FixedI16<Frac>>

type Output = Unwrapped<FixedI16<Frac>>

The resulting type after applying the % operator.

fn rem(self, other: &i16) -> Unwrapped<FixedI16<Frac>>

Performs the % operation.

impl<Frac: LeEqU16> Rem<&i16> for Unwrapped<FixedI16<Frac>>

type Output = Unwrapped<FixedI16<Frac>>

The resulting type after applying the % operator.

fn rem(self, other: &i16) -> Unwrapped<FixedI16<Frac>>

Performs the % operation.

impl<Frac: LeEqU32> Rem<&i32> for &Unwrapped<FixedI32<Frac>>

type Output = Unwrapped<FixedI32<Frac>>

The resulting type after applying the % operator.

fn rem(self, other: &i32) -> Unwrapped<FixedI32<Frac>>

Performs the % operation.

impl<Frac: LeEqU32> Rem<&i32> for Unwrapped<FixedI32<Frac>>

type Output = Unwrapped<FixedI32<Frac>>

The resulting type after applying the % operator.

fn rem(self, other: &i32) -> Unwrapped<FixedI32<Frac>>

Performs the % operation.

impl<Frac: LeEqU64> Rem<&i64> for &Unwrapped<FixedI64<Frac>>

type Output = Unwrapped<FixedI64<Frac>>

The resulting type after applying the % operator.

fn rem(self, other: &i64) -> Unwrapped<FixedI64<Frac>>

Performs the % operation.

impl<Frac: LeEqU64> Rem<&i64> for Unwrapped<FixedI64<Frac>>

type Output = Unwrapped<FixedI64<Frac>>

The resulting type after applying the % operator.

fn rem(self, other: &i64) -> Unwrapped<FixedI64<Frac>>

Performs the % operation.

impl<Frac: LeEqU8> Rem<&i8> for &Unwrapped<FixedI8<Frac>>

type Output = Unwrapped<FixedI8<Frac>>

The resulting type after applying the % operator.

fn rem(self, other: &i8) -> Unwrapped<FixedI8<Frac>>

Performs the % operation.

impl<Frac: LeEqU8> Rem<&i8> for Unwrapped<FixedI8<Frac>>

type Output = Unwrapped<FixedI8<Frac>>

The resulting type after applying the % operator.

fn rem(self, other: &i8) -> Unwrapped<FixedI8<Frac>>

Performs the % operation.

impl<Frac: LeEqU128> Rem<&u128> for &Unwrapped<FixedU128<Frac>>

type Output = Unwrapped<FixedU128<Frac>>

The resulting type after applying the % operator.

fn rem(self, other: &u128) -> Unwrapped<FixedU128<Frac>>

Performs the % operation.

impl<Frac: LeEqU128> Rem<&u128> for Unwrapped<FixedU128<Frac>>

type Output = Unwrapped<FixedU128<Frac>>

The resulting type after applying the % operator.

fn rem(self, other: &u128) -> Unwrapped<FixedU128<Frac>>

Performs the % operation.

impl<Frac: LeEqU16> Rem<&u16> for &Unwrapped<FixedU16<Frac>>

type Output = Unwrapped<FixedU16<Frac>>

The resulting type after applying the % operator.

fn rem(self, other: &u16) -> Unwrapped<FixedU16<Frac>>

Performs the % operation.

impl<Frac: LeEqU16> Rem<&u16> for Unwrapped<FixedU16<Frac>>

type Output = Unwrapped<FixedU16<Frac>>

The resulting type after applying the % operator.

fn rem(self, other: &u16) -> Unwrapped<FixedU16<Frac>>

Performs the % operation.

impl<Frac: LeEqU32> Rem<&u32> for &Unwrapped<FixedU32<Frac>>

type Output = Unwrapped<FixedU32<Frac>>

The resulting type after applying the % operator.

fn rem(self, other: &u32) -> Unwrapped<FixedU32<Frac>>

Performs the % operation.

impl<Frac: LeEqU32> Rem<&u32> for Unwrapped<FixedU32<Frac>>

type Output = Unwrapped<FixedU32<Frac>>

The resulting type after applying the % operator.

fn rem(self, other: &u32) -> Unwrapped<FixedU32<Frac>>

Performs the % operation.

impl<Frac: LeEqU64> Rem<&u64> for &Unwrapped<FixedU64<Frac>>

type Output = Unwrapped<FixedU64<Frac>>

The resulting type after applying the % operator.

fn rem(self, other: &u64) -> Unwrapped<FixedU64<Frac>>

Performs the % operation.

impl<Frac: LeEqU64> Rem<&u64> for Unwrapped<FixedU64<Frac>>

type Output = Unwrapped<FixedU64<Frac>>

The resulting type after applying the % operator.

fn rem(self, other: &u64) -> Unwrapped<FixedU64<Frac>>

Performs the % operation.

impl<Frac: LeEqU8> Rem<&u8> for &Unwrapped<FixedU8<Frac>>

type Output = Unwrapped<FixedU8<Frac>>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<Frac: LeEqU8> Rem<&u8> for Unwrapped<FixedU8<Frac>>

type Output = Unwrapped<FixedU8<Frac>>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<F: Fixed> Rem<Unwrapped<F>> for &Unwrapped<F>

type Output = Unwrapped<F>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Unwrapped<F>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<Frac: LeEqU128> Rem<i128> for &Unwrapped<FixedI128<Frac>>

type Output = Unwrapped<FixedI128<Frac>>

The resulting type after applying the % operator.

fn rem(self, other: i128) -> Unwrapped<FixedI128<Frac>>

Performs the % operation.

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

type Output = Unwrapped<FixedI128<Frac>>

The resulting type after applying the % operator.

fn rem(self, other: i128) -> Unwrapped<FixedI128<Frac>>

Performs the % operation.

impl<Frac: LeEqU16> Rem<i16> for &Unwrapped<FixedI16<Frac>>

type Output = Unwrapped<FixedI16<Frac>>

The resulting type after applying the % operator.

fn rem(self, other: i16) -> Unwrapped<FixedI16<Frac>>

Performs the % operation.

impl<Frac: LeEqU16> Rem<i16> for Unwrapped<FixedI16<Frac>>

type Output = Unwrapped<FixedI16<Frac>>

The resulting type after applying the % operator.

fn rem(self, other: i16) -> Unwrapped<FixedI16<Frac>>

Performs the % operation.

impl<Frac: LeEqU32> Rem<i32> for &Unwrapped<FixedI32<Frac>>

type Output = Unwrapped<FixedI32<Frac>>

The resulting type after applying the % operator.

fn rem(self, other: i32) -> Unwrapped<FixedI32<Frac>>

Performs the % operation.

impl<Frac: LeEqU32> Rem<i32> for Unwrapped<FixedI32<Frac>>

type Output = Unwrapped<FixedI32<Frac>>

The resulting type after applying the % operator.

fn rem(self, other: i32) -> Unwrapped<FixedI32<Frac>>

Performs the % operation.

impl<Frac: LeEqU64> Rem<i64> for &Unwrapped<FixedI64<Frac>>

type Output = Unwrapped<FixedI64<Frac>>

The resulting type after applying the % operator.

fn rem(self, other: i64) -> Unwrapped<FixedI64<Frac>>

Performs the % operation.

impl<Frac: LeEqU64> Rem<i64> for Unwrapped<FixedI64<Frac>>

type Output = Unwrapped<FixedI64<Frac>>

The resulting type after applying the % operator.

fn rem(self, other: i64) -> Unwrapped<FixedI64<Frac>>

Performs the % operation.

impl<Frac: LeEqU8> Rem<i8> for &Unwrapped<FixedI8<Frac>>

type Output = Unwrapped<FixedI8<Frac>>

The resulting type after applying the % operator.

fn rem(self, other: i8) -> Unwrapped<FixedI8<Frac>>

Performs the % operation.

impl<Frac: LeEqU8> Rem<i8> for Unwrapped<FixedI8<Frac>>

type Output = Unwrapped<FixedI8<Frac>>

The resulting type after applying the % operator.

fn rem(self, other: i8) -> Unwrapped<FixedI8<Frac>>

Performs the % operation.

impl<Frac: LeEqU128> Rem<u128> for &Unwrapped<FixedU128<Frac>>

type Output = Unwrapped<FixedU128<Frac>>

The resulting type after applying the % operator.

fn rem(self, other: u128) -> Unwrapped<FixedU128<Frac>>

Performs the % operation.

impl<Frac: LeEqU128> Rem<u128> for Unwrapped<FixedU128<Frac>>

type Output = Unwrapped<FixedU128<Frac>>

The resulting type after applying the % operator.

fn rem(self, other: u128) -> Unwrapped<FixedU128<Frac>>

Performs the % operation.

impl<Frac: LeEqU16> Rem<u16> for &Unwrapped<FixedU16<Frac>>

type Output = Unwrapped<FixedU16<Frac>>

The resulting type after applying the % operator.

fn rem(self, other: u16) -> Unwrapped<FixedU16<Frac>>

Performs the % operation.

impl<Frac: LeEqU16> Rem<u16> for Unwrapped<FixedU16<Frac>>

type Output = Unwrapped<FixedU16<Frac>>

The resulting type after applying the % operator.

fn rem(self, other: u16) -> Unwrapped<FixedU16<Frac>>

Performs the % operation.

impl<Frac: LeEqU32> Rem<u32> for &Unwrapped<FixedU32<Frac>>

type Output = Unwrapped<FixedU32<Frac>>

The resulting type after applying the % operator.

fn rem(self, other: u32) -> Unwrapped<FixedU32<Frac>>

Performs the % operation.

impl<Frac: LeEqU32> Rem<u32> for Unwrapped<FixedU32<Frac>>

type Output = Unwrapped<FixedU32<Frac>>

The resulting type after applying the % operator.

fn rem(self, other: u32) -> Unwrapped<FixedU32<Frac>>

Performs the % operation.

impl<Frac: LeEqU64> Rem<u64> for &Unwrapped<FixedU64<Frac>>

type Output = Unwrapped<FixedU64<Frac>>

The resulting type after applying the % operator.

fn rem(self, other: u64) -> Unwrapped<FixedU64<Frac>>

Performs the % operation.

impl<Frac: LeEqU64> Rem<u64> for Unwrapped<FixedU64<Frac>>

type Output = Unwrapped<FixedU64<Frac>>

The resulting type after applying the % operator.

fn rem(self, other: u64) -> Unwrapped<FixedU64<Frac>>

Performs the % operation.

impl<Frac: LeEqU8> Rem<u8> for &Unwrapped<FixedU8<Frac>>

type Output = Unwrapped<FixedU8<Frac>>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<Frac: LeEqU8> Rem<u8> for Unwrapped<FixedU8<Frac>>

type Output = Unwrapped<FixedU8<Frac>>

The resulting type after applying the % operator.

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

Performs the % operation.

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

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

Performs the %= operation.

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

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

Performs the %= operation.

impl<Frac: LeEqU128> RemAssign<&i128> for Unwrapped<FixedI128<Frac>>

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

Performs the %= operation.

impl<Frac: LeEqU16> RemAssign<&i16> for Unwrapped<FixedI16<Frac>>

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

Performs the %= operation.

impl<Frac: LeEqU32> RemAssign<&i32> for Unwrapped<FixedI32<Frac>>

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

Performs the %= operation.

impl<Frac: LeEqU64> RemAssign<&i64> for Unwrapped<FixedI64<Frac>>

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

Performs the %= operation.

impl<Frac: LeEqU8> RemAssign<&i8> for Unwrapped<FixedI8<Frac>>

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

Performs the %= operation.

impl<Frac: LeEqU128> RemAssign<&u128> for Unwrapped<FixedU128<Frac>>

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

Performs the %= operation.

impl<Frac: LeEqU16> RemAssign<&u16> for Unwrapped<FixedU16<Frac>>

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

Performs the %= operation.

impl<Frac: LeEqU32> RemAssign<&u32> for Unwrapped<FixedU32<Frac>>

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

Performs the %= operation.

impl<Frac: LeEqU64> RemAssign<&u64> for Unwrapped<FixedU64<Frac>>

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

Performs the %= operation.

impl<Frac: LeEqU8> RemAssign<&u8> for Unwrapped<FixedU8<Frac>>

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

Performs the %= operation.

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

fn rem_assign(&mut self, other: F)

Performs the %= operation.

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

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

Performs the %= operation.

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

fn rem_assign(&mut self, other: i128)

Performs the %= operation.

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

fn rem_assign(&mut self, other: i16)

Performs the %= operation.

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

fn rem_assign(&mut self, other: i32)

Performs the %= operation.

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

fn rem_assign(&mut self, other: i64)

Performs the %= operation.

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

fn rem_assign(&mut self, other: i8)

Performs the %= operation.

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

fn rem_assign(&mut self, other: u128)

Performs the %= operation.

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

fn rem_assign(&mut self, other: u16)

Performs the %= operation.

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

fn rem_assign(&mut self, other: u32)

Performs the %= operation.

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

fn rem_assign(&mut self, other: u64)

Performs the %= operation.

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

fn rem_assign(&mut self, other: u8)

Performs the %= operation.

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

type Output = Unwrapped<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Unwrapped<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Unwrapped<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Unwrapped<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Unwrapped<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Unwrapped<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Unwrapped<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Unwrapped<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Unwrapped<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Unwrapped<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Unwrapped<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Unwrapped<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Unwrapped<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Unwrapped<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Unwrapped<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Unwrapped<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Unwrapped<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Unwrapped<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Unwrapped<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Unwrapped<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Unwrapped<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Unwrapped<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Unwrapped<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Unwrapped<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Unwrapped<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Unwrapped<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Unwrapped<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Unwrapped<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Unwrapped<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Unwrapped<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Unwrapped<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Unwrapped<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Unwrapped<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Unwrapped<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Unwrapped<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Unwrapped<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Unwrapped<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Unwrapped<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Unwrapped<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Unwrapped<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Unwrapped<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Unwrapped<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Unwrapped<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Unwrapped<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Unwrapped<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Unwrapped<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Unwrapped<F>

The resulting type after applying the << operator.

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

Performs the << operation.

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

type Output = Unwrapped<F>

The resulting type after applying the << operator.

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

Performs the << operation.

impl<F> ShlAssign<&i128> for Unwrapped<F>where
    F: ShlAssign<u32>,

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

Performs the <<= operation.

impl<F> ShlAssign<&i16> for Unwrapped<F>where
    F: ShlAssign<u32>,

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

Performs the <<= operation.

impl<F> ShlAssign<&i32> for Unwrapped<F>where
    F: ShlAssign<u32>,

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

Performs the <<= operation.

impl<F> ShlAssign<&i64> for Unwrapped<F>where
    F: ShlAssign<u32>,

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

Performs the <<= operation.

impl<F> ShlAssign<&i8> for Unwrapped<F>where
    F: ShlAssign<u32>,

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

Performs the <<= operation.

impl<F> ShlAssign<&isize> for Unwrapped<F>where
    F: ShlAssign<u32>,

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

Performs the <<= operation.

impl<F> ShlAssign<&u128> for Unwrapped<F>where
    F: ShlAssign<u32>,

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

Performs the <<= operation.

impl<F> ShlAssign<&u16> for Unwrapped<F>where
    F: ShlAssign<u32>,

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

Performs the <<= operation.

impl<F> ShlAssign<&u32> for Unwrapped<F>where
    F: ShlAssign<u32>,

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

Performs the <<= operation.

impl<F> ShlAssign<&u64> for Unwrapped<F>where
    F: ShlAssign<u32>,

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

Performs the <<= operation.

impl<F> ShlAssign<&u8> for Unwrapped<F>where
    F: ShlAssign<u32>,

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

Performs the <<= operation.

impl<F> ShlAssign<&usize> for Unwrapped<F>where
    F: ShlAssign<u32>,

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

Performs the <<= operation.

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

fn shl_assign(&mut self, other: i128)

Performs the <<= operation.

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

fn shl_assign(&mut self, other: i16)

Performs the <<= operation.

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

fn shl_assign(&mut self, other: i32)

Performs the <<= operation.

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

fn shl_assign(&mut self, other: i64)

Performs the <<= operation.

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

fn shl_assign(&mut self, other: i8)

Performs the <<= operation.

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

fn shl_assign(&mut self, other: isize)

Performs the <<= operation.

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

fn shl_assign(&mut self, other: u128)

Performs the <<= operation.

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

fn shl_assign(&mut self, other: u16)

Performs the <<= operation.

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

fn shl_assign(&mut self, other: u32)

Performs the <<= operation.

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

fn shl_assign(&mut self, other: u64)

Performs the <<= operation.

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

fn shl_assign(&mut self, other: u8)

Performs the <<= operation.

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

fn shl_assign(&mut self, other: usize)

Performs the <<= operation.

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

type Output = Unwrapped<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Unwrapped<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Unwrapped<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Unwrapped<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Unwrapped<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Unwrapped<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Unwrapped<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Unwrapped<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Unwrapped<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Unwrapped<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Unwrapped<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Unwrapped<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Unwrapped<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Unwrapped<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Unwrapped<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Unwrapped<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Unwrapped<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Unwrapped<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Unwrapped<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Unwrapped<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Unwrapped<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Unwrapped<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Unwrapped<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Unwrapped<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Unwrapped<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Unwrapped<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Unwrapped<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Unwrapped<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Unwrapped<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Unwrapped<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Unwrapped<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Unwrapped<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Unwrapped<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Unwrapped<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Unwrapped<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Unwrapped<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Unwrapped<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Unwrapped<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Unwrapped<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Unwrapped<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Unwrapped<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Unwrapped<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Unwrapped<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Unwrapped<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Unwrapped<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Unwrapped<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Unwrapped<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

type Output = Unwrapped<F>

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl<F> ShrAssign<&i128> for Unwrapped<F>where
    F: ShrAssign<u32>,

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

Performs the >>= operation.

impl<F> ShrAssign<&i16> for Unwrapped<F>where
    F: ShrAssign<u32>,

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

Performs the >>= operation.

impl<F> ShrAssign<&i32> for Unwrapped<F>where
    F: ShrAssign<u32>,

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

Performs the >>= operation.

impl<F> ShrAssign<&i64> for Unwrapped<F>where
    F: ShrAssign<u32>,

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

Performs the >>= operation.

impl<F> ShrAssign<&i8> for Unwrapped<F>where
    F: ShrAssign<u32>,

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

Performs the >>= operation.

impl<F> ShrAssign<&isize> for Unwrapped<F>where
    F: ShrAssign<u32>,

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

Performs the >>= operation.

impl<F> ShrAssign<&u128> for Unwrapped<F>where
    F: ShrAssign<u32>,

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

Performs the >>= operation.

impl<F> ShrAssign<&u16> for Unwrapped<F>where
    F: ShrAssign<u32>,

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

Performs the >>= operation.

impl<F> ShrAssign<&u32> for Unwrapped<F>where
    F: ShrAssign<u32>,

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

Performs the >>= operation.

impl<F> ShrAssign<&u64> for Unwrapped<F>where
    F: ShrAssign<u32>,

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

Performs the >>= operation.

impl<F> ShrAssign<&u8> for Unwrapped<F>where
    F: ShrAssign<u32>,

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

Performs the >>= operation.

impl<F> ShrAssign<&usize> for Unwrapped<F>where
    F: ShrAssign<u32>,

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

Performs the >>= operation.

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

fn shr_assign(&mut self, other: i128)

Performs the >>= operation.

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

fn shr_assign(&mut self, other: i16)

Performs the >>= operation.

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

fn shr_assign(&mut self, other: i32)

Performs the >>= operation.

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

fn shr_assign(&mut self, other: i64)

Performs the >>= operation.

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

fn shr_assign(&mut self, other: i8)

Performs the >>= operation.

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

fn shr_assign(&mut self, other: isize)

Performs the >>= operation.

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

fn shr_assign(&mut self, other: u128)

Performs the >>= operation.

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

fn shr_assign(&mut self, other: u16)

Performs the >>= operation.

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

fn shr_assign(&mut self, other: u32)

Performs the >>= operation.

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

fn shr_assign(&mut self, other: u64)

Performs the >>= operation.

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

fn shr_assign(&mut self, other: u8)

Performs the >>= operation.

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

fn shr_assign(&mut self, other: usize)

Performs the >>= operation.

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

type Output = Unwrapped<F>

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = Unwrapped<F>

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = Unwrapped<F>

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = Unwrapped<F>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<F: Fixed> SubAssign<&F> for Unwrapped<F>

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

Performs the -= operation.

impl<F: Fixed> SubAssign<&Unwrapped<F>> for Unwrapped<F>

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

Performs the -= operation.

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

fn sub_assign(&mut self, other: F)

Performs the -= operation.

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

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

Performs the -= operation.

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

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

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

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

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

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

impl<Frac: LeEqU128> TransparentWrapper<FixedI128<Frac>> for Unwrapped<FixedI128<Frac>>

fn wrap(s: Inner) -> Selfwhere
    Self: Sized,

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

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

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

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

fn peel(s: Self) -> Innerwhere
    Self: Sized,

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

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

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

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

impl<Frac: LeEqU16> TransparentWrapper<FixedI16<Frac>> for Unwrapped<FixedI16<Frac>>

fn wrap(s: Inner) -> Selfwhere
    Self: Sized,

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

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

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

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

fn peel(s: Self) -> Innerwhere
    Self: Sized,

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

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

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

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

impl<Frac: LeEqU32> TransparentWrapper<FixedI32<Frac>> for Unwrapped<FixedI32<Frac>>

fn wrap(s: Inner) -> Selfwhere
    Self: Sized,

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

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

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

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

fn peel(s: Self) -> Innerwhere
    Self: Sized,

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

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

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

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

impl<Frac: LeEqU64> TransparentWrapper<FixedI64<Frac>> for Unwrapped<FixedI64<Frac>>

fn wrap(s: Inner) -> Selfwhere
    Self: Sized,

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

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

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

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

fn peel(s: Self) -> Innerwhere
    Self: Sized,

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

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

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

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

impl<Frac: LeEqU8> TransparentWrapper<FixedI8<Frac>> for Unwrapped<FixedI8<Frac>>

fn wrap(s: Inner) -> Selfwhere
    Self: Sized,

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

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

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

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

fn peel(s: Self) -> Innerwhere
    Self: Sized,

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

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

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

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

impl<Frac: LeEqU128> TransparentWrapper<FixedU128<Frac>> for Unwrapped<FixedU128<Frac>>

fn wrap(s: Inner) -> Selfwhere
    Self: Sized,

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

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

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

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

fn peel(s: Self) -> Innerwhere
    Self: Sized,

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

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

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

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

impl<Frac: LeEqU16> TransparentWrapper<FixedU16<Frac>> for Unwrapped<FixedU16<Frac>>

fn wrap(s: Inner) -> Selfwhere
    Self: Sized,

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

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

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

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

fn peel(s: Self) -> Innerwhere
    Self: Sized,

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

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

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

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

impl<Frac: LeEqU32> TransparentWrapper<FixedU32<Frac>> for Unwrapped<FixedU32<Frac>>

fn wrap(s: Inner) -> Selfwhere
    Self: Sized,

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

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

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

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

fn peel(s: Self) -> Innerwhere
    Self: Sized,

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

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

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

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

impl<Frac: LeEqU64> TransparentWrapper<FixedU64<Frac>> for Unwrapped<FixedU64<Frac>>

fn wrap(s: Inner) -> Selfwhere
    Self: Sized,

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

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

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

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

fn peel(s: Self) -> Innerwhere
    Self: Sized,

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

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

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

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

impl<Frac: LeEqU8> TransparentWrapper<FixedU8<Frac>> for Unwrapped<FixedU8<Frac>>

fn wrap(s: Inner) -> Selfwhere
    Self: Sized,

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

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

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

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

fn peel(s: Self) -> Innerwhere
    Self: Sized,

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

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

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

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

impl<Frac: LeEqU128> Zeroable for Unwrapped<FixedI128<Frac>>

fn zeroed() -> Self

Calls zeroed.

impl<Frac: LeEqU16> Zeroable for Unwrapped<FixedI16<Frac>>

fn zeroed() -> Self

Calls zeroed.

impl<Frac: LeEqU32> Zeroable for Unwrapped<FixedI32<Frac>>

fn zeroed() -> Self

Calls zeroed.

impl<Frac: LeEqU64> Zeroable for Unwrapped<FixedI64<Frac>>

fn zeroed() -> Self

Calls zeroed.

impl<Frac: LeEqU8> Zeroable for Unwrapped<FixedI8<Frac>>

fn zeroed() -> Self

Calls zeroed.

impl<Frac: LeEqU128> Zeroable for Unwrapped<FixedU128<Frac>>

fn zeroed() -> Self

Calls zeroed.

impl<Frac: LeEqU16> Zeroable for Unwrapped<FixedU16<Frac>>

fn zeroed() -> Self

Calls zeroed.

impl<Frac: LeEqU32> Zeroable for Unwrapped<FixedU32<Frac>>

fn zeroed() -> Self

Calls zeroed.

impl<Frac: LeEqU64> Zeroable for Unwrapped<FixedU64<Frac>>

fn zeroed() -> Self

Calls zeroed.

impl<Frac: LeEqU8> Zeroable for Unwrapped<FixedU8<Frac>>

fn zeroed() -> Self

Calls zeroed.

impl<F: Copy> Copy for Unwrapped<F>

impl<F: Eq> Eq for Unwrapped<F>

impl<Frac: LeEqU128> Pod for Unwrapped<FixedI128<Frac>>

impl<Frac: LeEqU16> Pod for Unwrapped<FixedI16<Frac>>

impl<Frac: LeEqU32> Pod for Unwrapped<FixedI32<Frac>>

impl<Frac: LeEqU64> Pod for Unwrapped<FixedI64<Frac>>

impl<Frac: LeEqU8> Pod for Unwrapped<FixedI8<Frac>>

impl<Frac: LeEqU128> Pod for Unwrapped<FixedU128<Frac>>

impl<Frac: LeEqU16> Pod for Unwrapped<FixedU16<Frac>>

impl<Frac: LeEqU32> Pod for Unwrapped<FixedU32<Frac>>

impl<Frac: LeEqU64> Pod for Unwrapped<FixedU64<Frac>>

impl<Frac: LeEqU8> Pod for Unwrapped<FixedU8<Frac>>

impl<F> StructuralEq for Unwrapped<F>

impl<F> StructuralPartialEq for Unwrapped<F>