Struct fixed::Saturating

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

Provides saturating arithmetic on fixed-point numbers.

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

Examples

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

Tuple Fields

0: F

Implementations

impl<F: Fixed> Saturating<F>

pub const ZERO: Saturating<F> = _

Zero.

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

Examples

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

pub const DELTA: Saturating<F> = _

The difference between any two successive representable numbers, Δ.

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

Examples

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

pub const MIN: Saturating<F> = _

The smallest value that can be represented.

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

Examples

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

pub const MAX: Saturating<F> = _

The largest value that can be represented.

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

Examples

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

pub const IS_SIGNED: bool = F::IS_SIGNED

true if the type is signed.

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

Examples

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

pub const INT_NBITS: u32 = F::INT_NBITS

The number of integer bits.

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

Examples

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

pub const FRAC_NBITS: u32 = F::FRAC_NBITS

The number of fractional bits.

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

Examples

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

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

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

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

Examples

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

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

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

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

Examples

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

pub fn from_be(w: Self) -> Self

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

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

Examples

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

pub fn from_le(w: Self) -> Self

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

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

Examples

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

pub fn to_be(self) -> Self

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

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

Examples

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

pub fn to_le(self) -> Self

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

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

Examples

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

pub fn swap_bytes(self) -> Self

Reverses the byte order of the fixed-point number.

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

Examples

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

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

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

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

Examples

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

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

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

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

Examples

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

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

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

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

Examples

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

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

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

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

Examples

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

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

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

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

Examples

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

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

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

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

Examples

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

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

Saturating conversion from another number.

The other number can be:

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

See also FixedI32::saturating_from_num and FixedU32::saturating_from_num.

Panics

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

Examples

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

let src = I16F16::from_bits(0x1234_5678);
let dst = Saturating::<I4F4>::from_num(src);
assert_eq!(dst, Saturating(I4F4::MAX));

let src_int = 0x1234_i32;
let dst_int = Saturating::<I4F4>::from_num(src_int);
assert_eq!(dst_int, Saturating(I4F4::MAX));

let src_float = f64::NEG_INFINITY;
let dst_float = Saturating::<I4F4>::from_num(src_float);
assert_eq!(dst_float, Saturating(I4F4::MIN));

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

Converts a fixed-point number to another number, saturating the value on overflow.

The other number can be:

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

See also FixedI32::saturating_to_num and FixedU32::saturating_to_num.

Examples

use fixed::{
    types::{I16F16, I2F6, I4F4},
    Saturating,
};

// conversion that fits
let src = Saturating(I4F4::from_num(1.75));
let expected = I16F16::from_num(1.75);
assert_eq!(src.to_num::<I16F16>(), expected);

// conversion that saturates
let src = Saturating(I4F4::MAX);
assert_eq!(src.to_num::<I2F6>(), I2F6::MAX);

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

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

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

See also FixedI32::saturating_from_str_binary and FixedU32::saturating_from_str_binary.

Examples

use fixed::{types::I8F8, Saturating};
let max = Saturating(I8F8::MAX);
assert_eq!(Saturating::<I8F8>::from_str_binary("101100111000.1"), Ok(max));

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

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

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

See also FixedI32::saturating_from_str_octal and FixedU32::saturating_from_str_octal.

Examples

use fixed::{types::I8F8, Saturating};
let max = Saturating(I8F8::MAX);
assert_eq!(Saturating::<I8F8>::from_str_octal("7165.4"), Ok(max));

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

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

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

See also FixedI32::saturating_from_str_hex and FixedU32::saturating_from_str_hex.

Examples

use fixed::{types::I8F8, Saturating};
let max = Saturating(I8F8::MAX);
assert_eq!(Saturating::<I8F8>::from_str_hex("C0F.FE"), Ok(max));

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

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

Examples

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

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

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

Examples

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

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

Rounds to the next integer towards 0.

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

Examples

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

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

Saturating ceil. Rounds to the next integer towards +∞, saturating on overflow.

See also FixedI32::saturating_ceil and FixedU32::saturating_ceil.

Examples

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

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

Saturating floor. Rounds to the next integer towards −∞, saturating on overflow.

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

See also FixedI32::saturating_floor and FixedU32::saturating_floor.

