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::from_bits(1));
let _overflow = max + delta;

Implementations

impl<F: Fixed> Unwrapped<F>

pub const MIN: Unwrapped<F>

The smallest value that can be represented.

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.

Examples

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

pub const INT_NBITS: u32

The number of integer bits.

Examples

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

pub const FRAC_NBITS: u32

The number of fractional bits.

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.

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.

Examples

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

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 f32 or f64. If the f16 feature is enabled, it can also be of type f16 or bf16. For this conversion, the method rounds to the nearest, with ties rounding to even.
• Any other number src for which ToFixed is implemented.

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 f32 or f64. If the f16 feature is enabled, it can also be of type f16 or bf16. For this conversion, the method rounds to the nearest, with ties rounding to even.
• Any other type Dst for which FromFixed is implemented.

Examples

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

The following panics even when debug assertions are disabled.

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

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

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

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

Examples

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

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

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

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

Examples

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

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

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

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

Examples

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

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

Returns the integer part.

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

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

Examples

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

pub fn int_log2(self) -> i32

Integer base-2 logarithm, rounded down.

Panics

Panics if the fixed-point number is ≤ 0.

pub fn int_log10(self) -> i32

Integer base-10 logarithm, rounded down.

Panics

Panics if the fixed-point number is ≤ 0.

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

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

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.

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 recip(self) -> Unwrapped<F>

Returns the reciprocal (inverse), 1/self.

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::from_num(1) / 512);
let _overflow = frac_1_512.recip();

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

Multiply and add. Returns self × 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)));

The following panics because of overflow.

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

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

Euclidean division.

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.

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.

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.

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

impl<F: FixedSigned> Unwrapped<F>

pub fn is_positive(self) -> bool

Returns true if the number is > 0.

Examples

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

pub fn is_negative(self) -> bool

Returns true if the number is < 0.

Examples

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

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.

Panics

Panics

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

Examples

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

The following panics because of overflow.

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

impl<F: FixedUnsigned> Unwrapped<F>

pub fn is_power_of_two(self) -> bool

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

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 next_power_of_two(self) -> Unwrapped<F>

Returns the smallest power of two that is ≥ self.

Panics

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

Examples

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

The following panics because of overflow.

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

Trait Implementations

impl<F: Fixed, '_> Add<&'_ Unwrapped<F>> for Unwrapped<F>

type Output = Unwrapped<F>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<F: Fixed, '_, '_> Add<&'_ Unwrapped<F>> for &'_ Unwrapped<F>

type Output = Unwrapped<F>

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = Unwrapped<F>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<F: Fixed, '_> Add<Unwrapped<F>> for &'_ Unwrapped<F>

type Output = Unwrapped<F>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<F: Fixed, '_> AddAssign<&'_ Unwrapped<F>> for Unwrapped<F>

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

Performs the += operation.

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

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

Performs the += operation.

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

type Output = Unwrapped<F>

The resulting type after applying the & operator.

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

Performs the & operation.

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

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

Performs the &= operation.

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

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

Performs the &= operation.

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

type Output = Unwrapped<F>

The resulting type after applying the | operator.

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

Performs the | operation.

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

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

Performs the |= operation.

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

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

Performs the |= operation.

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

type Output = Unwrapped<F>

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

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

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

Performs the ^= operation.

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

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

Performs the ^= operation.

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

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<F: Copy> Copy for Unwrapped<F>

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

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

Formats the value using the given formatter.

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

fn default() -> Unwrapped<F>

Returns the "default value" for a type.

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

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

Formats the value using the given formatter.

impl<F: Fixed, '_> Div<&'_ Unwrapped<F>> for Unwrapped<F>

type Output = Unwrapped<F>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<F: Fixed, '_, '_> Div<&'_ Unwrapped<F>> for &'_ Unwrapped<F>

type Output = Unwrapped<F>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<Frac, '_> Div<&'_ i128> for Unwrapped<FixedI128<Frac>>

type Output = Unwrapped<FixedI128<Frac>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<Frac, '_, '_> Div<&'_ i128> for &'_ Unwrapped<FixedI128<Frac>>

