[−][src]Struct fixed::Wrapping

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

Provides intentionally wrapped arithmetic on fixed-point numbers.

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

Examples

use fixed::{types::I16F16, Wrapping};
let max = Wrapping(I16F16::max_value());
let delta = Wrapping(I16F16::from_bits(1));
assert_eq!(I16F16::min_value(), (max + delta).0);

Methods

`impl<F: Fixed> Wrapping<F>`[src]

`pub fn from_num<Src: ToFixed>(src: Src) -> Self`[src]

Wrapping conversion from another number.

The other number can be:

A fixed-point number. Any extra fractional bits are truncated.
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. For this conversion, the method rounds to the nearest, with ties rounding to even.
Any other number src for which ToFixed is implemented, in which case this method returns Wrapping(src.wrapping_to_fixed()).

Panics

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

Examples

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

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

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

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

`pub fn from_str_binary(src: &str) -> Result<Self, ParseFixedError>`[src]

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

Examples

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

`pub fn from_str_octal(src: &str) -> Result<Self, ParseFixedError>`[src]

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

Examples

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

`pub fn from_str_hex(src: &str) -> Result<Self, ParseFixedError>`[src]

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

Examples

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

`pub fn ceil(self) -> Wrapping<F>`[src]

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

Examples

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

`pub fn floor(self) -> Wrapping<F>`[src]

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

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

Examples

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

`pub fn round(self) -> Wrapping<F>`[src]

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

Examples

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

`impl<F: FixedSigned> Wrapping<F>`[src]

`pub fn abs(self) -> Wrapping<F>`[src]

Wrapping absolute value. Returns the absolute value, wrapping on overflow.

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

Examples

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

Trait Implementations

`impl<F: Debug> Debug for Wrapping<F>`[src]

`fn fmt(&self, f: &mut Formatter) -> Result`[src]

`impl<F: Fixed> Display for Wrapping<F>`[src]

`fn fmt(&self, f: &mut Formatter) -> FmtResult`[src]

`impl<Frac> Rem<i8> for Wrapping<FixedI8<Frac>>`[src]

`type Output = Wrapping<FixedI8<Frac>>`

The resulting type after applying the % operator.

`fn rem(self, other: i8) -> Wrapping<FixedI8<Frac>>`[src]

`impl<'a, Frac> Rem<i8> for &'a Wrapping<FixedI8<Frac>>`[src]

`type Output = Wrapping<FixedI8<Frac>>`

The resulting type after applying the % operator.

`fn rem(self, other: i8) -> Wrapping<FixedI8<Frac>>`[src]

`impl<'a, Frac> Rem<&'a i8> for Wrapping<FixedI8<Frac>>`[src]

`type Output = Wrapping<FixedI8<Frac>>`

The resulting type after applying the % operator.

`fn rem(self, other: &i8) -> Wrapping<FixedI8<Frac>>`[src]

`impl<'a, 'b, Frac> Rem<&'a i8> for &'b Wrapping<FixedI8<Frac>>`[src]

`type Output = Wrapping<FixedI8<Frac>>`

The resulting type after applying the % operator.

`fn rem(self, other: &i8) -> Wrapping<FixedI8<Frac>>`[src]

`impl<Frac> Rem<i16> for Wrapping<FixedI16<Frac>>`[src]

`type Output = Wrapping<FixedI16<Frac>>`

The resulting type after applying the % operator.

`fn rem(self, other: i16) -> Wrapping<FixedI16<Frac>>`[src]

`impl<'a, Frac> Rem<i16> for &'a Wrapping<FixedI16<Frac>>`[src]

`type Output = Wrapping<FixedI16<Frac>>`

The resulting type after applying the % operator.

`fn rem(self, other: i16) -> Wrapping<FixedI16<Frac>>`[src]

`impl<'a, Frac> Rem<&'a i16> for Wrapping<FixedI16<Frac>>`[src]

`type Output = Wrapping<FixedI16<Frac>>`

The resulting type after applying the % operator.

`fn rem(self, other: &i16) -> Wrapping<FixedI16<Frac>>`[src]

`impl<'a, 'b, Frac> Rem<&'a i16> for &'b Wrapping<FixedI16<Frac>>`[src]

`type Output = Wrapping<FixedI16<Frac>>`

The resulting type after applying the % operator.

`fn rem(self, other: &i16) -> Wrapping<FixedI16<Frac>>`[src]

`impl<Frac> Rem<i32> for Wrapping<FixedI32<Frac>>`[src]

`type Output = Wrapping<FixedI32<Frac>>`

The resulting type after applying the % operator.

`fn rem(self, other: i32) -> Wrapping<FixedI32<Frac>>`[src]

`impl<'a, Frac> Rem<i32> for &'a Wrapping<FixedI32<Frac>>`[src]

`type Output = Wrapping<FixedI32<Frac>>`

The resulting type after applying the % operator.

`fn rem(self, other: i32) -> Wrapping<FixedI32<Frac>>`[src]

`impl<'a, Frac> Rem<&'a i32> for Wrapping<FixedI32<Frac>>`[src]

`type Output = Wrapping<FixedI32<Frac>>`

The resulting type after applying the % operator.

`fn rem(self, other: &i32) -> Wrapping<FixedI32<Frac>>`[src]

`impl<'a, 'b, Frac> Rem<&'a i32> for &'b Wrapping<FixedI32<Frac>>`[src]

`type Output = Wrapping<FixedI32<Frac>>`

The resulting type after applying the % operator.

`fn rem(self, other: &i32) -> Wrapping<FixedI32<Frac>>`[src]

`impl<Frac> Rem<i64> for Wrapping<FixedI64<Frac>>`[src]

`type Output = Wrapping<FixedI64<Frac>>`

The resulting type after applying the % operator.

`fn rem(self, other: i64) -> Wrapping<FixedI64<Frac>>`[src]

`impl<'a, Frac> Rem<i64> for &'a Wrapping<FixedI64<Frac>>`[src]

`type Output = Wrapping<FixedI64<Frac>>`

The resulting type after applying the % operator.

`fn rem(self, other: i64) -> Wrapping<FixedI64<Frac>>`[src]

`impl<'a, Frac> Rem<&'a i64> for Wrapping<FixedI64<Frac>>`[src]

`type Output = Wrapping<FixedI64<Frac>>`

The resulting type after applying the % operator.

`fn rem(self, other: &i64) -> Wrapping<FixedI64<Frac>>`[src]

`impl<'a, 'b, Frac> Rem<&'a i64> for &'b Wrapping<FixedI64<Frac>>`[src]

`type Output = Wrapping<FixedI64<Frac>>`

The resulting type after applying the % operator.

`fn rem(self, other: &i64) -> Wrapping<FixedI64<Frac>>`[src]

`impl<Frac> Rem<i128> for Wrapping<FixedI128<Frac>>`[src]

`type Output = Wrapping<FixedI128<Frac>>`

The resulting type after applying the % operator.

`fn rem(self, other: i128) -> Wrapping<FixedI128<Frac>>`[src]

`impl<'a, Frac> Rem<i128> for &'a Wrapping<FixedI128<Frac>>`[src]

`type Output = Wrapping<FixedI128<Frac>>`

The resulting type after applying the % operator.

`fn rem(self, other: i128) -> Wrapping<FixedI128<Frac>>`[src]

`impl<'a, Frac> Rem<&'a i128> for Wrapping<FixedI128<Frac>>`[src]

`type Output = Wrapping<FixedI128<Frac>>`

The resulting type after applying the % operator.

`fn rem(self, other: &i128) -> Wrapping<FixedI128<Frac>>`[src]

`impl<'a, 'b, Frac> Rem<&'a i128> for &'b Wrapping<FixedI128<Frac>>`[src]

`type Output = Wrapping<FixedI128<Frac>>`

The resulting type after applying the % operator.

`fn rem(self, other: &i128) -> Wrapping<FixedI128<Frac>>`[src]

`impl<Frac> Rem<u8> for Wrapping<FixedU8<Frac>>`[src]

`type Output = Wrapping<FixedU8<Frac>>`

The resulting type after applying the % operator.

`fn rem(self, other: u8) -> Wrapping<FixedU8<Frac>>`[src]

`impl<'a, Frac> Rem<u8> for &'a Wrapping<FixedU8<Frac>>`[src]

`type Output = Wrapping<FixedU8<Frac>>`

The resulting type after applying the % operator.

`fn rem(self, other: u8) -> Wrapping<FixedU8<Frac>>`[src]

`impl<'a, Frac> Rem<&'a u8> for Wrapping<FixedU8<Frac>>`[src]

`type Output = Wrapping<FixedU8<Frac>>`