Examples

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

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

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

See also FixedI32::saturating_round and FixedU32::saturating_round.

Examples

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

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

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

See also FixedI32::saturating_round_ties_to_even and FixedU32::saturating_round_ties_to_even.

Examples

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

pub fn count_ones(self) -> u32

Returns the number of ones in the binary representation.

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

Examples

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

pub fn count_zeros(self) -> u32

Returns the number of zeros in the binary representation.

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

Examples

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

pub fn leading_ones(self) -> u32

Returns the number of leading ones in the binary representation.

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

Examples

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

pub fn leading_zeros(self) -> u32

Returns the number of leading zeros in the binary representation.

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

Examples

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

pub fn trailing_ones(self) -> u32

Returns the number of trailing ones in the binary representation.

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

Examples

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

pub fn trailing_zeros(self) -> u32

Returns the number of trailing zeros in the binary representation.

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

Examples

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

pub fn sqrt(self) -> Self

Returns the square root.

See also FixedI32::sqrt and FixedU32::sqrt.

Panics

Panics if the number is negative.

Examples

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

// This method handles the overflow corner case.
let s = Saturating(I0F32::from_num(0.25));
assert_eq!(s.sqrt().0, I0F32::MAX);

pub fn int_log2(self) -> i32

Integer base-2 logarithm, rounded down.

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

Panics

Panics if the fixed-point number is ≤ 0.

pub fn int_log10(self) -> i32

Integer base-10 logarithm, rounded down.

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

Panics

Panics if the fixed-point number is ≤ 0.

pub fn int_log(self, base: u32) -> i32

Integer logarithm to the specified base, rounded down.

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

Panics

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

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

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

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

Examples

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

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

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

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

Examples

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

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

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

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

Examples

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

pub fn is_zero(self) -> bool

Returns true if the number is zero.

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

Examples

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

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

Returns the distance from self to other.

See also FixedI32::saturating_dist and FixedU32::saturating_dist.

Examples

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

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

Returns the mean of self and other.

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

Examples

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

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

Returns the reciprocal (inverse), 1/self.

See also FixedI32::saturating_recip and FixedU32::saturating_recip.

Panics

Panics if self is zero.

Examples

use fixed::{types::I8F24, Saturating};
let quarter = Saturating(I8F24::from_num(0.25));
let frac_1_512 = Saturating(I8F24::ONE / 512);
assert_eq!(quarter.recip(), Saturating(I8F24::from_num(4)));
assert_eq!(frac_1_512.recip(), Saturating(I8F24::MAX));

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

Returns the next multiple of other.

See also FixedI32::saturating_next_multiple_of and FixedU32::saturating_next_multiple_of.

Panics

Panics if other is zero.

Examples

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

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

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

Multiply and add. Returns self × mul + add.

See also FixedI32::saturating_mul_add and FixedU32::saturating_mul_add.

Examples

use fixed::{types::I16F16, Saturating};
let half = Saturating(I16F16::from_num(0.5));
let three = Saturating(I16F16::from_num(3));
let four = Saturating(I16F16::from_num(4));
let max = Saturating(I16F16::MAX);
assert_eq!(three.mul_add(half, four), Saturating(I16F16::from_num(5.5)));
assert_eq!(max.mul_add(three, max), max * 4);

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

Adds self to the product a × b.

See also FixedI32::saturating_add_prod and FixedU32::saturating_add_prod.

Examples

use fixed::{types::I16F16, Saturating};
let half = Saturating(I16F16::from_num(0.5));
let three = Saturating(I16F16::from_num(3));
let four = Saturating(I16F16::from_num(4));
let max = Saturating(I16F16::MAX);
assert_eq!(four.add_prod(three, half), Saturating(I16F16::from_num(5.5)));
assert_eq!(max.add_prod(max, three), max * 4);

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

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

See also FixedI32::saturating_mul_acc and FixedU32::saturating_mul_acc.

Examples

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

acc = Saturating(I16F16::MAX);
acc.mul_acc(Saturating(I16F16::MAX), Saturating(I16F16::from_num(3)));
assert_eq!(acc, Saturating(I16F16::MAX) * 4);

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

Euclidean division.

