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 F128. For this conversion, the method rounds to the nearest, with ties rounding to even.
• Any other number src for which ToFixed is implemented, in which case this method returns 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 F128. For this conversion, the method rounds to the nearest, with ties rounding to even.
• Any other type Dst for which FromFixed is implemented, in which case this method returns Dst::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_dec(src: &str) -> Unwrapped<F>

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

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

See also FixedI32::unwrapped_from_str and FixedU32::unwrapped_from_str.

Panics

Panics if the value does not fit or if there is a parsing error.

Examples

use fixed::{types::I8F8, Unwrapped};
// 16 + 3/4 = 16.75
let check = Unwrapped(I8F8::from_bits((16 << 8) + (3 << 8) / 4));
assert_eq!(Unwrapped::<I8F8>::from_str_dec("16.75"), check);

The following panics because of a parsing error.

use fixed::{types::I8F8, Unwrapped};
let _error = Unwrapped::<I8F8>::from_str_dec("1.2.");

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

Panics

Panics if the value does not fit or if there is a parsing error.

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

The following panics because of a parsing error.

use fixed::{types::I8F8, Unwrapped};
let _error = Unwrapped::<I8F8>::from_str_binary("1.2");

Compatibility note

This method either returns Ok or panics, and never returns Err. In version 2, this method will not return a Result, but will return the fixed-point number directly similarly to from_str_dec.

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

Panics

Panics if the value does not fit or if there is a parsing error.

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

The following panics because of a parsing error.

use fixed::{types::I8F8, Unwrapped};
let _error = Unwrapped::<I8F8>::from_str_octal("1.8");

Compatibility note

This method either returns Ok or panics, and never returns Err. In version 2, this method will not return a Result, but will return the fixed-point number directly similarly to from_str_dec.

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

Panics

Panics if the value does not fit or if there is a parsing error.

Examples

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

The following panics because of a parsing error.

use fixed::{types::I8F8, Unwrapped};
let _error = Unwrapped::<I8F8>::from_str_hex("1.G");

Compatibility note

This method either returns Ok or panics, and never returns Err. In version 2, this method will not return a Result, but will return the fixed-point number directly similarly to from_str_dec.

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 sqrt(self) -> Self

Returns the square root.

See also FixedI32::unwrapped_sqrt and FixedU32::unwrapped_sqrt.

Panics

Panics if the number is negative, or on overflow.

Examples

use fixed::{types::I0F32, Unwrapped};
assert_eq!(Unwrapped(I0F32::lit("0b0.0001")).sqrt().0, I0F32::lit("0b0.01"));

The following panics because the input value is negative.

use fixed::{types::I16F16, Unwrapped};
let neg = Unwrapped(I16F16::from_num(-1));
let _sqrt_neg = neg.sqrt();

The following panics because of overflow.

use fixed::{types::I0F32, Unwrapped};
let u = Unwrapped(I0F32::from_num(0.25));
let _overflow = u.sqrt();

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 int_log(self, base: u32) -> i32

Integer logarithm to the specified base, rounded down.

See also FixedI32::int_log and FixedU32::int_log.

Panics

Panics if the fixed-point number is ≤ 0 or if the base is < 2.

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 hypot(self, other: Unwrapped<F>) -> Unwrapped<F>

Compute the hypotenuse of a right triange.

See also FixedI32::unwrapped_hypot and FixedU32::unwrapped_hypot.

Examples

use fixed::{types::I8F8, Unwrapped};
type Unwr = Unwrapped<I8F8>;
// hypot(3, 4) == 5
assert_eq!(Unwr::from_num(3).hypot(Unwr::from_num(4)), Unwr::from_num(5));

The following panics because of overflow.

use fixed::{types::I8F8, Unwrapped};
type Unwr = Unwrapped<I8F8>;
// hypot(88, 105) == 137, which does not fit
let _overflow = Unwr::from_num(88).hypot(Unwr::from_num(105));

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 add_prod(self, a: Unwrapped<F>, b: Unwrapped<F>) -> Unwrapped<F>