The resulting type after applying the % operator.

`fn rem(self, other: &u8) -> Wrapping<FixedU8<Frac>>`[src]

`impl<'a, 'b, Frac> Rem<&'a u8> for &'b Wrapping<FixedU8<Frac>>`[src]

`type Output = Wrapping<FixedU8<Frac>>`

The resulting type after applying the % operator.

`fn rem(self, other: &u8) -> Wrapping<FixedU8<Frac>>`[src]

`impl<Frac> Rem<u16> for Wrapping<FixedU16<Frac>>`[src]

`type Output = Wrapping<FixedU16<Frac>>`

The resulting type after applying the % operator.

`fn rem(self, other: u16) -> Wrapping<FixedU16<Frac>>`[src]

`impl<'a, Frac> Rem<u16> for &'a Wrapping<FixedU16<Frac>>`[src]

`type Output = Wrapping<FixedU16<Frac>>`

The resulting type after applying the % operator.

`fn rem(self, other: u16) -> Wrapping<FixedU16<Frac>>`[src]

`impl<'a, Frac> Rem<&'a u16> for Wrapping<FixedU16<Frac>>`[src]

`type Output = Wrapping<FixedU16<Frac>>`

The resulting type after applying the % operator.

`fn rem(self, other: &u16) -> Wrapping<FixedU16<Frac>>`[src]

`impl<'a, 'b, Frac> Rem<&'a u16> for &'b Wrapping<FixedU16<Frac>>`[src]

`type Output = Wrapping<FixedU16<Frac>>`

The resulting type after applying the % operator.

`fn rem(self, other: &u16) -> Wrapping<FixedU16<Frac>>`[src]

`impl<Frac> Rem<u32> for Wrapping<FixedU32<Frac>>`[src]

`type Output = Wrapping<FixedU32<Frac>>`

The resulting type after applying the % operator.

`fn rem(self, other: u32) -> Wrapping<FixedU32<Frac>>`[src]

`impl<'a, Frac> Rem<u32> for &'a Wrapping<FixedU32<Frac>>`[src]

`type Output = Wrapping<FixedU32<Frac>>`

The resulting type after applying the % operator.

`fn rem(self, other: u32) -> Wrapping<FixedU32<Frac>>`[src]

`impl<'a, Frac> Rem<&'a u32> for Wrapping<FixedU32<Frac>>`[src]

`type Output = Wrapping<FixedU32<Frac>>`

The resulting type after applying the % operator.

`fn rem(self, other: &u32) -> Wrapping<FixedU32<Frac>>`[src]

`impl<'a, 'b, Frac> Rem<&'a u32> for &'b Wrapping<FixedU32<Frac>>`[src]

`type Output = Wrapping<FixedU32<Frac>>`

The resulting type after applying the % operator.

`fn rem(self, other: &u32) -> Wrapping<FixedU32<Frac>>`[src]

`impl<Frac> Rem<u64> for Wrapping<FixedU64<Frac>>`[src]

`type Output = Wrapping<FixedU64<Frac>>`

The resulting type after applying the % operator.

`fn rem(self, other: u64) -> Wrapping<FixedU64<Frac>>`[src]

`impl<'a, Frac> Rem<u64> for &'a Wrapping<FixedU64<Frac>>`[src]

`type Output = Wrapping<FixedU64<Frac>>`

The resulting type after applying the % operator.

`fn rem(self, other: u64) -> Wrapping<FixedU64<Frac>>`[src]

`impl<'a, Frac> Rem<&'a u64> for Wrapping<FixedU64<Frac>>`[src]

`type Output = Wrapping<FixedU64<Frac>>`

The resulting type after applying the % operator.

`fn rem(self, other: &u64) -> Wrapping<FixedU64<Frac>>`[src]

`impl<'a, 'b, Frac> Rem<&'a u64> for &'b Wrapping<FixedU64<Frac>>`[src]

`type Output = Wrapping<FixedU64<Frac>>`

The resulting type after applying the % operator.

`fn rem(self, other: &u64) -> Wrapping<FixedU64<Frac>>`[src]

`impl<Frac> Rem<u128> for Wrapping<FixedU128<Frac>>`[src]

`type Output = Wrapping<FixedU128<Frac>>`

The resulting type after applying the % operator.

`fn rem(self, other: u128) -> Wrapping<FixedU128<Frac>>`[src]

`impl<'a, Frac> Rem<u128> for &'a Wrapping<FixedU128<Frac>>`[src]

`type Output = Wrapping<FixedU128<Frac>>`

The resulting type after applying the % operator.

`fn rem(self, other: u128) -> Wrapping<FixedU128<Frac>>`[src]

`impl<'a, Frac> Rem<&'a u128> for Wrapping<FixedU128<Frac>>`[src]

`type Output = Wrapping<FixedU128<Frac>>`

The resulting type after applying the % operator.

`fn rem(self, other: &u128) -> Wrapping<FixedU128<Frac>>`[src]

`impl<'a, 'b, Frac> Rem<&'a u128> for &'b Wrapping<FixedU128<Frac>>`[src]

`type Output = Wrapping<FixedU128<Frac>>`

The resulting type after applying the % operator.

`fn rem(self, other: &u128) -> Wrapping<FixedU128<Frac>>`[src]

`impl<F: PartialEq> PartialEq<Wrapping<F>> for Wrapping<F>`[src]

`fn eq(&self, other: &Wrapping<F>) -> bool`[src]

`fn ne(&self, other: &Wrapping<F>) -> bool`[src]

`impl<F: Eq> Eq for Wrapping<F>`[src]

`impl<F: Ord> Ord for Wrapping<F>`[src]

`fn cmp(&self, other: &Wrapping<F>) -> Ordering`[src]

`fn max(self, other: Self) -> Self`1.21.0[src]

Compares and returns the maximum of two values. Read more

`fn min(self, other: Self) -> Self`1.21.0[src]

Compares and returns the minimum of two values. Read more

`fn clamp(self, min: Self, max: Self) -> Self`[src]

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

Restrict a value to a certain interval. Read more

`impl<F: PartialOrd> PartialOrd<Wrapping<F>> for Wrapping<F>`[src]

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

`fn lt(&self, other: &Wrapping<F>) -> bool`[src]

`fn le(&self, other: &Wrapping<F>) -> bool`[src]

`fn gt(&self, other: &Wrapping<F>) -> bool`[src]

`fn ge(&self, other: &Wrapping<F>) -> bool`[src]

`impl<F: Fixed> FromStr for Wrapping<F>`[src]

`type Err = ParseFixedError`

The associated error which can be returned from parsing.

`fn from_str(s: &str) -> Result<Self, Self::Err>`[src]

`impl<F: Fixed> Add<Wrapping<F>> for Wrapping<F>`[src]

`type Output = Wrapping<F>`

The resulting type after applying the + operator.

`fn add(self, other: Wrapping<F>) -> Wrapping<F>`[src]

`impl<'a, F: Fixed> Add<Wrapping<F>> for &'a Wrapping<F>`[src]

`type Output = Wrapping<F>`

The resulting type after applying the + operator.

`fn add(self, other: Wrapping<F>) -> Wrapping<F>`[src]

`impl<'a, F: Fixed> Add<&'a Wrapping<F>> for Wrapping<F>`[src]

`type Output = Wrapping<F>`

The resulting type after applying the + operator.

`fn add(self, other: &Wrapping<F>) -> Wrapping<F>`[src]

`impl<'a, 'b, F: Fixed> Add<&'a Wrapping<F>> for &'b Wrapping<F>`[src]

`type Output = Wrapping<F>`

The resulting type after applying the + operator.

`fn add(self, other: &Wrapping<F>) -> Wrapping<F>`[src]

`impl<F: Fixed> Sub<Wrapping<F>> for Wrapping<F>`[src]

`type Output = Wrapping<F>`

The resulting type after applying the - operator.

`fn sub(self, other: Wrapping<F>) -> Wrapping<F>`[src]

`impl<'a, F: Fixed> Sub<Wrapping<F>> for &'a Wrapping<F>`[src]

`type Output = Wrapping<F>`

The resulting type after applying the - operator.

`fn sub(self, other: Wrapping<F>) -> Wrapping<F>`[src]

`impl<'a, F: Fixed> Sub<&'a Wrapping<F>> for Wrapping<F>`[src]

`type Output = Wrapping<F>`

The resulting type after applying the - operator.

`fn sub(self, other: &Wrapping<F>) -> Wrapping<F>`[src]

`impl<'a, 'b, F: Fixed> Sub<&'a Wrapping<F>> for &'b Wrapping<F>`[src]

`type Output = Wrapping<F>`