See also FixedI32::saturating_div_euclid and FixedU32::saturating_div_euclid.

Panics

Panics if the divisor is zero.

Examples

use fixed::{types::I16F16, Saturating};
let num = Saturating(I16F16::from_num(7.5));
let den = Saturating(I16F16::from_num(2));
assert_eq!(num.div_euclid(den), Saturating(I16F16::from_num(3)));
let quarter = Saturating(I16F16::from_num(0.25));
let max = Saturating(I16F16::MAX);
assert_eq!(max.div_euclid(quarter), max);

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

Remainder for Euclidean division.

See also FixedI32::rem_euclid and FixedU32::rem_euclid.

Panics

Panics if the divisor is zero.

Examples

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

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

Euclidean division by an integer.

See also FixedI32::saturating_div_euclid_int and FixedU32::saturating_div_euclid_int.

Panics

Panics if the divisor is zero.

Examples

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

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

Remainder for Euclidean division.

See also FixedI32::saturating_rem_euclid_int and FixedU32::saturating_rem_euclid_int.

Panics

Panics if the divisor is zero.

Examples

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

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

Linear interpolation between start and end.

See also FixedI32::saturating_lerp and FixedU32::saturating_lerp.

Examples

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

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

Inverse linear interpolation between start and end.

See also FixedI32::saturating_inv_lerp and FixedU32::saturating_inv_lerp.

Examples

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

impl<F: FixedSigned> Saturating<F>

pub fn signed_bits(self) -> u32

Returns the number of bits required to represent the value.

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

See also FixedI32::signed_bits.

Examples

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

pub fn is_positive(self) -> bool

Returns true if the number is > 0.

See also FixedI32::is_positive.

Examples

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

pub fn is_negative(self) -> bool

Returns true if the number is < 0.

See also FixedI32::is_negative.

Examples

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

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

Saturating absolute value. Returns the absolute value, saturating on overflow.

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

See also FixedI32::saturating_abs.

Examples

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

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

Returns a number representing the sign of self.

Warning

Using this method when 1 and −1 cannot be represented is almost certainly a bug, however, this is allowed and gives the following saturated results.

• When there are no integer bits, for example for the type Saturating<I0F16>, the return value is zero when self is zero, MIN when self is negative, and MAX when self is positive.
• When there is one integer bit, for example for the type Saturating<I1F15>, the return value is zero when self is zero, −1 when self is negative, and MAX when self is positive.

See also FixedI32::saturating_signum.

Examples

use fixed::{
    types::{I0F32, I1F31, I16F16},
    Saturating,
};
assert_eq!(Saturating(<I16F16>::from_num(-3.9)).signum(), Saturating(I16F16::NEG_ONE));
assert_eq!(Saturating(<I16F16>::ZERO).signum(), Saturating(I16F16::ZERO));
assert_eq!(Saturating(<I16F16>::from_num(3.9)).signum(), Saturating(I16F16::ONE));

assert_eq!(Saturating(<I1F31>::from_num(0.5)).signum(), Saturating(I1F31::MAX));
assert_eq!(Saturating(<I0F32>::from_num(0.25)).signum(), Saturating(I0F32::MAX));
assert_eq!(Saturating(<I0F32>::from_num(-0.5)).signum(), Saturating(I0F32::MIN));

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

Addition with an unsigned fixed-point number.

See also FixedI32::saturating_add_unsigned.

Examples

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

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

Subtraction with an unsigned fixed-point number.

See also FixedI32::saturating_sub_unsigned.

Examples

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

impl<F: FixedUnsigned> Saturating<F>

pub fn significant_bits(self) -> u32

Returns the number of bits required to represent the value.

See also FixedU32::significant_bits.

Examples

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

pub fn is_power_of_two(self) -> bool

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

See also FixedU32::is_power_of_two.

Examples

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

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

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

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

See also FixedU32::highest_one.

Examples

use fixed::{types::U16F16, Saturating};
type T = Saturating<U16F16>;
assert_eq!(T::from_bits(0b11_0010).highest_one(), T::from_bits(0b10_0000));
assert_eq!(T::from_num(0.3).highest_one(), T::from_num(0.25));
assert_eq!(T::from_num(4).highest_one(), T::from_num(4));
assert_eq!(T::from_num(6.5).highest_one(), T::from_num(4));
assert_eq!(T::ZERO.highest_one(), T::ZERO);

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