type Output = Unwrapped<FixedI128<Frac>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<Frac, '_> Div<&'_ i16> for Unwrapped<FixedI16<Frac>>

type Output = Unwrapped<FixedI16<Frac>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<Frac, '_, '_> Div<&'_ i16> for &'_ Unwrapped<FixedI16<Frac>>

type Output = Unwrapped<FixedI16<Frac>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<Frac, '_> Div<&'_ i32> for Unwrapped<FixedI32<Frac>>

type Output = Unwrapped<FixedI32<Frac>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<Frac, '_, '_> Div<&'_ i32> for &'_ Unwrapped<FixedI32<Frac>>

type Output = Unwrapped<FixedI32<Frac>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<Frac, '_> Div<&'_ i64> for Unwrapped<FixedI64<Frac>>

type Output = Unwrapped<FixedI64<Frac>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<Frac, '_, '_> Div<&'_ i64> for &'_ Unwrapped<FixedI64<Frac>>

type Output = Unwrapped<FixedI64<Frac>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<Frac, '_> Div<&'_ i8> for Unwrapped<FixedI8<Frac>>

type Output = Unwrapped<FixedI8<Frac>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<Frac, '_, '_> Div<&'_ i8> for &'_ Unwrapped<FixedI8<Frac>>

type Output = Unwrapped<FixedI8<Frac>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<Frac, '_> Div<&'_ u128> for Unwrapped<FixedU128<Frac>>

type Output = Unwrapped<FixedU128<Frac>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<Frac, '_, '_> Div<&'_ u128> for &'_ Unwrapped<FixedU128<Frac>>

type Output = Unwrapped<FixedU128<Frac>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<Frac, '_> Div<&'_ u16> for Unwrapped<FixedU16<Frac>>

type Output = Unwrapped<FixedU16<Frac>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<Frac, '_, '_> Div<&'_ u16> for &'_ Unwrapped<FixedU16<Frac>>

type Output = Unwrapped<FixedU16<Frac>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<Frac, '_> Div<&'_ u32> for Unwrapped<FixedU32<Frac>>

type Output = Unwrapped<FixedU32<Frac>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<Frac, '_, '_> Div<&'_ u32> for &'_ Unwrapped<FixedU32<Frac>>

type Output = Unwrapped<FixedU32<Frac>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<Frac, '_> Div<&'_ u64> for Unwrapped<FixedU64<Frac>>

type Output = Unwrapped<FixedU64<Frac>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<Frac, '_, '_> Div<&'_ u64> for &'_ Unwrapped<FixedU64<Frac>>

type Output = Unwrapped<FixedU64<Frac>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<Frac, '_> Div<&'_ u8> for Unwrapped<FixedU8<Frac>>

type Output = Unwrapped<FixedU8<Frac>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<Frac, '_, '_> Div<&'_ u8> for &'_ Unwrapped<FixedU8<Frac>>

type Output = Unwrapped<FixedU8<Frac>>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Unwrapped<F>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<F: Fixed, '_> Div<Unwrapped<F>> for &'_ Unwrapped<F>

type Output = Unwrapped<F>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Unwrapped<FixedI128<Frac>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<Frac, '_> Div<i128> for &'_ Unwrapped<FixedI128<Frac>>

type Output = Unwrapped<FixedI128<Frac>>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Unwrapped<FixedI16<Frac>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<Frac, '_> Div<i16> for &'_ Unwrapped<FixedI16<Frac>>

type Output = Unwrapped<FixedI16<Frac>>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Unwrapped<FixedI32<Frac>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<Frac, '_> Div<i32> for &'_ Unwrapped<FixedI32<Frac>>

type Output = Unwrapped<FixedI32<Frac>>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Unwrapped<FixedI64<Frac>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<Frac, '_> Div<i64> for &'_ Unwrapped<FixedI64<Frac>>

type Output = Unwrapped<FixedI64<Frac>>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Unwrapped<FixedI8<Frac>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<Frac, '_> Div<i8> for &'_ Unwrapped<FixedI8<Frac>>