Adds self to the product a × b.

See also FixedI32::unwrapped_add_prod and FixedU32::unwrapped_add_prod.

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.add_prod(four, half), Unwrapped(I16F16::from_num(5)));

The following panics because of overflow.

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

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::NEG_ONE));
assert_eq!(Unwrapped(<I16F16>::ZERO).signum(), Unwrapped(I16F16::ZERO));
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 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 for Unwrapped<F>

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

Performs the += operation.

impl<'a, Frac: LeEqU128> Arbitrary<'a> for Unwrapped<FixedI128<Frac>>

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

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

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

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

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

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

impl<'a, Frac: LeEqU16> Arbitrary<'a> for Unwrapped<FixedI16<Frac>>

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

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

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

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

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

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

impl<'a, Frac: LeEqU32> Arbitrary<'a> for Unwrapped<FixedI32<Frac>>

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

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

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

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

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

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

impl<'a, Frac: LeEqU64> Arbitrary<'a> for Unwrapped<FixedI64<Frac>>

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

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

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

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

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

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

impl<'a, Frac: LeEqU8> Arbitrary<'a> for Unwrapped<FixedI8<Frac>>

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

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

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

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

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

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

impl<'a, Frac: LeEqU128> Arbitrary<'a> for Unwrapped<FixedU128<Frac>>

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

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

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

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

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

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

impl<'a, Frac: LeEqU16> Arbitrary<'a> for Unwrapped<FixedU16<Frac>>

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

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

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

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

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

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

impl<'a, Frac: LeEqU32> Arbitrary<'a> for Unwrapped<FixedU32<Frac>>

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

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

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

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

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

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

impl<'a, Frac: LeEqU64> Arbitrary<'a> for Unwrapped<FixedU64<Frac>>

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

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

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

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

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

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

impl<'a, Frac: LeEqU8> Arbitrary<'a> for Unwrapped<FixedU8<Frac>>

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

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

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

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

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

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

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

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

Formats the value using the given formatter.

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 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 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 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 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 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 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<Frac: LeEqU128> Contiguous for Unwrapped<FixedI128<Frac>>

type Int = i128

The primitive integer type with an identical representation to this type.

const MAX_VALUE: i128 = 170_141_183_460_469_231_731_687_303_715_884_105_727i128

The upper inclusive bound for valid instances of this type.

const MIN_VALUE: i128 = -170_141_183_460_469_231_731_687_303_715_884_105_728i128

The lower inclusive bound for valid instances of this type.

fn from_integer(value: Self::Int) -> Option<Self>

If value is within the range for valid instances of this type, returns Some(converted_value), otherwise, returns None.

fn into_integer(self) -> Self::Int

Perform the conversion from C into the underlying integral type. This mostly exists otherwise generic code would need unsafe for the value as integer

impl<Frac: LeEqU16> Contiguous for Unwrapped<FixedI16<Frac>>

type Int = i16

The primitive integer type with an identical representation to this type.

const MAX_VALUE: i16 = 32_767i16

The upper inclusive bound for valid instances of this type.

const MIN_VALUE: i16 = -32_768i16

The lower inclusive bound for valid instances of this type.

fn from_integer(value: Self::Int) -> Option<Self>

If value is within the range for valid instances of this type, returns Some(converted_value), otherwise, returns None.

fn into_integer(self) -> Self::Int

Perform the conversion from C into the underlying integral type. This mostly exists otherwise generic code would need unsafe for the value as integer

impl<Frac: LeEqU32> Contiguous for Unwrapped<FixedI32<Frac>>

type Int = i32

The primitive integer type with an identical representation to this type.

const MAX_VALUE: i32 = 2_147_483_647i32

The upper inclusive bound for valid instances of this type.