Addition with an signed fixed-point number.

See also FixedU32::saturating_add_signed.

Examples

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

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

Subtraction with an signed fixed-point number.

See also FixedU32::saturating_sub_signed.

Examples

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

Trait Implementations

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

type Output = Saturating<F>

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = Saturating<F>

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = Saturating<F>

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = Saturating<F>

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

Performs the += operation.

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

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

Performs the += operation.

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

fn add_assign(&mut self, other: F)

Performs the += operation.

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

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

Performs the += operation.

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

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

Formats the value using the given formatter.

impl<F> BitAnd<&Saturating<F>> for &Saturating<F>

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

type Output = Saturating<F>

The resulting type after applying the & operator.

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

Performs the & operation.

impl<F> BitAnd<&Saturating<F>> for Saturating<F>

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

type Output = Saturating<F>

The resulting type after applying the & operator.

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

Performs the & operation.

impl<F> BitAnd<Saturating<F>> for &Saturating<F>

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

type Output = Saturating<F>

The resulting type after applying the & operator.

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

Performs the & operation.

impl<F> BitAnd for Saturating<F>

where F: BitAnd<F, Output = F>,

type Output = Saturating<F>

The resulting type after applying the & operator.

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

Performs the & operation.

impl<F> BitAndAssign<&F> for Saturating<F>

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

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

Performs the &= operation.

impl<F> BitAndAssign<&Saturating<F>> for Saturating<F>

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

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

Performs the &= operation.

impl<F> BitAndAssign<F> for Saturating<F>

where F: BitAndAssign<F>,

fn bitand_assign(&mut self, other: F)

Performs the &= operation.

impl<F> BitAndAssign for Saturating<F>

where F: BitAndAssign<F>,

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

Performs the &= operation.

impl<F> BitOr<&Saturating<F>> for &Saturating<F>

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

type Output = Saturating<F>

The resulting type after applying the | operator.

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

Performs the | operation.

impl<F> BitOr<&Saturating<F>> for Saturating<F>

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

type Output = Saturating<F>

The resulting type after applying the | operator.

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

Performs the | operation.

impl<F> BitOr<Saturating<F>> for &Saturating<F>

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

type Output = Saturating<F>

The resulting type after applying the | operator.

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

Performs the | operation.

impl<F> BitOr for Saturating<F>

where F: BitOr<F, Output = F>,

type Output = Saturating<F>

The resulting type after applying the | operator.

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

Performs the | operation.

impl<F> BitOrAssign<&F> for Saturating<F>

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

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

Performs the |= operation.

impl<F> BitOrAssign<&Saturating<F>> for Saturating<F>

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

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

Performs the |= operation.

impl<F> BitOrAssign<F> for Saturating<F>

where F: BitOrAssign<F>,

fn bitor_assign(&mut self, other: F)

Performs the |= operation.

impl<F> BitOrAssign for Saturating<F>

where F: BitOrAssign<F>,

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

Performs the |= operation.

impl<F> BitXor<&Saturating<F>> for &Saturating<F>

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

type Output = Saturating<F>

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<F> BitXor<&Saturating<F>> for Saturating<F>

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

type Output = Saturating<F>

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<F> BitXor<Saturating<F>> for &Saturating<F>

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

type Output = Saturating<F>

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<F> BitXor for Saturating<F>

where F: BitXor<F, Output = F>,

type Output = Saturating<F>

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<F> BitXorAssign<&F> for Saturating<F>

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

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

Performs the ^= operation.

impl<F> BitXorAssign<&Saturating<F>> for Saturating<F>

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

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

Performs the ^= operation.

impl<F> BitXorAssign<F> for Saturating<F>

where F: BitXorAssign<F>,

fn bitxor_assign(&mut self, other: F)

Performs the ^= operation.

impl<F> BitXorAssign for Saturating<F>

where F: BitXorAssign<F>,

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

Performs the ^= operation.

impl<F: Clone> Clone for Saturating<F>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

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

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

Formats the value using the given formatter.

impl<F: Default> Default for Saturating<F>

fn default() -> Saturating<F>