The resulting type after applying the - operator.

`fn sub(self, other: &Wrapping<F>) -> Wrapping<F>`[src]

`impl<F: Fixed> Mul<Wrapping<F>> for Wrapping<F>`[src]

`type Output = Wrapping<F>`

The resulting type after applying the * operator.

`fn mul(self, other: Wrapping<F>) -> Wrapping<F>`[src]

`impl<'a, F: Fixed> Mul<Wrapping<F>> for &'a Wrapping<F>`[src]

`type Output = Wrapping<F>`

The resulting type after applying the * operator.

`fn mul(self, other: Wrapping<F>) -> Wrapping<F>`[src]

`impl<'a, F: Fixed> Mul<&'a Wrapping<F>> for Wrapping<F>`[src]

`type Output = Wrapping<F>`

The resulting type after applying the * operator.

`fn mul(self, other: &Wrapping<F>) -> Wrapping<F>`[src]

`impl<'a, 'b, F: Fixed> Mul<&'a Wrapping<F>> for &'b Wrapping<F>`[src]

`type Output = Wrapping<F>`

The resulting type after applying the * operator.

`fn mul(self, other: &Wrapping<F>) -> Wrapping<F>`[src]

`impl<Frac> Mul<i8> for Wrapping<FixedI8<Frac>>`[src]

`type Output = Wrapping<FixedI8<Frac>>`

The resulting type after applying the * operator.

`fn mul(self, other: i8) -> Wrapping<FixedI8<Frac>>`[src]

`impl<'a, Frac> Mul<i8> for &'a Wrapping<FixedI8<Frac>>`[src]

`type Output = Wrapping<FixedI8<Frac>>`

The resulting type after applying the * operator.

`fn mul(self, other: i8) -> Wrapping<FixedI8<Frac>>`[src]

`impl<'a, Frac> Mul<&'a i8> for Wrapping<FixedI8<Frac>>`[src]

`type Output = Wrapping<FixedI8<Frac>>`

The resulting type after applying the * operator.

`fn mul(self, other: &i8) -> Wrapping<FixedI8<Frac>>`[src]

`impl<'a, 'b, Frac> Mul<&'a i8> for &'b Wrapping<FixedI8<Frac>>`[src]

`type Output = Wrapping<FixedI8<Frac>>`

The resulting type after applying the * operator.

`fn mul(self, other: &i8) -> Wrapping<FixedI8<Frac>>`[src]

`impl<Frac> Mul<i16> for Wrapping<FixedI16<Frac>>`[src]

`type Output = Wrapping<FixedI16<Frac>>`

The resulting type after applying the * operator.

`fn mul(self, other: i16) -> Wrapping<FixedI16<Frac>>`[src]

`impl<'a, Frac> Mul<i16> for &'a Wrapping<FixedI16<Frac>>`[src]

`type Output = Wrapping<FixedI16<Frac>>`

The resulting type after applying the * operator.

`fn mul(self, other: i16) -> Wrapping<FixedI16<Frac>>`[src]

`impl<'a, Frac> Mul<&'a i16> for Wrapping<FixedI16<Frac>>`[src]

`type Output = Wrapping<FixedI16<Frac>>`

The resulting type after applying the * operator.

`fn mul(self, other: &i16) -> Wrapping<FixedI16<Frac>>`[src]

`impl<'a, 'b, Frac> Mul<&'a i16> for &'b Wrapping<FixedI16<Frac>>`[src]

`type Output = Wrapping<FixedI16<Frac>>`

The resulting type after applying the * operator.

`fn mul(self, other: &i16) -> Wrapping<FixedI16<Frac>>`[src]

`impl<Frac> Mul<i32> for Wrapping<FixedI32<Frac>>`[src]

`type Output = Wrapping<FixedI32<Frac>>`

The resulting type after applying the * operator.

`fn mul(self, other: i32) -> Wrapping<FixedI32<Frac>>`[src]

`impl<'a, Frac> Mul<i32> for &'a Wrapping<FixedI32<Frac>>`[src]

`type Output = Wrapping<FixedI32<Frac>>`

The resulting type after applying the * operator.

`fn mul(self, other: i32) -> Wrapping<FixedI32<Frac>>`[src]

`impl<'a, Frac> Mul<&'a i32> for Wrapping<FixedI32<Frac>>`[src]

`type Output = Wrapping<FixedI32<Frac>>`

The resulting type after applying the * operator.

`fn mul(self, other: &i32) -> Wrapping<FixedI32<Frac>>`[src]

`impl<'a, 'b, Frac> Mul<&'a i32> for &'b Wrapping<FixedI32<Frac>>`[src]

`type Output = Wrapping<FixedI32<Frac>>`

The resulting type after applying the * operator.

`fn mul(self, other: &i32) -> Wrapping<FixedI32<Frac>>`[src]

`impl<Frac> Mul<i64> for Wrapping<FixedI64<Frac>>`[src]

`type Output = Wrapping<FixedI64<Frac>>`

The resulting type after applying the * operator.

`fn mul(self, other: i64) -> Wrapping<FixedI64<Frac>>`[src]

`impl<'a, Frac> Mul<i64> for &'a Wrapping<FixedI64<Frac>>`[src]

`type Output = Wrapping<FixedI64<Frac>>`

The resulting type after applying the * operator.

`fn mul(self, other: i64) -> Wrapping<FixedI64<Frac>>`[src]

`impl<'a, Frac> Mul<&'a i64> for Wrapping<FixedI64<Frac>>`[src]

`type Output = Wrapping<FixedI64<Frac>>`

The resulting type after applying the * operator.

`fn mul(self, other: &i64) -> Wrapping<FixedI64<Frac>>`[src]

`impl<'a, 'b, Frac> Mul<&'a i64> for &'b Wrapping<FixedI64<Frac>>`[src]

`type Output = Wrapping<FixedI64<Frac>>`

The resulting type after applying the * operator.

`fn mul(self, other: &i64) -> Wrapping<FixedI64<Frac>>`[src]

`impl<Frac> Mul<i128> for Wrapping<FixedI128<Frac>>`[src]

`type Output = Wrapping<FixedI128<Frac>>`

The resulting type after applying the * operator.

`fn mul(self, other: i128) -> Wrapping<FixedI128<Frac>>`[src]

`impl<'a, Frac> Mul<i128> for &'a Wrapping<FixedI128<Frac>>`[src]

`type Output = Wrapping<FixedI128<Frac>>`

The resulting type after applying the * operator.

`fn mul(self, other: i128) -> Wrapping<FixedI128<Frac>>`[src]

`impl<'a, Frac> Mul<&'a i128> for Wrapping<FixedI128<Frac>>`[src]

`type Output = Wrapping<FixedI128<Frac>>`

The resulting type after applying the * operator.

`fn mul(self, other: &i128) -> Wrapping<FixedI128<Frac>>`[src]

`impl<'a, 'b, Frac> Mul<&'a i128> for &'b Wrapping<FixedI128<Frac>>`[src]

`type Output = Wrapping<FixedI128<Frac>>`

The resulting type after applying the * operator.

`fn mul(self, other: &i128) -> Wrapping<FixedI128<Frac>>`[src]

`impl<Frac> Mul<u8> for Wrapping<FixedU8<Frac>>`[src]

`type Output = Wrapping<FixedU8<Frac>>`

The resulting type after applying the * operator.

`fn mul(self, other: u8) -> Wrapping<FixedU8<Frac>>`[src]

`impl<'a, Frac> Mul<u8> for &'a Wrapping<FixedU8<Frac>>`[src]

`type Output = Wrapping<FixedU8<Frac>>`

The resulting type after applying the * operator.

`fn mul(self, other: u8) -> Wrapping<FixedU8<Frac>>`[src]

`impl<'a, Frac> Mul<&'a u8> for Wrapping<FixedU8<Frac>>`[src]

`type Output = Wrapping<FixedU8<Frac>>`

The resulting type after applying the * operator.

`fn mul(self, other: &u8) -> Wrapping<FixedU8<Frac>>`[src]

`impl<'a, 'b, Frac> Mul<&'a u8> for &'b Wrapping<FixedU8<Frac>>`[src]

`type Output = Wrapping<FixedU8<Frac>>`

The resulting type after applying the * operator.

`fn mul(self, other: &u8) -> Wrapping<FixedU8<Frac>>`[src]

`impl<Frac> Mul<u16> for Wrapping<FixedU16<Frac>>`[src]

`type Output = Wrapping<FixedU16<Frac>>`

The resulting type after applying the * operator.

`fn mul(self, other: u16) -> Wrapping<FixedU16<Frac>>`[src]