type Output = Unwrapped<FixedI8<Frac>>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Unwrapped<FixedU128<Frac>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<Frac, '_> Div<u128> for &'_ Unwrapped<FixedU128<Frac>>

type Output = Unwrapped<FixedU128<Frac>>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Unwrapped<FixedU16<Frac>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<Frac, '_> Div<u16> for &'_ Unwrapped<FixedU16<Frac>>

type Output = Unwrapped<FixedU16<Frac>>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Unwrapped<FixedU32<Frac>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<Frac, '_> Div<u32> for &'_ Unwrapped<FixedU32<Frac>>

type Output = Unwrapped<FixedU32<Frac>>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Unwrapped<FixedU64<Frac>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<Frac, '_> Div<u64> for &'_ Unwrapped<FixedU64<Frac>>

type Output = Unwrapped<FixedU64<Frac>>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Unwrapped<FixedU8<Frac>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<Frac, '_> Div<u8> for &'_ Unwrapped<FixedU8<Frac>>

type Output = Unwrapped<FixedU8<Frac>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<F: Fixed, '_> DivAssign<&'_ 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<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: Eq> Eq for Unwrapped<F>

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>

type Err = ParseFixedError

The associated error which can be returned from parsing.

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

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

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

impl<F: Hash> Hash for 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, 

Feeds a slice of this type into the given Hasher.

impl<F: Fixed, '_> Mul<&'_ Unwrapped<F>> for Unwrapped<F>

type Output = Unwrapped<F>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<F: Fixed, '_, '_> Mul<&'_ Unwrapped<F>> for &'_ Unwrapped<F>

type Output = Unwrapped<F>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<Frac, '_> Mul<&'_ i128> for Unwrapped<FixedI128<Frac>>

type Output = Unwrapped<FixedI128<Frac>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<Frac, '_, '_> Mul<&'_ i128> for &'_ Unwrapped<FixedI128<Frac>>

type Output = Unwrapped<FixedI128<Frac>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<Frac, '_> Mul<&'_ i16> for Unwrapped<FixedI16<Frac>>

type Output = Unwrapped<FixedI16<Frac>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<Frac, '_, '_> Mul<&'_ i16> for &'_ Unwrapped<FixedI16<Frac>>

type Output = Unwrapped<FixedI16<Frac>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<Frac, '_> Mul<&'_ i32> for Unwrapped<FixedI32<Frac>>

type Output = Unwrapped<FixedI32<Frac>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<Frac, '_, '_> Mul<&'_ i32> for &'_ Unwrapped<FixedI32<Frac>>

type Output = Unwrapped<FixedI32<Frac>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<Frac, '_> Mul<&'_ i64> for Unwrapped<FixedI64<Frac>>

type Output = Unwrapped<FixedI64<Frac>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<Frac, '_, '_> Mul<&'_ i64> for &'_ Unwrapped<FixedI64<Frac>>

type Output = Unwrapped<FixedI64<Frac>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<Frac, '_> Mul<&'_ i8> for Unwrapped<FixedI8<Frac>>

type Output = Unwrapped<FixedI8<Frac>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<Frac, '_, '_> Mul<&'_ i8> for &'_ Unwrapped<FixedI8<Frac>>

type Output = Unwrapped<FixedI8<Frac>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<Frac, '_> Mul<&'_ u128> for Unwrapped<FixedU128<Frac>>

type Output = Unwrapped<FixedU128<Frac>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<Frac, '_, '_> Mul<&'_ u128> for &'_ Unwrapped<FixedU128<Frac>>

type Output = Unwrapped<FixedU128<Frac>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<Frac, '_> Mul<&'_ u16> for Unwrapped<FixedU16<Frac>>

type Output = Unwrapped<FixedU16<Frac>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<Frac, '_, '_> Mul<&'_ u16> for &'_ Unwrapped<FixedU16<Frac>>

type Output = Unwrapped<FixedU16<Frac>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<Frac, '_> Mul<&'_ u32> for Unwrapped<FixedU32<Frac>>

type Output = Unwrapped<FixedU32<Frac>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<Frac, '_, '_> Mul<&'_ u32> for &'_ Unwrapped<FixedU32<Frac>>