Returns the “default value” for a type.

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

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

Formats the value using the given formatter.

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

type Output = Saturating<F>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Saturating<F>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Saturating<FixedI128<Frac>>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Saturating<FixedI128<Frac>>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Saturating<FixedI16<Frac>>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Saturating<FixedI16<Frac>>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Saturating<FixedI32<Frac>>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Saturating<FixedI32<Frac>>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Saturating<FixedI64<Frac>>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Saturating<FixedI64<Frac>>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Saturating<FixedI8<Frac>>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Saturating<FixedI8<Frac>>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Saturating<FixedU128<Frac>>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Saturating<FixedU128<Frac>>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Saturating<FixedU16<Frac>>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Saturating<FixedU16<Frac>>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Saturating<FixedU32<Frac>>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Saturating<FixedU32<Frac>>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Saturating<FixedU64<Frac>>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Saturating<FixedU64<Frac>>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Saturating<FixedU8<Frac>>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Saturating<FixedU8<Frac>>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Saturating<F>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Saturating<FixedI128<Frac>>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Saturating<FixedI128<Frac>>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Saturating<FixedI16<Frac>>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Saturating<FixedI16<Frac>>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Saturating<FixedI32<Frac>>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Saturating<FixedI32<Frac>>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Saturating<FixedI64<Frac>>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Saturating<FixedI64<Frac>>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Saturating<FixedI8<Frac>>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Saturating<FixedI8<Frac>>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Saturating<FixedU128<Frac>>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Saturating<FixedU128<Frac>>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Saturating<FixedU16<Frac>>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Saturating<FixedU16<Frac>>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Saturating<FixedU32<Frac>>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Saturating<FixedU32<Frac>>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Saturating<FixedU64<Frac>>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Saturating<FixedU64<Frac>>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Saturating<FixedU8<Frac>>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Saturating<FixedU8<Frac>>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Saturating<F>

The resulting type after applying the / operator.

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

Performs the / operation.

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

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

Performs the /= operation.

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

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

Performs the /= operation.

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

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

Performs the /= operation.

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

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

Performs the /= operation.

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

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

Performs the /= operation.

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

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

Performs the /= operation.

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

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

Performs the /= operation.

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

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

Performs the /= operation.

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

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

Performs the /= operation.

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

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

Performs the /= operation.

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

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

Performs the /= operation.

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

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

Performs the /= operation.

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

fn div_assign(&mut self, other: F)

Performs the /= operation.

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

fn div_assign(&mut self, other: i128)

Performs the /= operation.

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

fn div_assign(&mut self, other: i16)

Performs the /= operation.

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

fn div_assign(&mut self, other: i32)

Performs the /= operation.

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

fn div_assign(&mut self, other: i64)

Performs the /= operation.

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

fn div_assign(&mut self, other: i8)

Performs the /= operation.

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

fn div_assign(&mut self, other: u128)

Performs the /= operation.

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

fn div_assign(&mut self, other: u16)

Performs the /= operation.

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

fn div_assign(&mut self, other: u32)

Performs the /= operation.

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

fn div_assign(&mut self, other: u64)

Performs the /= operation.

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

fn div_assign(&mut self, other: u8)

Performs the /= operation.

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

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

Performs the /= operation.

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

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

Saturates a fixed-point number.

impl<F: Fixed> FromStr for Saturating<F>

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

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

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

type Err = ParseFixedError

The associated error which can be returned from parsing.

impl<F: Hash> Hash for Saturating<F>

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

Feeds this value into the given Hasher.

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

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<F: Fixed> LowerExp for Saturating<F>

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

Formats the value using the given formatter.

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

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

Formats the value using the given formatter.

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