`impl<'a, Frac> Mul<u16> for &'a Wrapping<FixedU16<Frac>>`[src]

`type Output = Wrapping<FixedU16<Frac>>`

The resulting type after applying the * operator.

`fn mul(self, other: u16) -> Wrapping<FixedU16<Frac>>`[src]

`impl<'a, Frac> Mul<&'a u16> for Wrapping<FixedU16<Frac>>`[src]

`type Output = Wrapping<FixedU16<Frac>>`

The resulting type after applying the * operator.

`fn mul(self, other: &u16) -> Wrapping<FixedU16<Frac>>`[src]

`impl<'a, 'b, Frac> Mul<&'a u16> for &'b Wrapping<FixedU16<Frac>>`[src]

`type Output = Wrapping<FixedU16<Frac>>`

The resulting type after applying the * operator.

`fn mul(self, other: &u16) -> Wrapping<FixedU16<Frac>>`[src]

`impl<Frac> Mul<u32> for Wrapping<FixedU32<Frac>>`[src]

`type Output = Wrapping<FixedU32<Frac>>`

The resulting type after applying the * operator.

`fn mul(self, other: u32) -> Wrapping<FixedU32<Frac>>`[src]

`impl<'a, Frac> Mul<u32> for &'a Wrapping<FixedU32<Frac>>`[src]

`type Output = Wrapping<FixedU32<Frac>>`

The resulting type after applying the * operator.

`fn mul(self, other: u32) -> Wrapping<FixedU32<Frac>>`[src]

`impl<'a, Frac> Mul<&'a u32> for Wrapping<FixedU32<Frac>>`[src]

`type Output = Wrapping<FixedU32<Frac>>`

The resulting type after applying the * operator.

`fn mul(self, other: &u32) -> Wrapping<FixedU32<Frac>>`[src]

`impl<'a, 'b, Frac> Mul<&'a u32> for &'b Wrapping<FixedU32<Frac>>`[src]

`type Output = Wrapping<FixedU32<Frac>>`

The resulting type after applying the * operator.

`fn mul(self, other: &u32) -> Wrapping<FixedU32<Frac>>`[src]

`impl<Frac> Mul<u64> for Wrapping<FixedU64<Frac>>`[src]

`type Output = Wrapping<FixedU64<Frac>>`

The resulting type after applying the * operator.

`fn mul(self, other: u64) -> Wrapping<FixedU64<Frac>>`[src]

`impl<'a, Frac> Mul<u64> for &'a Wrapping<FixedU64<Frac>>`[src]

`type Output = Wrapping<FixedU64<Frac>>`

The resulting type after applying the * operator.

`fn mul(self, other: u64) -> Wrapping<FixedU64<Frac>>`[src]

`impl<'a, Frac> Mul<&'a u64> for Wrapping<FixedU64<Frac>>`[src]

`type Output = Wrapping<FixedU64<Frac>>`

The resulting type after applying the * operator.

`fn mul(self, other: &u64) -> Wrapping<FixedU64<Frac>>`[src]

`impl<'a, 'b, Frac> Mul<&'a u64> for &'b Wrapping<FixedU64<Frac>>`[src]

`type Output = Wrapping<FixedU64<Frac>>`

The resulting type after applying the * operator.

`fn mul(self, other: &u64) -> Wrapping<FixedU64<Frac>>`[src]

`impl<Frac> Mul<u128> for Wrapping<FixedU128<Frac>>`[src]

`type Output = Wrapping<FixedU128<Frac>>`

The resulting type after applying the * operator.

`fn mul(self, other: u128) -> Wrapping<FixedU128<Frac>>`[src]

`impl<'a, Frac> Mul<u128> for &'a Wrapping<FixedU128<Frac>>`[src]

`type Output = Wrapping<FixedU128<Frac>>`

The resulting type after applying the * operator.

`fn mul(self, other: u128) -> Wrapping<FixedU128<Frac>>`[src]

`impl<'a, Frac> Mul<&'a u128> for Wrapping<FixedU128<Frac>>`[src]

`type Output = Wrapping<FixedU128<Frac>>`

The resulting type after applying the * operator.

`fn mul(self, other: &u128) -> Wrapping<FixedU128<Frac>>`[src]

`impl<'a, 'b, Frac> Mul<&'a u128> for &'b Wrapping<FixedU128<Frac>>`[src]

`type Output = Wrapping<FixedU128<Frac>>`

The resulting type after applying the * operator.

`fn mul(self, other: &u128) -> Wrapping<FixedU128<Frac>>`[src]

`impl<F: Fixed> Div<Wrapping<F>> for Wrapping<F>`[src]

`type Output = Wrapping<F>`

The resulting type after applying the / operator.

`fn div(self, other: Wrapping<F>) -> Wrapping<F>`[src]

`impl<'a, F: Fixed> Div<Wrapping<F>> for &'a Wrapping<F>`[src]

`type Output = Wrapping<F>`

The resulting type after applying the / operator.

`fn div(self, other: Wrapping<F>) -> Wrapping<F>`[src]

`impl<'a, F: Fixed> Div<&'a Wrapping<F>> for Wrapping<F>`[src]

`type Output = Wrapping<F>`

The resulting type after applying the / operator.

`fn div(self, other: &Wrapping<F>) -> Wrapping<F>`[src]

`impl<'a, 'b, F: Fixed> Div<&'a Wrapping<F>> for &'b Wrapping<F>`[src]

`type Output = Wrapping<F>`

The resulting type after applying the / operator.

`fn div(self, other: &Wrapping<F>) -> Wrapping<F>`[src]

`impl<Frac> Div<i8> for Wrapping<FixedI8<Frac>>`[src]

`type Output = Wrapping<FixedI8<Frac>>`

The resulting type after applying the / operator.

`fn div(self, other: i8) -> Wrapping<FixedI8<Frac>>`[src]

`impl<'a, Frac> Div<i8> for &'a Wrapping<FixedI8<Frac>>`[src]

`type Output = Wrapping<FixedI8<Frac>>`

The resulting type after applying the / operator.

`fn div(self, other: i8) -> Wrapping<FixedI8<Frac>>`[src]

`impl<'a, Frac> Div<&'a i8> for Wrapping<FixedI8<Frac>>`[src]

`type Output = Wrapping<FixedI8<Frac>>`

The resulting type after applying the / operator.

`fn div(self, other: &i8) -> Wrapping<FixedI8<Frac>>`[src]

`impl<'a, 'b, Frac> Div<&'a i8> for &'b Wrapping<FixedI8<Frac>>`[src]

`type Output = Wrapping<FixedI8<Frac>>`

The resulting type after applying the / operator.

`fn div(self, other: &i8) -> Wrapping<FixedI8<Frac>>`[src]

`impl<Frac> Div<i16> for Wrapping<FixedI16<Frac>>`[src]

`type Output = Wrapping<FixedI16<Frac>>`

The resulting type after applying the / operator.

`fn div(self, other: i16) -> Wrapping<FixedI16<Frac>>`[src]

`impl<'a, Frac> Div<i16> for &'a Wrapping<FixedI16<Frac>>`[src]

`type Output = Wrapping<FixedI16<Frac>>`

The resulting type after applying the / operator.

`fn div(self, other: i16) -> Wrapping<FixedI16<Frac>>`[src]

`impl<'a, Frac> Div<&'a i16> for Wrapping<FixedI16<Frac>>`[src]

`type Output = Wrapping<FixedI16<Frac>>`

The resulting type after applying the / operator.

`fn div(self, other: &i16) -> Wrapping<FixedI16<Frac>>`[src]

`impl<'a, 'b, Frac> Div<&'a i16> for &'b Wrapping<FixedI16<Frac>>`[src]

`type Output = Wrapping<FixedI16<Frac>>`

The resulting type after applying the / operator.

`fn div(self, other: &i16) -> Wrapping<FixedI16<Frac>>`[src]

`impl<Frac> Div<i32> for Wrapping<FixedI32<Frac>>`[src]

`type Output = Wrapping<FixedI32<Frac>>`

The resulting type after applying the / operator.

`fn div(self, other: i32) -> Wrapping<FixedI32<Frac>>`[src]

`impl<'a, Frac> Div<i32> for &'a Wrapping<FixedI32<Frac>>`[src]

`type Output = Wrapping<FixedI32<Frac>>`

The resulting type after applying the / operator.

`fn div(self, other: i32) -> Wrapping<FixedI32<Frac>>`[src]

`impl<'a, Frac> Div<&'a i32> for Wrapping<FixedI32<Frac>>`[src]

`type Output = Wrapping<FixedI32<Frac>>`

The resulting type after applying the / operator.