type Output = Unwrapped<FixedU32<Frac>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<Frac, '_> Mul<&'_ u64> for Unwrapped<FixedU64<Frac>>

type Output = Unwrapped<FixedU64<Frac>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<Frac, '_, '_> Mul<&'_ u64> for &'_ Unwrapped<FixedU64<Frac>>

type Output = Unwrapped<FixedU64<Frac>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<Frac, '_> Mul<&'_ u8> for Unwrapped<FixedU8<Frac>>

type Output = Unwrapped<FixedU8<Frac>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<Frac, '_, '_> Mul<&'_ u8> for &'_ Unwrapped<FixedU8<Frac>>

type Output = Unwrapped<FixedU8<Frac>>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Unwrapped<F>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<F: Fixed, '_> Mul<Unwrapped<F>> for &'_ Unwrapped<F>

type Output = Unwrapped<F>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Unwrapped<FixedI128<Frac>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<Frac, '_> Mul<i128> for &'_ Unwrapped<FixedI128<Frac>>

type Output = Unwrapped<FixedI128<Frac>>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Unwrapped<FixedI16<Frac>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<Frac, '_> Mul<i16> for &'_ Unwrapped<FixedI16<Frac>>

type Output = Unwrapped<FixedI16<Frac>>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Unwrapped<FixedI32<Frac>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<Frac, '_> Mul<i32> for &'_ Unwrapped<FixedI32<Frac>>

type Output = Unwrapped<FixedI32<Frac>>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Unwrapped<FixedI64<Frac>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<Frac, '_> Mul<i64> for &'_ Unwrapped<FixedI64<Frac>>

type Output = Unwrapped<FixedI64<Frac>>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Unwrapped<FixedI8<Frac>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<Frac, '_> Mul<i8> for &'_ Unwrapped<FixedI8<Frac>>

type Output = Unwrapped<FixedI8<Frac>>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Unwrapped<FixedU128<Frac>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<Frac, '_> Mul<u128> for &'_ Unwrapped<FixedU128<Frac>>

type Output = Unwrapped<FixedU128<Frac>>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Unwrapped<FixedU16<Frac>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<Frac, '_> Mul<u16> for &'_ Unwrapped<FixedU16<Frac>>

type Output = Unwrapped<FixedU16<Frac>>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Unwrapped<FixedU32<Frac>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<Frac, '_> Mul<u32> for &'_ Unwrapped<FixedU32<Frac>>

type Output = Unwrapped<FixedU32<Frac>>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Unwrapped<FixedU64<Frac>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<Frac, '_> Mul<u64> for &'_ Unwrapped<FixedU64<Frac>>

type Output = Unwrapped<FixedU64<Frac>>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Unwrapped<FixedU8<Frac>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<Frac, '_> Mul<u8> for &'_ Unwrapped<FixedU8<Frac>>

type Output = Unwrapped<FixedU8<Frac>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<F: Fixed, '_> MulAssign<&'_ 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<Unwrapped<F>> for Unwrapped<F>

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

Performs the *= operation.

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

fn mul_assign(&mut self, other: i128)

Performs the *= operation.

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

fn mul_assign(&mut self, other: i16)

Performs the *= operation.

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

fn mul_assign(&mut self, other: i32)

Performs the *= operation.

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

fn mul_assign(&mut self, other: i64)

Performs the *= operation.

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

fn mul_assign(&mut self, other: i8)

Performs the *= operation.

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

fn mul_assign(&mut self, other: u128)

Performs the *= operation.

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

fn mul_assign(&mut self, other: u16)

Performs the *= operation.

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

fn mul_assign(&mut self, other: u32)

Performs the *= operation.

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

fn mul_assign(&mut self, other: u64)

Performs the *= operation.

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

fn mul_assign(&mut self, other: u8)

Performs the *= operation.

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

type Output = Unwrapped<F>

The resulting type after applying the - operator.

fn neg(self) -> Unwrapped<F>

Performs the unary - operation.

impl<F: Fixed, '_> Neg for &'_ Unwrapped<F>

type Output = Unwrapped<F>

The resulting type after applying the - operator.

fn neg(self) -> Unwrapped<F>