type Output = Saturating<F>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Saturating<F>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Saturating<FixedI128<Frac>>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Saturating<FixedI128<Frac>>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Saturating<FixedI16<Frac>>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Saturating<FixedI16<Frac>>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Saturating<FixedI32<Frac>>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Saturating<FixedI32<Frac>>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Saturating<FixedI64<Frac>>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Saturating<FixedI64<Frac>>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Saturating<FixedI8<Frac>>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Saturating<FixedI8<Frac>>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Saturating<FixedU128<Frac>>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Saturating<FixedU128<Frac>>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Saturating<FixedU16<Frac>>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Saturating<FixedU16<Frac>>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Saturating<FixedU32<Frac>>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Saturating<FixedU32<Frac>>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Saturating<FixedU64<Frac>>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Saturating<FixedU64<Frac>>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Saturating<FixedU8<Frac>>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Saturating<FixedU8<Frac>>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Saturating<F>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Saturating<FixedI128<Frac>>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Saturating<FixedI128<Frac>>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Saturating<FixedI16<Frac>>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Saturating<FixedI16<Frac>>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Saturating<FixedI32<Frac>>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Saturating<FixedI32<Frac>>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Saturating<FixedI64<Frac>>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Saturating<FixedI64<Frac>>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Saturating<FixedI8<Frac>>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Saturating<FixedI8<Frac>>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Saturating<FixedU128<Frac>>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Saturating<FixedU128<Frac>>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Saturating<FixedU16<Frac>>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Saturating<FixedU16<Frac>>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Saturating<FixedU32<Frac>>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Saturating<FixedU32<Frac>>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Saturating<FixedU64<Frac>>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Saturating<FixedU64<Frac>>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Saturating<FixedU8<Frac>>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Saturating<FixedU8<Frac>>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Saturating<F>

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

Performs the *= operation.

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

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

Performs the *= operation.

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

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

Performs the *= operation.

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

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

Performs the *= operation.

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

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

Performs the *= operation.

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

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

Performs the *= operation.

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

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

Performs the *= operation.

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

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

Performs the *= operation.

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

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

Performs the *= operation.

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

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

Performs the *= operation.

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

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

Performs the *= operation.

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

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

Performs the *= operation.

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

fn mul_assign(&mut self, other: F)

Performs the *= operation.

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

fn mul_assign(&mut self, other: i128)

Performs the *= operation.

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

fn mul_assign(&mut self, other: i16)

Performs the *= operation.

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

fn mul_assign(&mut self, other: i32)

Performs the *= operation.

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

fn mul_assign(&mut self, other: i64)

Performs the *= operation.

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

fn mul_assign(&mut self, other: i8)

Performs the *= operation.

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

fn mul_assign(&mut self, other: u128)

Performs the *= operation.

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

fn mul_assign(&mut self, other: u16)

Performs the *= operation.

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

fn mul_assign(&mut self, other: u32)

Performs the *= operation.

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

fn mul_assign(&mut self, other: u64)

Performs the *= operation.

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

fn mul_assign(&mut self, other: u8)

Performs the *= operation.

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

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

Performs the *= operation.

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

type Output = Saturating<F>

The resulting type after applying the - operator.

fn neg(self) -> Saturating<F>

Performs the unary - operation.

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

type Output = Saturating<F>

The resulting type after applying the - operator.

fn neg(self) -> Saturating<F>

Performs the unary - operation.

impl<F> Not for &Saturating<F>

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

type Output = Saturating<F>

The resulting type after applying the ! operator.

fn not(self) -> Saturating<F>

Performs the unary ! operation.

impl<F> Not for Saturating<F>

where F: Not<Output = F>,

type Output = Saturating<F>

The resulting type after applying the ! operator.

fn not(self) -> Saturating<F>

Performs the unary ! operation.

impl<F: Fixed> Octal for Saturating<F>

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

Formats the value using the given formatter.

impl<F: Ord> Ord for Saturating<F>

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

This method returns an Ordering between self and other.

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

where Self: Sized,

Compares and returns the maximum of two values.

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

where Self: Sized,

Compares and returns the minimum of two values.

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

where Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl<F: PartialEq> PartialEq for Saturating<F>

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

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

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

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

impl<F: PartialOrd> PartialOrd for Saturating<F>

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

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

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

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

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

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

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

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

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

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

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

fn product<I>(iter: I) -> Saturating<F>

where I: Iterator<Item = &'a Saturating<F>>,

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

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

fn product<I>(iter: I) -> Saturating<F>

where I: Iterator<Item = Saturating<F>>,

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

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