`fn div(self, other: &i32) -> Wrapping<FixedI32<Frac>>`[src]

`impl<'a, 'b, Frac> Div<&'a i32> for &'b Wrapping<FixedI32<Frac>>`[src]

`type Output = Wrapping<FixedI32<Frac>>`

The resulting type after applying the / operator.

`fn div(self, other: &i32) -> Wrapping<FixedI32<Frac>>`[src]

`impl<Frac> Div<i64> for Wrapping<FixedI64<Frac>>`[src]

`type Output = Wrapping<FixedI64<Frac>>`

The resulting type after applying the / operator.

`fn div(self, other: i64) -> Wrapping<FixedI64<Frac>>`[src]

`impl<'a, Frac> Div<i64> for &'a Wrapping<FixedI64<Frac>>`[src]

`type Output = Wrapping<FixedI64<Frac>>`

The resulting type after applying the / operator.

`fn div(self, other: i64) -> Wrapping<FixedI64<Frac>>`[src]

`impl<'a, Frac> Div<&'a i64> for Wrapping<FixedI64<Frac>>`[src]

`type Output = Wrapping<FixedI64<Frac>>`

The resulting type after applying the / operator.

`fn div(self, other: &i64) -> Wrapping<FixedI64<Frac>>`[src]

`impl<'a, 'b, Frac> Div<&'a i64> for &'b Wrapping<FixedI64<Frac>>`[src]

`type Output = Wrapping<FixedI64<Frac>>`

The resulting type after applying the / operator.

`fn div(self, other: &i64) -> Wrapping<FixedI64<Frac>>`[src]

`impl<Frac> Div<i128> for Wrapping<FixedI128<Frac>>`[src]

`type Output = Wrapping<FixedI128<Frac>>`

The resulting type after applying the / operator.

`fn div(self, other: i128) -> Wrapping<FixedI128<Frac>>`[src]

`impl<'a, Frac> Div<i128> for &'a Wrapping<FixedI128<Frac>>`[src]

`type Output = Wrapping<FixedI128<Frac>>`

The resulting type after applying the / operator.

`fn div(self, other: i128) -> Wrapping<FixedI128<Frac>>`[src]

`impl<'a, Frac> Div<&'a i128> for Wrapping<FixedI128<Frac>>`[src]

`type Output = Wrapping<FixedI128<Frac>>`

The resulting type after applying the / operator.

`fn div(self, other: &i128) -> Wrapping<FixedI128<Frac>>`[src]

`impl<'a, 'b, Frac> Div<&'a i128> for &'b Wrapping<FixedI128<Frac>>`[src]

`type Output = Wrapping<FixedI128<Frac>>`

The resulting type after applying the / operator.

`fn div(self, other: &i128) -> Wrapping<FixedI128<Frac>>`[src]

`impl<Frac> Div<u8> for Wrapping<FixedU8<Frac>>`[src]

`type Output = Wrapping<FixedU8<Frac>>`

The resulting type after applying the / operator.

`fn div(self, other: u8) -> Wrapping<FixedU8<Frac>>`[src]

`impl<'a, Frac> Div<u8> for &'a Wrapping<FixedU8<Frac>>`[src]

`type Output = Wrapping<FixedU8<Frac>>`

The resulting type after applying the / operator.

`fn div(self, other: u8) -> Wrapping<FixedU8<Frac>>`[src]

`impl<'a, Frac> Div<&'a u8> for Wrapping<FixedU8<Frac>>`[src]

`type Output = Wrapping<FixedU8<Frac>>`

The resulting type after applying the / operator.

`fn div(self, other: &u8) -> Wrapping<FixedU8<Frac>>`[src]

`impl<'a, 'b, Frac> Div<&'a u8> for &'b Wrapping<FixedU8<Frac>>`[src]

`type Output = Wrapping<FixedU8<Frac>>`

The resulting type after applying the / operator.

`fn div(self, other: &u8) -> Wrapping<FixedU8<Frac>>`[src]

`impl<Frac> Div<u16> for Wrapping<FixedU16<Frac>>`[src]

`type Output = Wrapping<FixedU16<Frac>>`

The resulting type after applying the / operator.

`fn div(self, other: u16) -> Wrapping<FixedU16<Frac>>`[src]

`impl<'a, Frac> Div<u16> for &'a Wrapping<FixedU16<Frac>>`[src]

`type Output = Wrapping<FixedU16<Frac>>`

The resulting type after applying the / operator.

`fn div(self, other: u16) -> Wrapping<FixedU16<Frac>>`[src]

`impl<'a, Frac> Div<&'a u16> for Wrapping<FixedU16<Frac>>`[src]

`type Output = Wrapping<FixedU16<Frac>>`

The resulting type after applying the / operator.

`fn div(self, other: &u16) -> Wrapping<FixedU16<Frac>>`[src]

`impl<'a, 'b, Frac> Div<&'a u16> for &'b Wrapping<FixedU16<Frac>>`[src]

`type Output = Wrapping<FixedU16<Frac>>`

The resulting type after applying the / operator.

`fn div(self, other: &u16) -> Wrapping<FixedU16<Frac>>`[src]

`impl<Frac> Div<u32> for Wrapping<FixedU32<Frac>>`[src]

`type Output = Wrapping<FixedU32<Frac>>`

The resulting type after applying the / operator.

`fn div(self, other: u32) -> Wrapping<FixedU32<Frac>>`[src]

`impl<'a, Frac> Div<u32> for &'a Wrapping<FixedU32<Frac>>`[src]

`type Output = Wrapping<FixedU32<Frac>>`

The resulting type after applying the / operator.

`fn div(self, other: u32) -> Wrapping<FixedU32<Frac>>`[src]

`impl<'a, Frac> Div<&'a u32> for Wrapping<FixedU32<Frac>>`[src]

`type Output = Wrapping<FixedU32<Frac>>`

The resulting type after applying the / operator.

`fn div(self, other: &u32) -> Wrapping<FixedU32<Frac>>`[src]

`impl<'a, 'b, Frac> Div<&'a u32> for &'b Wrapping<FixedU32<Frac>>`[src]

`type Output = Wrapping<FixedU32<Frac>>`

The resulting type after applying the / operator.

`fn div(self, other: &u32) -> Wrapping<FixedU32<Frac>>`[src]

`impl<Frac> Div<u64> for Wrapping<FixedU64<Frac>>`[src]

`type Output = Wrapping<FixedU64<Frac>>`

The resulting type after applying the / operator.

`fn div(self, other: u64) -> Wrapping<FixedU64<Frac>>`[src]

`impl<'a, Frac> Div<u64> for &'a Wrapping<FixedU64<Frac>>`[src]

`type Output = Wrapping<FixedU64<Frac>>`

The resulting type after applying the / operator.

`fn div(self, other: u64) -> Wrapping<FixedU64<Frac>>`[src]

`impl<'a, Frac> Div<&'a u64> for Wrapping<FixedU64<Frac>>`[src]

`type Output = Wrapping<FixedU64<Frac>>`

The resulting type after applying the / operator.

`fn div(self, other: &u64) -> Wrapping<FixedU64<Frac>>`[src]

`impl<'a, 'b, Frac> Div<&'a u64> for &'b Wrapping<FixedU64<Frac>>`[src]

`type Output = Wrapping<FixedU64<Frac>>`

The resulting type after applying the / operator.

`fn div(self, other: &u64) -> Wrapping<FixedU64<Frac>>`[src]

`impl<Frac> Div<u128> for Wrapping<FixedU128<Frac>>`[src]

`type Output = Wrapping<FixedU128<Frac>>`

The resulting type after applying the / operator.

`fn div(self, other: u128) -> Wrapping<FixedU128<Frac>>`[src]

`impl<'a, Frac> Div<u128> for &'a Wrapping<FixedU128<Frac>>`[src]

`type Output = Wrapping<FixedU128<Frac>>`

The resulting type after applying the / operator.

`fn div(self, other: u128) -> Wrapping<FixedU128<Frac>>`[src]

`impl<'a, Frac> Div<&'a u128> for Wrapping<FixedU128<Frac>>`[src]

`type Output = Wrapping<FixedU128<Frac>>`

The resulting type after applying the / operator.

`fn div(self, other: &u128) -> Wrapping<FixedU128<Frac>>`[src]

`impl<'a, 'b, Frac> Div<&'a u128> for &'b Wrapping<FixedU128<Frac>>`[src]

`type Output = Wrapping<FixedU128<Frac>>`

The resulting type after applying the / operator.

`fn div(self, other: &u128) -> Wrapping<FixedU128<Frac>>`[src]

`impl<F: Fixed> Neg for Wrapping<F>`[src]

`type Output = Wrapping<F>`