Performs the unary - operation.

impl<F> Not for Unwrapped<F> where
    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
    &'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: Ord> Ord for Unwrapped<F>

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

This method returns an Ordering between self and other.

#[must_use]fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]fn clamp(self, min: Self, max: Self) -> Self

🔬 This is a nightly-only experimental API. (clamp)

Restrict a value to a certain interval.

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

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

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

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

This method tests for !=.

impl<F: PartialOrd> PartialOrd<Unwrapped<F>> for Unwrapped<F>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<F: Fixed, '_> Rem<&'_ Unwrapped<F>> for Unwrapped<F>

type Output = Unwrapped<F>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<F: Fixed, '_, '_> Rem<&'_ Unwrapped<F>> for &'_ Unwrapped<F>

type Output = Unwrapped<F>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Unwrapped<FixedI128<Frac>>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Unwrapped<FixedI128<Frac>>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Unwrapped<FixedI16<Frac>>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Unwrapped<FixedI16<Frac>>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Unwrapped<FixedI32<Frac>>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Unwrapped<FixedI32<Frac>>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Unwrapped<FixedI64<Frac>>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Unwrapped<FixedI64<Frac>>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Unwrapped<FixedI8<Frac>>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Unwrapped<FixedI8<Frac>>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Unwrapped<FixedU128<Frac>>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Unwrapped<FixedU128<Frac>>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Unwrapped<FixedU16<Frac>>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Unwrapped<FixedU16<Frac>>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Unwrapped<FixedU32<Frac>>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Unwrapped<FixedU32<Frac>>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Unwrapped<FixedU64<Frac>>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Unwrapped<FixedU64<Frac>>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Unwrapped<FixedU8<Frac>>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Unwrapped<FixedU8<Frac>>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Unwrapped<F>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<F: Fixed, '_> Rem<Unwrapped<F>> for &'_ Unwrapped<F>

type Output = Unwrapped<F>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Unwrapped<FixedI128<Frac>>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Unwrapped<FixedI128<Frac>>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Unwrapped<FixedI16<Frac>>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Unwrapped<FixedI16<Frac>>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Unwrapped<FixedI32<Frac>>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Unwrapped<FixedI32<Frac>>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Unwrapped<FixedI64<Frac>>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Unwrapped<FixedI64<Frac>>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Unwrapped<FixedI8<Frac>>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Unwrapped<FixedI8<Frac>>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Unwrapped<FixedU128<Frac>>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Unwrapped<FixedU128<Frac>>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Unwrapped<FixedU16<Frac>>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Unwrapped<FixedU16<Frac>>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Unwrapped<FixedU32<Frac>>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Unwrapped<FixedU32<Frac>>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Unwrapped<FixedU64<Frac>>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Unwrapped<FixedU64<Frac>>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Unwrapped<FixedU8<Frac>>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Unwrapped<FixedU8<Frac>>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<F: Fixed, '_> RemAssign<&'_ 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<Unwrapped<F>> for Unwrapped<F>

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

Performs the %= operation.

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

fn rem_assign(&mut self, other: i128)

Performs the %= operation.

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

fn rem_assign(&mut self, other: i16)

Performs the %= operation.

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

fn rem_assign(&mut self, other: i32)

Performs the %= operation.

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

fn rem_assign(&mut self, other: i64)

Performs the %= operation.

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

fn rem_assign(&mut self, other: i8)

Performs the %= operation.

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

fn rem_assign(&mut self, other: u128)

Performs the %= operation.

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

fn rem_assign(&mut self, other: u16)

Performs the %= operation.

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

fn rem_assign(&mut self, other: u32)

Performs the %= operation.

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

fn rem_assign(&mut self, other: u64)

Performs the %= operation.

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

fn rem_assign(&mut self, other: u8)

Performs the %= operation.