type Output = Saturating<F>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Saturating<F>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Saturating<FixedI128<Frac>>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Saturating<FixedI128<Frac>>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Saturating<FixedI16<Frac>>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Saturating<FixedI16<Frac>>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Saturating<FixedI32<Frac>>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Saturating<FixedI32<Frac>>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Saturating<FixedI64<Frac>>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Saturating<FixedI64<Frac>>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Saturating<FixedI8<Frac>>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Saturating<FixedI8<Frac>>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Saturating<FixedU128<Frac>>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Saturating<FixedU128<Frac>>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Saturating<FixedU16<Frac>>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Saturating<FixedU16<Frac>>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Saturating<FixedU32<Frac>>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Saturating<FixedU32<Frac>>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Saturating<FixedU64<Frac>>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Saturating<FixedU64<Frac>>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Saturating<FixedU8<Frac>>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Saturating<FixedU8<Frac>>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Saturating<F>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Saturating<FixedI128<Frac>>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Saturating<FixedI128<Frac>>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Saturating<FixedI16<Frac>>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Saturating<FixedI16<Frac>>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Saturating<FixedI32<Frac>>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Saturating<FixedI32<Frac>>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Saturating<FixedI64<Frac>>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Saturating<FixedI64<Frac>>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Saturating<FixedI8<Frac>>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Saturating<FixedI8<Frac>>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Saturating<FixedU128<Frac>>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Saturating<FixedU128<Frac>>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Saturating<FixedU16<Frac>>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Saturating<FixedU16<Frac>>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Saturating<FixedU32<Frac>>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Saturating<FixedU32<Frac>>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Saturating<FixedU64<Frac>>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Saturating<FixedU64<Frac>>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Saturating<FixedU8<Frac>>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Saturating<FixedU8<Frac>>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Saturating<F>

The resulting type after applying the % operator.

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

Performs the % operation.

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

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

Performs the %= operation.

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

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

Performs the %= operation.

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

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

Performs the %= operation.

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

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

Performs the %= operation.

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

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

Performs the %= operation.

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

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

Performs the %= operation.

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

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

Performs the %= operation.

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

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

Performs the %= operation.

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

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

Performs the %= operation.

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

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

Performs the %= operation.

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

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

Performs the %= operation.

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

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

Performs the %= operation.

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

fn rem_assign(&mut self, other: F)

Performs the %= operation.

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

fn rem_assign(&mut self, other: i128)

Performs the %= operation.

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

fn rem_assign(&mut self, other: i16)

Performs the %= operation.

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

fn rem_assign(&mut self, other: i32)

Performs the %= operation.

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

fn rem_assign(&mut self, other: i64)

Performs the %= operation.

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

fn rem_assign(&mut self, other: i8)

Performs the %= operation.

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

fn rem_assign(&mut self, other: u128)

Performs the %= operation.

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

fn rem_assign(&mut self, other: u16)

Performs the %= operation.

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

fn rem_assign(&mut self, other: u32)

Performs the %= operation.

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

fn rem_assign(&mut self, other: u64)

Performs the %= operation.

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

fn rem_assign(&mut self, other: u8)

Performs the %= operation.

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

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

Performs the %= operation.

impl<F: Fixed> Sub<&Saturating<F>> for &Saturating<F>

type Output = Saturating<F>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<F: Fixed> Sub<&Saturating<F>> for Saturating<F>

type Output = Saturating<F>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<F: Fixed> Sub<Saturating<F>> for &Saturating<F>

type Output = Saturating<F>

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = Saturating<F>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<F: Fixed> SubAssign<&F> for Saturating<F>

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

Performs the -= operation.

impl<F: Fixed> SubAssign<&Saturating<F>> for Saturating<F>

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

Performs the -= operation.

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

fn sub_assign(&mut self, other: F)

Performs the -= operation.

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

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

Performs the -= operation.

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

fn sum<I>(iter: I) -> Saturating<F>

where I: Iterator<Item = &'a Saturating<F>>,

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

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

fn sum<I>(iter: I) -> Saturating<F>

where I: Iterator<Item = Saturating<F>>,

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

impl<F: Fixed> UpperExp for Saturating<F>

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

Formats the value using the given formatter.

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

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

Formats the value using the given formatter.

impl<F: Copy> Copy for Saturating<F>

impl<F: Eq> Eq for Saturating<F>

impl<F> StructuralPartialEq for Saturating<F>