The resulting type after applying the - operator.

`fn neg(self) -> Wrapping<F>`[src]

`impl<'a, F: Fixed> Neg for &'a Wrapping<F>`[src]

`type Output = Wrapping<F>`

The resulting type after applying the - operator.

`fn neg(self) -> Wrapping<F>`[src]

`impl<F: Fixed> AddAssign<Wrapping<F>> for Wrapping<F>`[src]

`fn add_assign(&mut self, other: Wrapping<F>)`[src]

`impl<'a, F: Fixed> AddAssign<&'a Wrapping<F>> for Wrapping<F>`[src]

`fn add_assign(&mut self, other: &Wrapping<F>)`[src]

`impl<F: Fixed> SubAssign<Wrapping<F>> for Wrapping<F>`[src]

`fn sub_assign(&mut self, other: Wrapping<F>)`[src]

`impl<'a, F: Fixed> SubAssign<&'a Wrapping<F>> for Wrapping<F>`[src]

`fn sub_assign(&mut self, other: &Wrapping<F>)`[src]

`impl<F: Fixed> MulAssign<Wrapping<F>> for Wrapping<F>`[src]

`fn mul_assign(&mut self, other: Wrapping<F>)`[src]

`impl<'a, F: Fixed> MulAssign<&'a Wrapping<F>> for Wrapping<F>`[src]

`fn mul_assign(&mut self, other: &Wrapping<F>)`[src]

`impl<Frac> MulAssign<i8> for Wrapping<FixedI8<Frac>>`[src]

`fn mul_assign(&mut self, other: i8)`[src]

`impl<'a, Frac> MulAssign<&'a i8> for Wrapping<FixedI8<Frac>>`[src]

`fn mul_assign(&mut self, other: &i8)`[src]

`impl<Frac> MulAssign<i16> for Wrapping<FixedI16<Frac>>`[src]

`fn mul_assign(&mut self, other: i16)`[src]

`impl<'a, Frac> MulAssign<&'a i16> for Wrapping<FixedI16<Frac>>`[src]

`fn mul_assign(&mut self, other: &i16)`[src]

`impl<Frac> MulAssign<i32> for Wrapping<FixedI32<Frac>>`[src]

`fn mul_assign(&mut self, other: i32)`[src]

`impl<'a, Frac> MulAssign<&'a i32> for Wrapping<FixedI32<Frac>>`[src]

`fn mul_assign(&mut self, other: &i32)`[src]

`impl<Frac> MulAssign<i64> for Wrapping<FixedI64<Frac>>`[src]

`fn mul_assign(&mut self, other: i64)`[src]

`impl<'a, Frac> MulAssign<&'a i64> for Wrapping<FixedI64<Frac>>`[src]

`fn mul_assign(&mut self, other: &i64)`[src]

`impl<Frac> MulAssign<i128> for Wrapping<FixedI128<Frac>>`[src]

`fn mul_assign(&mut self, other: i128)`[src]

`impl<'a, Frac> MulAssign<&'a i128> for Wrapping<FixedI128<Frac>>`[src]

`fn mul_assign(&mut self, other: &i128)`[src]

`impl<Frac> MulAssign<u8> for Wrapping<FixedU8<Frac>>`[src]

`fn mul_assign(&mut self, other: u8)`[src]

`impl<'a, Frac> MulAssign<&'a u8> for Wrapping<FixedU8<Frac>>`[src]

`fn mul_assign(&mut self, other: &u8)`[src]

`impl<Frac> MulAssign<u16> for Wrapping<FixedU16<Frac>>`[src]

`fn mul_assign(&mut self, other: u16)`[src]

`impl<'a, Frac> MulAssign<&'a u16> for Wrapping<FixedU16<Frac>>`[src]

`fn mul_assign(&mut self, other: &u16)`[src]

`impl<Frac> MulAssign<u32> for Wrapping<FixedU32<Frac>>`[src]

`fn mul_assign(&mut self, other: u32)`[src]

`impl<'a, Frac> MulAssign<&'a u32> for Wrapping<FixedU32<Frac>>`[src]

`fn mul_assign(&mut self, other: &u32)`[src]

`impl<Frac> MulAssign<u64> for Wrapping<FixedU64<Frac>>`[src]

`fn mul_assign(&mut self, other: u64)`[src]

`impl<'a, Frac> MulAssign<&'a u64> for Wrapping<FixedU64<Frac>>`[src]

`fn mul_assign(&mut self, other: &u64)`[src]

`impl<Frac> MulAssign<u128> for Wrapping<FixedU128<Frac>>`[src]

`fn mul_assign(&mut self, other: u128)`[src]

`impl<'a, Frac> MulAssign<&'a u128> for Wrapping<FixedU128<Frac>>`[src]

`fn mul_assign(&mut self, other: &u128)`[src]

`impl<F: Fixed> DivAssign<Wrapping<F>> for Wrapping<F>`[src]

`fn div_assign(&mut self, other: Wrapping<F>)`[src]

`impl<'a, F: Fixed> DivAssign<&'a Wrapping<F>> for Wrapping<F>`[src]

`fn div_assign(&mut self, other: &Wrapping<F>)`[src]

`impl<Frac> DivAssign<i8> for Wrapping<FixedI8<Frac>>`[src]

`fn div_assign(&mut self, other: i8)`[src]

`impl<'a, Frac> DivAssign<&'a i8> for Wrapping<FixedI8<Frac>>`[src]

`fn div_assign(&mut self, other: &i8)`[src]

`impl<Frac> DivAssign<i16> for Wrapping<FixedI16<Frac>>`[src]

`fn div_assign(&mut self, other: i16)`[src]

`impl<'a, Frac> DivAssign<&'a i16> for Wrapping<FixedI16<Frac>>`[src]

`fn div_assign(&mut self, other: &i16)`[src]

`impl<Frac> DivAssign<i32> for Wrapping<FixedI32<Frac>>`[src]

`fn div_assign(&mut self, other: i32)`[src]

`impl<'a, Frac> DivAssign<&'a i32> for Wrapping<FixedI32<Frac>>`[src]

`fn div_assign(&mut self, other: &i32)`[src]

`impl<Frac> DivAssign<i64> for Wrapping<FixedI64<Frac>>`[src]

`fn div_assign(&mut self, other: i64)`[src]

`impl<'a, Frac> DivAssign<&'a i64> for Wrapping<FixedI64<Frac>>`[src]

`fn div_assign(&mut self, other: &i64)`[src]

`impl<Frac> DivAssign<i128> for Wrapping<FixedI128<Frac>>`[src]

`fn div_assign(&mut self, other: i128)`[src]

`impl<'a, Frac> DivAssign<&'a i128> for Wrapping<FixedI128<Frac>>`[src]

`fn div_assign(&mut self, other: &i128)`[src]

`impl<Frac> DivAssign<u8> for Wrapping<FixedU8<Frac>>`[src]

`fn div_assign(&mut self, other: u8)`[src]

`impl<'a, Frac> DivAssign<&'a u8> for Wrapping<FixedU8<Frac>>`[src]

`fn div_assign(&mut self, other: &u8)`[src]

`impl<Frac> DivAssign<u16> for Wrapping<FixedU16<Frac>>`[src]

`fn div_assign(&mut self, other: u16)`[src]

`impl<'a, Frac> DivAssign<&'a u16> for Wrapping<FixedU16<Frac>>`[src]

`fn div_assign(&mut self, other: &u16)`[src]

`impl<Frac> DivAssign<u32> for Wrapping<FixedU32<Frac>>`[src]

`fn div_assign(&mut self, other: u32)`[src]

`impl<'a, Frac> DivAssign<&'a u32> for Wrapping<FixedU32<Frac>>`[src]

`fn div_assign(&mut self, other: &u32)`[src]

`impl<Frac> DivAssign<u64> for Wrapping<FixedU64<Frac>>`[src]

`fn div_assign(&mut self, other: u64)`[src]

`impl<'a, Frac> DivAssign<&'a u64> for Wrapping<FixedU64<Frac>>`[src]

`fn div_assign(&mut self, other: &u64)`[src]

`impl<Frac> DivAssign<u128> for Wrapping<FixedU128<Frac>>`[src]

`fn div_assign(&mut self, other: u128)`[src]

`impl<'a, Frac> DivAssign<&'a u128> for Wrapping<FixedU128<Frac>>`[src]

`fn div_assign(&mut self, other: &u128)`[src]

`impl<Frac> RemAssign<i8> for Wrapping<FixedI8<Frac>>`[src]

`fn rem_assign(&mut self, other: i8)`[src]

`impl<'a, Frac> RemAssign<&'a i8> for Wrapping<FixedI8<Frac>>`[src]