impl<F, '_> Shl<&'_ i128> for Unwrapped<F> where
    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
    &'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<&'_ 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<&'_ i16> for &'_ Unwrapped<F> where
    &'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<&'_ 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<&'_ i32> for &'_ Unwrapped<F> where
    &'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<&'_ 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<&'_ i64> for &'_ Unwrapped<F> where
    &'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<&'_ 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<&'_ i8> for &'_ Unwrapped<F> where
    &'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<&'_ 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<&'_ isize> for &'_ Unwrapped<F> where
    &'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<&'_ 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<&'_ u128> for &'_ Unwrapped<F> where
    &'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<&'_ 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<&'_ u16> for &'_ Unwrapped<F> where
    &'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<&'_ 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<&'_ u32> for &'_ Unwrapped<F> where
    &'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<&'_ 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<&'_ u64> for &'_ Unwrapped<F> where
    &'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<&'_ 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<&'_ u8> for &'_ Unwrapped<F> where
    &'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<&'_ 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<&'_ usize> for &'_ Unwrapped<F> where
    &'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<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<i128> for &'_ Unwrapped<F> where
    &'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<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<i16> for &'_ Unwrapped<F> where
    &'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<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<i32> for &'_ Unwrapped<F> where
    &'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<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<i64> for &'_ Unwrapped<F> where
    &'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<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<i8> for &'_ Unwrapped<F> where
    &'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<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<isize> for &'_ Unwrapped<F> where
    &'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<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<u128> for &'_ Unwrapped<F> where
    &'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<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<u16> for &'_ Unwrapped<F> where
    &'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<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<u32> for &'_ Unwrapped<F> where
    &'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<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<u64> for &'_ Unwrapped<F> where
    &'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<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<u8> for &'_ Unwrapped<F> where
    &'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<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<usize> for &'_ Unwrapped<F> where
    &'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, '_> 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
    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
    &'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<&'_ 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<&'_ i16> for &'_ Unwrapped<F> where
    &'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<&'_ 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<&'_ i32> for &'_ Unwrapped<F> where
    &'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<&'_ 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<&'_ i64> for &'_ Unwrapped<F> where
    &'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<&'_ 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<&'_ i8> for &'_ Unwrapped<F> where
    &'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<&'_ 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<&'_ isize> for &'_ Unwrapped<F> where
    &'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<&'_ 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<&'_ u128> for &'_ Unwrapped<F> where
    &'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<&'_ 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<&'_ u16> for &'_ Unwrapped<F> where
    &'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<&'_ 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<&'_ u32> for &'_ Unwrapped<F> where
    &'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<&'_ 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<&'_ u64> for &'_ Unwrapped<F> where
    &'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<&'_ 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<&'_ u8> for &'_ Unwrapped<F> where
    &'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<&'_ 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<&'_ usize> for &'_ Unwrapped<F> where
    &'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<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<i128> for &'_ Unwrapped<F> where
    &'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<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<i16> for &'_ Unwrapped<F> where
    &'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<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<i32> for &'_ Unwrapped<F> where
    &'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<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<i64> for &'_ Unwrapped<F> where
    &'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<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<i8> for &'_ Unwrapped<F> where
    &'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<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<isize> for &'_ Unwrapped<F> where
    &'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<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<u128> for &'_ Unwrapped<F> where
    &'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<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<u16> for &'_ Unwrapped<F> where
    &'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<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<u32> for &'_ Unwrapped<F> where
    &'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<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<u64> for &'_ Unwrapped<F> where
    &'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<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<u8> for &'_ Unwrapped<F> where
    &'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<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<usize> for &'_ Unwrapped<F> where
    &'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, '_> 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> StructuralEq for Unwrapped<F>

impl<F> StructuralPartialEq for Unwrapped<F>

impl<F: Fixed, '_> Sub<&'_ Unwrapped<F>> for Unwrapped<F>

type Output = Unwrapped<F>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<F: Fixed, '_, '_> Sub<&'_ Unwrapped<F>> for &'_ Unwrapped<F>

type Output = Unwrapped<F>

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = Unwrapped<F>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<F: Fixed, '_> Sub<Unwrapped<F>> for &'_ Unwrapped<F>

type Output = Unwrapped<F>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<F: Fixed, '_> SubAssign<&'_ Unwrapped<F>> for Unwrapped<F>

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

Performs the -= operation.

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

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

Performs the -= operation.

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

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

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

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

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

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