const MIN_VALUE: i32 = -2_147_483_648i32

The lower inclusive bound for valid instances of this type.

fn from_integer(value: Self::Int) -> Option<Self>

If value is within the range for valid instances of this type, returns Some(converted_value), otherwise, returns None.

fn into_integer(self) -> Self::Int

Perform the conversion from C into the underlying integral type. This mostly exists otherwise generic code would need unsafe for the value as integer

impl<Frac: LeEqU64> Contiguous for Unwrapped<FixedI64<Frac>>

type Int = i64

The primitive integer type with an identical representation to this type.

const MAX_VALUE: i64 = 9_223_372_036_854_775_807i64

The upper inclusive bound for valid instances of this type.

const MIN_VALUE: i64 = -9_223_372_036_854_775_808i64

The lower inclusive bound for valid instances of this type.

fn from_integer(value: Self::Int) -> Option<Self>

If value is within the range for valid instances of this type, returns Some(converted_value), otherwise, returns None.

fn into_integer(self) -> Self::Int

Perform the conversion from C into the underlying integral type. This mostly exists otherwise generic code would need unsafe for the value as integer

impl<Frac: LeEqU8> Contiguous for Unwrapped<FixedI8<Frac>>

type Int = i8

The primitive integer type with an identical representation to this type.

const MAX_VALUE: i8 = 127i8

The upper inclusive bound for valid instances of this type.

const MIN_VALUE: i8 = -128i8

The lower inclusive bound for valid instances of this type.

fn from_integer(value: Self::Int) -> Option<Self>

If value is within the range for valid instances of this type, returns Some(converted_value), otherwise, returns None.

fn into_integer(self) -> Self::Int

Perform the conversion from C into the underlying integral type. This mostly exists otherwise generic code would need unsafe for the value as integer

impl<Frac: LeEqU128> Contiguous for Unwrapped<FixedU128<Frac>>

type Int = u128

The primitive integer type with an identical representation to this type.

const MAX_VALUE: u128 = 340_282_366_920_938_463_463_374_607_431_768_211_455u128

The upper inclusive bound for valid instances of this type.

const MIN_VALUE: u128 = 0u128

The lower inclusive bound for valid instances of this type.

fn from_integer(value: Self::Int) -> Option<Self>

If value is within the range for valid instances of this type, returns Some(converted_value), otherwise, returns None.

fn into_integer(self) -> Self::Int

Perform the conversion from C into the underlying integral type. This mostly exists otherwise generic code would need unsafe for the value as integer

impl<Frac: LeEqU16> Contiguous for Unwrapped<FixedU16<Frac>>

type Int = u16

The primitive integer type with an identical representation to this type.

const MAX_VALUE: u16 = 65_535u16

The upper inclusive bound for valid instances of this type.

const MIN_VALUE: u16 = 0u16

The lower inclusive bound for valid instances of this type.

fn from_integer(value: Self::Int) -> Option<Self>

If value is within the range for valid instances of this type, returns Some(converted_value), otherwise, returns None.

fn into_integer(self) -> Self::Int

Perform the conversion from C into the underlying integral type. This mostly exists otherwise generic code would need unsafe for the value as integer

impl<Frac: LeEqU32> Contiguous for Unwrapped<FixedU32<Frac>>

type Int = u32

The primitive integer type with an identical representation to this type.

const MAX_VALUE: u32 = 4_294_967_295u32

The upper inclusive bound for valid instances of this type.

const MIN_VALUE: u32 = 0u32

The lower inclusive bound for valid instances of this type.

fn from_integer(value: Self::Int) -> Option<Self>

If value is within the range for valid instances of this type, returns Some(converted_value), otherwise, returns None.

fn into_integer(self) -> Self::Int

Perform the conversion from C into the underlying integral type. This mostly exists otherwise generic code would need unsafe for the value as integer

impl<Frac: LeEqU64> Contiguous for Unwrapped<FixedU64<Frac>>