`fn rem_assign(&mut self, other: &i8)`[src]

`impl<Frac> RemAssign<i16> for Wrapping<FixedI16<Frac>>`[src]

`fn rem_assign(&mut self, other: i16)`[src]

`impl<'a, Frac> RemAssign<&'a i16> for Wrapping<FixedI16<Frac>>`[src]

`fn rem_assign(&mut self, other: &i16)`[src]

`impl<Frac> RemAssign<i32> for Wrapping<FixedI32<Frac>>`[src]

`fn rem_assign(&mut self, other: i32)`[src]

`impl<'a, Frac> RemAssign<&'a i32> for Wrapping<FixedI32<Frac>>`[src]

`fn rem_assign(&mut self, other: &i32)`[src]

`impl<Frac> RemAssign<i64> for Wrapping<FixedI64<Frac>>`[src]

`fn rem_assign(&mut self, other: i64)`[src]

`impl<'a, Frac> RemAssign<&'a i64> for Wrapping<FixedI64<Frac>>`[src]

`fn rem_assign(&mut self, other: &i64)`[src]

`impl<Frac> RemAssign<i128> for Wrapping<FixedI128<Frac>>`[src]

`fn rem_assign(&mut self, other: i128)`[src]

`impl<'a, Frac> RemAssign<&'a i128> for Wrapping<FixedI128<Frac>>`[src]

`fn rem_assign(&mut self, other: &i128)`[src]

`impl<Frac> RemAssign<u8> for Wrapping<FixedU8<Frac>>`[src]

`fn rem_assign(&mut self, other: u8)`[src]

`impl<'a, Frac> RemAssign<&'a u8> for Wrapping<FixedU8<Frac>>`[src]

`fn rem_assign(&mut self, other: &u8)`[src]

`impl<Frac> RemAssign<u16> for Wrapping<FixedU16<Frac>>`[src]

`fn rem_assign(&mut self, other: u16)`[src]

`impl<'a, Frac> RemAssign<&'a u16> for Wrapping<FixedU16<Frac>>`[src]

`fn rem_assign(&mut self, other: &u16)`[src]

`impl<Frac> RemAssign<u32> for Wrapping<FixedU32<Frac>>`[src]

`fn rem_assign(&mut self, other: u32)`[src]

`impl<'a, Frac> RemAssign<&'a u32> for Wrapping<FixedU32<Frac>>`[src]

`fn rem_assign(&mut self, other: &u32)`[src]

`impl<Frac> RemAssign<u64> for Wrapping<FixedU64<Frac>>`[src]

`fn rem_assign(&mut self, other: u64)`[src]

`impl<'a, Frac> RemAssign<&'a u64> for Wrapping<FixedU64<Frac>>`[src]

`fn rem_assign(&mut self, other: &u64)`[src]

`impl<Frac> RemAssign<u128> for Wrapping<FixedU128<Frac>>`[src]

`fn rem_assign(&mut self, other: u128)`[src]

`impl<'a, Frac> RemAssign<&'a u128> for Wrapping<FixedU128<Frac>>`[src]

`fn rem_assign(&mut self, other: &u128)`[src]

`impl<F> Not for Wrapping<F> where F: Not<Output = F>,` [src]

`type Output = Wrapping<F>`

The resulting type after applying the ! operator.

`fn not(self) -> Wrapping<F>`[src]

`impl<'a, F> Not for &'a Wrapping<F> where &'a F: Not<Output = F>,` [src]

`type Output = Wrapping<F>`

The resulting type after applying the ! operator.

`fn not(self) -> Wrapping<F>`[src]

`impl<F> BitAnd<Wrapping<F>> for Wrapping<F> where F: BitAnd<F, Output = F>,` [src]

`type Output = Wrapping<F>`

The resulting type after applying the & operator.

`fn bitand(self, other: Wrapping<F>) -> Wrapping<F>`[src]

`impl<'a, F> BitAnd<Wrapping<F>> for &'a Wrapping<F> where &'a F: BitAnd<F, Output = F>,` [src]

`type Output = Wrapping<F>`

The resulting type after applying the & operator.

`fn bitand(self, other: Wrapping<F>) -> Wrapping<F>`[src]

`impl<'a, F> BitAnd<&'a Wrapping<F>> for Wrapping<F> where F: BitAnd<&'a F, Output = F>,` [src]

`type Output = Wrapping<F>`

The resulting type after applying the & operator.

`fn bitand(self, other: &'a Wrapping<F>) -> Wrapping<F>`[src]

`impl<'a, 'b, F> BitAnd<&'a Wrapping<F>> for &'b Wrapping<F> where &'b F: BitAnd<&'a F, Output = F>,` [src]

`type Output = Wrapping<F>`

The resulting type after applying the & operator.

`fn bitand(self, other: &'a Wrapping<F>) -> Wrapping<F>`[src]

`impl<F> BitOr<Wrapping<F>> for Wrapping<F> where F: BitOr<F, Output = F>,` [src]

`type Output = Wrapping<F>`

The resulting type after applying the | operator.

`fn bitor(self, other: Wrapping<F>) -> Wrapping<F>`[src]

`impl<'a, F> BitOr<Wrapping<F>> for &'a Wrapping<F> where &'a F: BitOr<F, Output = F>,` [src]

`type Output = Wrapping<F>`

The resulting type after applying the | operator.

`fn bitor(self, other: Wrapping<F>) -> Wrapping<F>`[src]

`impl<'a, F> BitOr<&'a Wrapping<F>> for Wrapping<F> where F: BitOr<&'a F, Output = F>,` [src]

`type Output = Wrapping<F>`

The resulting type after applying the | operator.

`fn bitor(self, other: &'a Wrapping<F>) -> Wrapping<F>`[src]

`impl<'a, 'b, F> BitOr<&'a Wrapping<F>> for &'b Wrapping<F> where &'b F: BitOr<&'a F, Output = F>,` [src]

`type Output = Wrapping<F>`

The resulting type after applying the | operator.

`fn bitor(self, other: &'a Wrapping<F>) -> Wrapping<F>`[src]

`impl<F> BitXor<Wrapping<F>> for Wrapping<F> where F: BitXor<F, Output = F>,` [src]

`type Output = Wrapping<F>`

The resulting type after applying the ^ operator.

`fn bitxor(self, other: Wrapping<F>) -> Wrapping<F>`[src]

`impl<'a, F> BitXor<Wrapping<F>> for &'a Wrapping<F> where &'a F: BitXor<F, Output = F>,` [src]

`type Output = Wrapping<F>`

The resulting type after applying the ^ operator.

`fn bitxor(self, other: Wrapping<F>) -> Wrapping<F>`[src]

`impl<'a, F> BitXor<&'a Wrapping<F>> for Wrapping<F> where F: BitXor<&'a F, Output = F>,` [src]

`type Output = Wrapping<F>`

The resulting type after applying the ^ operator.

`fn bitxor(self, other: &'a Wrapping<F>) -> Wrapping<F>`[src]

`impl<'a, 'b, F> BitXor<&'a Wrapping<F>> for &'b Wrapping<F> where &'b F: BitXor<&'a F, Output = F>,` [src]

`type Output = Wrapping<F>`

The resulting type after applying the ^ operator.

`fn bitxor(self, other: &'a Wrapping<F>) -> Wrapping<F>`[src]

`impl<F> Shl<i8> for Wrapping<F> where F: Shl<u32, Output = F>,` [src]

`type Output = Wrapping<F>`

The resulting type after applying the << operator.

`fn shl(self, other: i8) -> Wrapping<F>`[src]

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

`type Output = Wrapping<F>`

The resulting type after applying the << operator.

`fn shl(self, other: i8) -> Wrapping<F>`[src]

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

`type Output = Wrapping<F>`

The resulting type after applying the << operator.

`fn shl(self, other: &i8) -> Wrapping<F>`[src]

`impl<'a, 'b, F> Shl<&'a i8> for &'b Wrapping<F> where &'b F: Shl<u32, Output = F>,` [src]

`type Output = Wrapping<F>`

The resulting type after applying the << operator.

`fn shl(self, other: &i8) -> Wrapping<F>`[src]

`impl<F> Shl<i16> for Wrapping<F> where F: Shl<u32, Output = F>,` [src]

`type Output = Wrapping<F>`

The resulting type after applying the << operator.

`fn shl(self, other: i16) -> Wrapping<F>`[src]

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

`type Output = Wrapping<F>`

The resulting type after applying the << operator.

`fn shl(self, other: i16) -> Wrapping<F>`[src]

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

`type Output = Wrapping<F>`

The resulting type after applying the << operator.

`fn shl(self, other: &i16) -> Wrapping<F>`[src]

`impl<'a, 'b, F> Shl<&'a i16> for &'b Wrapping<F> where &'b F: Shl<u32, Output = F>,` [src]

`type Output = Wrapping<F>`

The resulting type after applying the << operator.

`fn shl(self, other: &i16) -> Wrapping<F>`[src]

`impl<F> Shl<i32> for Wrapping<F> where F: Shl<u32, Output = F>,` [src]

`type Output = Wrapping<F>`

The resulting type after applying the << operator.

`fn shl(self, other: i32) -> Wrapping<F>`[src]

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

`type Output = Wrapping<F>`

The resulting type after applying the << operator.

`fn shl(self, other: i32) -> Wrapping<F>`[src]

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

`type Output = Wrapping<F>`

The resulting type after applying the << operator.

`fn shl(self, other: &i32) -> Wrapping<F>`[src]

`impl<'a, 'b, F> Shl<&'a i32> for &'b Wrapping<F> where &'b F: Shl<u32, Output = F>,` [src]

`type Output = Wrapping<F>`

The resulting type after applying the << operator.

`fn shl(self, other: &i32) -> Wrapping<F>`[src]

`impl<F> Shl<i64> for Wrapping<F> where F: Shl<u32, Output = F>,` [src]

`type Output = Wrapping<F>`

The resulting type after applying the << operator.

`fn shl(self, other: i64) -> Wrapping<F>`[src]

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

`type Output = Wrapping<F>`

The resulting type after applying the << operator.

`fn shl(self, other: i64) -> Wrapping<F>`[src]

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

`type Output = Wrapping<F>`

The resulting type after applying the << operator.

`fn shl(self, other: &i64) -> Wrapping<F>`[src]

`impl<'a, 'b, F> Shl<&'a i64> for &'b Wrapping<F> where &'b F: Shl<u32, Output = F>,` [src]

`type Output = Wrapping<F>`

The resulting type after applying the << operator.

`fn shl(self, other: &i64) -> Wrapping<F>`[src]

`impl<F> Shl<i128> for Wrapping<F> where F: Shl<u32, Output = F>,` [src]

`type Output = Wrapping<F>`

The resulting type after applying the << operator.

`fn shl(self, other: i128) -> Wrapping<F>`[src]

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

`type Output = Wrapping<F>`

The resulting type after applying the << operator.

`fn shl(self, other: i128) -> Wrapping<F>`[src]

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

`type Output = Wrapping<F>`

The resulting type after applying the << operator.

`fn shl(self, other: &i128) -> Wrapping<F>`[src]

`impl<'a, 'b, F> Shl<&'a i128> for &'b Wrapping<F> where &'b F: Shl<u32, Output = F>,` [src]

`type Output = Wrapping<F>`

The resulting type after applying the << operator.

`fn shl(self, other: &i128) -> Wrapping<F>`[src]

`impl<F> Shl<isize> for Wrapping<F> where F: Shl<u32, Output = F>,` [src]

`type Output = Wrapping<F>`

The resulting type after applying the << operator.

`fn shl(self, other: isize) -> Wrapping<F>`[src]

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

`type Output = Wrapping<F>`

The resulting type after applying the << operator.

`fn shl(self, other: isize) -> Wrapping<F>`[src]

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

`type Output = Wrapping<F>`

The resulting type after applying the << operator.

`fn shl(self, other: &isize) -> Wrapping<F>`[src]

`impl<'a, 'b, F> Shl<&'a isize> for &'b Wrapping<F> where &'b F: Shl<u32, Output = F>,` [src]

`type Output = Wrapping<F>`

The resulting type after applying the << operator.

`fn shl(self, other: &isize) -> Wrapping<F>`[src]

`impl<F> Shl<u8> for Wrapping<F> where F: Shl<u32, Output = F>,` [src]

`type Output = Wrapping<F>`

The resulting type after applying the << operator.

`fn shl(self, other: u8) -> Wrapping<F>`[src]

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

`type Output = Wrapping<F>`

The resulting type after applying the << operator.

`fn shl(self, other: u8) -> Wrapping<F>`[src]

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

`type Output = Wrapping<F>`

The resulting type after applying the << operator.

`fn shl(self, other: &u8) -> Wrapping<F>`[src]

`impl<'a, 'b, F> Shl<&'a u8> for &'b Wrapping<F> where &'b F: Shl<u32, Output = F>,` [src]

`type Output = Wrapping<F>`

The resulting type after applying the << operator.

`fn shl(self, other: &u8) -> Wrapping<F>`[src]

`impl<F> Shl<u16> for Wrapping<F> where F: Shl<u32, Output = F>,` [src]

`type Output = Wrapping<F>`

The resulting type after applying the << operator.

`fn shl(self, other: u16) -> Wrapping<F>`[src]

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

`type Output = Wrapping<F>`

The resulting type after applying the << operator.

`fn shl(self, other: u16) -> Wrapping<F>`[src]

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

`type Output = Wrapping<F>`

The resulting type after applying the << operator.

`fn shl(self, other: &u16) -> Wrapping<F>`[src]

`impl<'a, 'b, F> Shl<&'a u16> for &'b Wrapping<F> where &'b F: Shl<u32, Output = F>,` [src]

`type Output = Wrapping<F>`

The resulting type after applying the << operator.

`fn shl(self, other: &u16) -> Wrapping<F>`[src]

`impl<F> Shl<u32> for Wrapping<F> where F: Shl<u32, Output = F>,` [src]

`type Output = Wrapping<F>`

The resulting type after applying the << operator.

`fn shl(self, other: u32) -> Wrapping<F>`[src]

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

`type Output = Wrapping<F>`

The resulting type after applying the << operator.

`fn shl(self, other: u32) -> Wrapping<F>`[src]

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

`type Output = Wrapping<F>`

The resulting type after applying the << operator.

`fn shl(self, other: &u32) -> Wrapping<F>`[src]

`impl<'a, 'b, F> Shl<&'a u32> for &'b Wrapping<F> where &'b F: Shl<u32, Output = F>,` [src]

`type Output = Wrapping<F>`

The resulting type after applying the << operator.

`fn shl(self, other: &u32) -> Wrapping<F>`[src]

`impl<F> Shl<u64> for Wrapping<F> where F: Shl<u32, Output = F>,` [src]

`type Output = Wrapping<F>`

The resulting type after applying the << operator.

`fn shl(self, other: u64) -> Wrapping<F>`[src]

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

`type Output = Wrapping<F>`

The resulting type after applying the << operator.

`fn shl(self, other: u64) -> Wrapping<F>`[src]

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

`type Output = Wrapping<F>`

The resulting type after applying the << operator.

`fn shl(self, other: &u64) -> Wrapping<F>`[src]

`impl<'a, 'b, F> Shl<&'a u64> for &'b Wrapping<F> where &'b F: Shl<u32, Output = F>,` [src]

`type Output = Wrapping<F>`

The resulting type after applying the << operator.

`fn shl(self, other: &u64) -> Wrapping<F>`[src]

`impl<F> Shl<u128> for Wrapping<F> where F: Shl<u32, Output = F>,` [src]

`type Output = Wrapping<F>`

The resulting type after applying the << operator.

`fn shl(self, other: u128) -> Wrapping<F>`[src]

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

`type Output = Wrapping<F>`

The resulting type after applying the << operator.

`fn shl(self, other: u128) -> Wrapping<F>`[src]

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

`type Output = Wrapping<F>`

The resulting type after applying the << operator.

`fn shl(self, other: &u128) -> Wrapping<F>`[src]

`impl<'a, 'b, F> Shl<&'a u128> for &'b Wrapping<F> where &'b F: Shl<u32, Output = F>,` [src]

`type Output = Wrapping<F>`

The resulting type after applying the << operator.

`fn shl(self, other: &u128) -> Wrapping<F>`[src]

`impl<F> Shl<usize> for Wrapping<F> where F: Shl<u32, Output = F>,` [src]

`type Output = Wrapping<F>`

The resulting type after applying the << operator.

`fn shl(self, other: usize) -> Wrapping<F>`[src]

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

`type Output = Wrapping<F>`

The resulting type after applying the << operator.

`fn shl(self, other: usize) -> Wrapping<F>`[src]

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

`type Output = Wrapping<F>`

The resulting type after applying the << operator.

`fn shl(self, other: &usize) -> Wrapping<F>`[src]

`impl<'a, 'b, F> Shl<&'a usize> for &'b Wrapping<F> where &'b F: Shl<u32, Output = F>,` [src]

`type Output = Wrapping<F>`

The resulting type after applying the << operator.