type Int = u64

The primitive integer type with an identical representation to this type.

const MAX_VALUE: u64 = 18_446_744_073_709_551_615u64

The upper inclusive bound for valid instances of this type.

const MIN_VALUE: u64 = 0u64

The lower inclusive bound for valid instances of this type.

fn from_integer(value: Self::Int) -> Option<Self>

If value is within the range for valid instances of this type, returns Some(converted_value), otherwise, returns None.

fn into_integer(self) -> Self::Int

Perform the conversion from C into the underlying integral type. This mostly exists otherwise generic code would need unsafe for the value as integer

impl<Frac: LeEqU8> Contiguous for Unwrapped<FixedU8<Frac>>

type Int = u8

The primitive integer type with an identical representation to this type.

const MAX_VALUE: u8 = 255u8

The upper inclusive bound for valid instances of this type.

const MIN_VALUE: u8 = 0u8

The lower inclusive bound for valid instances of this type.

fn from_integer(value: Self::Int) -> Option<Self>

If value is within the range for valid instances of this type, returns Some(converted_value), otherwise, returns None.

fn into_integer(self) -> Self::Int

Perform the conversion from C into the underlying integral type. This mostly exists otherwise generic code would need unsafe for the value as integer

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<'de, Frac: LeEqU128> Deserialize<'de> for Unwrapped<FixedI128<Frac>>

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

Deserialize this value from the given Serde deserializer.

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

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

Deserialize this value from the given Serde deserializer.

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

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

Deserialize this value from the given Serde deserializer.

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

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

Deserialize this value from the given Serde deserializer.

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

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

Deserialize this value from the given Serde deserializer.

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

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

Deserialize this value from the given Serde deserializer.

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

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

Deserialize this value from the given Serde deserializer.

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

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

Deserialize this value from the given Serde deserializer.

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

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

Deserialize this value from the given Serde deserializer.

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

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

Deserialize this value from the given Serde deserializer.

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

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

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.

This method either returns Ok or panics, and never returns Err. The inherent method Unwrapped<F>::from_str_dec returns the value directly instead of a Result.

Panics

Panics if the value does not fit or if there is a parsing error.

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> LowerExp for Unwrapped<F>

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

Formats the value using the given formatter.

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

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

Formats the value using the given formatter.

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<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 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> 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<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 for Unwrapped<F>

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

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

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

Formats the value using the given formatter.

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

where Self: Sized,

Compares and returns the maximum of two values.

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

where Self: Sized,

Compares and returns the minimum of two values.

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

where Self: Sized + PartialOrd,

Restrict a value to a certain interval.

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

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

Performs the %= operation.

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

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

Serialize this value into the given Serde serializer.

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

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

Serialize this value into the given Serde serializer.

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

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

Serialize this value into the given Serde serializer.

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

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

Serialize this value into the given Serde serializer.

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

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

Serialize this value into the given Serde serializer.

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

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

Serialize this value into the given Serde serializer.

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

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

Serialize this value into the given Serde serializer.

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

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

Serialize this value into the given Serde serializer.

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

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

Serialize this value into the given Serde serializer.

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

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

Serialize this value into the given Serde serializer.

impl<F> Shl<&i128> for &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 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 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 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) -> Self

where 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) -> Inner

where 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) -> Self

where 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) -> Inner

where 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) -> Self

where 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) -> Inner

where 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) -> Self

where 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) -> Inner

where 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) -> Self

where 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) -> Inner

where 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) -> Self

where 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) -> Inner

where 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) -> Self

where 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) -> Inner

where 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) -> Self

where 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) -> Inner

where 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) -> Self

where 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) -> Inner

where 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) -> Self

where 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) -> Inner

where 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<F: Fixed> UpperExp for Unwrapped<F>

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

Formats the value using the given formatter.

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

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

Formats the value using the given formatter.

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> StructuralPartialEq for Unwrapped<F>