Trait Fixed

pub trait Fixed
where
    Self: Copy + Default + Hash + Ord + Debug + Display + Binary + Octal + LowerHex + UpperHex + FromStr<Err = ParseFixedError> + FromFixed + ToFixed + Add<Output = Self> + AddAssign + Sub<Output = Self> + SubAssign + Mul<Output = Self> + MulAssign + Div<Output = Self> + DivAssign + Rem<Output = Self> + RemAssign + Mul<Self::Bits, Output = Self> + MulAssign<Self::Bits> + Div<Self::Bits, Output = Self> + DivAssign<Self::Bits> + Rem<Self::Bits, Output = Self> + RemAssign<Self::Bits> + Not<Output = Self> + BitAnd<Output = Self> + BitAndAssign + BitOr<Output = Self> + BitOrAssign + BitXor<Output = Self> + BitXorAssign + Shl<u32, Output = Self> + ShlAssign<u32> + Shr<u32, Output = Self> + ShrAssign<u32> + PartialOrd<i8> + PartialOrd<i16> + PartialOrd<i32> + PartialOrd<i64> + PartialOrd<i128> + PartialOrd<isize> + PartialOrd<u8> + PartialOrd<u16> + PartialOrd<u32> + PartialOrd<u64> + PartialOrd<u128> + PartialOrd<usize> + PartialOrd<f32> + PartialOrd<f64> + FixedOptionalFeatures + Sealed,
{
    type Bits;
    type Bytes;
    type Frac: Unsigned;

    // Required methods
    fn min_value() -> Self;
    fn max_value() -> Self;
    fn int_nbits() -> u32;
    fn frac_nbits() -> u32;
    fn from_bits(bits: Self::Bits) -> Self;
    fn to_bits(self) -> Self::Bits;
    fn from_be_bytes(bytes: Self::Bytes) -> Self;
    fn from_le_bytes(bytes: Self::Bytes) -> Self;
    fn from_ne_bytes(bytes: Self::Bytes) -> Self;
    fn to_be_bytes(self) -> Self::Bytes;
    fn to_le_bytes(self) -> Self::Bytes;
    fn to_ne_bytes(self) -> Self::Bytes;
    fn from_num<Src: ToFixed>(src: Src) -> Self;
    fn to_num<Dst: FromFixed>(self) -> Dst;
    fn checked_from_num<Src: ToFixed>(src: Src) -> Option<Self>;
    fn checked_to_num<Dst: FromFixed>(self) -> Option<Dst>;
    fn saturating_from_num<Src: ToFixed>(src: Src) -> Self;
    fn saturating_to_num<Dst: FromFixed>(self) -> Dst;
    fn wrapping_from_num<Src: ToFixed>(src: Src) -> Self;
    fn wrapping_to_num<Dst: FromFixed>(self) -> Dst;
    fn overflowing_from_num<Src: ToFixed>(src: Src) -> (Self, bool);
    fn overflowing_to_num<Dst: FromFixed>(self) -> (Dst, bool);
    fn from_str_binary(src: &str) -> Result<Self, ParseFixedError>;
    fn from_str_octal(src: &str) -> Result<Self, ParseFixedError>;
    fn from_str_hex(src: &str) -> Result<Self, ParseFixedError>;
    fn saturating_from_str(src: &str) -> Result<Self, ParseFixedError>;
    fn saturating_from_str_binary(src: &str) -> Result<Self, ParseFixedError>;
    fn saturating_from_str_octal(src: &str) -> Result<Self, ParseFixedError>;
    fn saturating_from_str_hex(src: &str) -> Result<Self, ParseFixedError>;
    fn wrapping_from_str(src: &str) -> Result<Self, ParseFixedError>;
    fn wrapping_from_str_binary(src: &str) -> Result<Self, ParseFixedError>;
    fn wrapping_from_str_octal(src: &str) -> Result<Self, ParseFixedError>;
    fn wrapping_from_str_hex(src: &str) -> Result<Self, ParseFixedError>;
    fn overflowing_from_str(src: &str) -> Result<(Self, bool), ParseFixedError>;
    fn overflowing_from_str_binary(
        src: &str,
    ) -> Result<(Self, bool), ParseFixedError>;
    fn overflowing_from_str_octal(
        src: &str,
    ) -> Result<(Self, bool), ParseFixedError>;
    fn overflowing_from_str_hex(
        src: &str,
    ) -> Result<(Self, bool), ParseFixedError>;
    fn int(self) -> Self;
    fn frac(self) -> Self;
    fn round_to_zero(self) -> Self;
    fn ceil(self) -> Self;
    fn floor(self) -> Self;
    fn round(self) -> Self;
    fn round_ties_to_even(self) -> Self;
    fn checked_ceil(self) -> Option<Self>;
    fn checked_floor(self) -> Option<Self>;
    fn checked_round(self) -> Option<Self>;
    fn checked_round_ties_to_even(self) -> Option<Self>;
    fn saturating_ceil(self) -> Self;
    fn saturating_floor(self) -> Self;
    fn saturating_round(self) -> Self;
    fn saturating_round_ties_to_even(self) -> Self;
    fn wrapping_ceil(self) -> Self;
    fn wrapping_floor(self) -> Self;
    fn wrapping_round(self) -> Self;
    fn wrapping_round_ties_to_even(self) -> Self;
    fn overflowing_ceil(self) -> (Self, bool);
    fn overflowing_floor(self) -> (Self, bool);
    fn overflowing_round(self) -> (Self, bool);
    fn overflowing_round_ties_to_even(self) -> (Self, bool);
    fn count_ones(self) -> u32;
    fn count_zeros(self) -> u32;
    fn leading_zeros(self) -> u32;
    fn trailing_zeros(self) -> u32;
    fn rotate_left(self, n: u32) -> Self;
    fn rotate_right(self, n: u32) -> Self;
    fn div_euclid(self, rhs: Self) -> Self;
    fn rem_euclid(self, rhs: Self) -> Self;
    fn div_euclid_int(self, rhs: Self::Bits) -> Self;
    fn rem_euclid_int(self, rhs: Self::Bits) -> Self;
    fn checked_neg(self) -> Option<Self>;
    fn checked_add(self, rhs: Self) -> Option<Self>;
    fn checked_sub(self, rhs: Self) -> Option<Self>;
    fn checked_mul(self, rhs: Self) -> Option<Self>;
    fn checked_div(self, rhs: Self) -> Option<Self>;
    fn checked_rem(self, rhs: Self) -> Option<Self>;
    fn checked_div_euclid(self, rhs: Self) -> Option<Self>;
    fn checked_rem_euclid(self, rhs: Self) -> Option<Self>;
    fn checked_mul_int(self, rhs: Self::Bits) -> Option<Self>;
    fn checked_div_int(self, rhs: Self::Bits) -> Option<Self>;
    fn checked_rem_int(self, rhs: Self::Bits) -> Option<Self>;
    fn checked_div_euclid_int(self, rhs: Self::Bits) -> Option<Self>;
    fn checked_rem_euclid_int(self, rhs: Self::Bits) -> Option<Self>;
    fn checked_shl(self, rhs: u32) -> Option<Self>;
    fn checked_shr(self, rhs: u32) -> Option<Self>;
    fn saturating_neg(self) -> Self;
    fn saturating_add(self, rhs: Self) -> Self;
    fn saturating_sub(self, rhs: Self) -> Self;
    fn saturating_mul(self, rhs: Self) -> Self;
    fn saturating_div(self, rhs: Self) -> Self;
    fn saturating_div_euclid(self, rhs: Self) -> Self;
    fn saturating_mul_int(self, rhs: Self::Bits) -> Self;
    fn wrapping_neg(self) -> Self;
    fn wrapping_add(self, rhs: Self) -> Self;
    fn wrapping_sub(self, rhs: Self) -> Self;
    fn wrapping_mul(self, rhs: Self) -> Self;
    fn wrapping_div(self, rhs: Self) -> Self;
    fn wrapping_div_euclid(self, rhs: Self) -> Self;
    fn wrapping_mul_int(self, rhs: Self::Bits) -> Self;
    fn wrapping_div_int(self, rhs: Self::Bits) -> Self;
    fn wrapping_div_euclid_int(self, rhs: Self::Bits) -> Self;
    fn wrapping_rem_euclid_int(self, rhs: Self::Bits) -> Self;
    fn wrapping_shl(self, rhs: u32) -> Self;
    fn wrapping_shr(self, rhs: u32) -> Self;
    fn overflowing_neg(self) -> (Self, bool);
    fn overflowing_add(self, rhs: Self) -> (Self, bool);
    fn overflowing_sub(self, rhs: Self) -> (Self, bool);
    fn overflowing_mul(self, rhs: Self) -> (Self, bool);
    fn overflowing_div(self, rhs: Self) -> (Self, bool);
    fn overflowing_div_euclid(self, rhs: Self) -> (Self, bool);
    fn overflowing_mul_int(self, rhs: Self::Bits) -> (Self, bool);
    fn overflowing_div_int(self, rhs: Self::Bits) -> (Self, bool);
    fn overflowing_div_euclid_int(self, rhs: Self::Bits) -> (Self, bool);
    fn overflowing_rem_euclid_int(self, rhs: Self::Bits) -> (Self, bool);
    fn overflowing_shl(self, rhs: u32) -> (Self, bool);
    fn overflowing_shr(self, rhs: u32) -> (Self, bool);

    // Provided methods
    fn wrapping_rem_int(self, rhs: Self::Bits) -> Self { ... }
    fn overflowing_rem_int(self, rhs: Self::Bits) -> (Self, bool) { ... }
}

This trait provides methods common to all fixed-point numbers.

It can be helpful when writing generic code that makes use of fixed-point numbers. For methods only available on signed fixed-point numbers, use the FixedSigned trait instead, and for methods only available on unsigned fixed-point numbers, use FixedUnsigned.

This trait is sealed and cannot be implemented for more types; it is implemented for FixedI8, FixedI16, FixedI32, FixedI64, FixedI128, FixedU8, FixedU16, FixedU32, FixedU64, and FixedU128.

Examples

use substrate_fixed::{
    traits::Fixed,
    types::{I8F8, I16F16},
};

fn checked_add_twice<F: Fixed>(lhs: F, rhs: F) -> Option<F> {
    lhs.checked_add(rhs)?.checked_add(rhs)
}

let val1 = checked_add_twice(I8F8::from_num(5), Fixed::from_num(1.75));
assert_eq!(val1, Some(Fixed::from_num(8.5)));
// can use with different fixed-point type
let val2 = checked_add_twice(I16F16::from_num(5), Fixed::from_num(1.75));
assert_eq!(val2, Some(Fixed::from_num(8.5)));

The following example fails to compile, since the compiler cannot infer that 500 in the checked_mul_int call is of type F::Bits.

use substrate_fixed::traits::Fixed;

fn checked_add_times_500<F: Fixed>(lhs: F, rhs: F) -> Option<F> {
    rhs.checked_mul_int(500)?.checked_add(lhs)
}

One way to fix this is to add a trait bound indicating that any u16 (which can represent 500) can be converted into F::Bits.

use substrate_fixed::{traits::Fixed, types::U12F4};

fn checked_add_times_500<F: Fixed>(lhs: F, rhs: F) -> Option<F>
where
    u16: Into<F::Bits>,
{
    rhs.checked_mul_int(500.into())?.checked_add(lhs)
}

let val = checked_add_times_500(U12F4::from_num(0.25), Fixed::from_num(1.5));
assert_eq!(val, Some(Fixed::from_num(750.25)));

While this works in most cases, u16 cannot be converted to i16, even if the value 500 does fit in i16, so that the following example would fail to compile.

use substrate_fixed::{traits::Fixed, types::I12F4};

fn checked_add_times_500<F: Fixed>(lhs: F, rhs: F) -> Option<F>
where
    u16: Into<F::Bits>,
{
    rhs.checked_mul_int(500.into())?.checked_add(lhs)
}

// I12F4::Bits is i16, and u16 does not implement Into<i16>
let val = checked_add_times_500(I12F4::from_num(0.25), Fixed::from_num(1.5));

We can use TryFrom to fix this, as we know that F::Bits::try_from(500_u16) will work for both u16 and i16. (The function will always return None when F::Bits is u8 or i8.)

use substrate_fixed::{traits::Fixed, types::I12F4};
use core::convert::TryInto;

fn checked_add_times_500<F: Fixed>(lhs: F, rhs: F) -> Option<F>
where
    u16: TryInto<F::Bits>,
{
    rhs.checked_mul_int(500.try_into().ok()?)?.checked_add(lhs)
}

let val = checked_add_times_500(I12F4::from_num(0.25), Fixed::from_num(1.5));
assert_eq!(val, Some(Fixed::from_num(750.25)));

Required Associated Types

type Bits

The primitive integer underlying type.

type Bytes

A byte array with the same size as the type.

type Frac: Unsigned

The number of fractional bits.

<F as Fixed>::Frac::U32 is equivalent to <F as Fixed>::frac_nbits().

Required Methods

fn min_value() -> Self

Returns the smallest value that can be represented.

fn max_value() -> Self

Returns the largest value that can be represented.

fn int_nbits() -> u32

Returns the number of integer bits.

fn frac_nbits() -> u32

Returns the number of fractional bits.

fn from_bits(bits: Self::Bits) -> Self

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

fn to_bits(self) -> Self::Bits

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

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

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

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

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

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

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

fn to_be_bytes(self) -> Self::Bytes

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

fn to_le_bytes(self) -> Self::Bytes

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

fn to_ne_bytes(self) -> Self::Bytes

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

fn from_num<Src: ToFixed>(src: Src) -> Self

Creates a fixed-point number from another number.

Returns the same value as src.to_fixed().

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

Converts a fixed-point number to another number.

Returns the same value as Dst::from_fixed(self).

fn checked_from_num<Src: ToFixed>(src: Src) -> Option<Self>

Creates a fixed-point number from another number if it fits, otherwise returns None.

Returns the same value as src.checked_to_fixed().

fn checked_to_num<Dst: FromFixed>(self) -> Option<Dst>

Converts a fixed-point number to another number if it fits, otherwise returns None.

Returns the same value as Dst::checked_from_fixed(self).

fn saturating_from_num<Src: ToFixed>(src: Src) -> Self

Creates a fixed-point number from another number, saturating the value if it does not fit.

Returns the same value as src.saturating_to_fixed().

fn saturating_to_num<Dst: FromFixed>(self) -> Dst

Converts a fixed-point number to another number, saturating the value if it does not fit.

Returns the same value as Dst::saturating_from_fixed(self).

fn wrapping_from_num<Src: ToFixed>(src: Src) -> Self

Creates a fixed-point number from another number, wrapping the value on overflow.

Returns the same value as src.wrapping_to_fixed().

fn wrapping_to_num<Dst: FromFixed>(self) -> Dst

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

Returns the same value as Src::wrapping_from_fixed(self).

fn overflowing_from_num<Src: ToFixed>(src: Src) -> (Self, bool)

Creates a fixed-point number from another number.

Returns the same value as src.overflowing_to_fixed().

fn overflowing_to_num<Dst: FromFixed>(self) -> (Dst, bool)

Converts a fixed-point number to another number.

Returns the same value as Dst::overflowing_from_fixed(self).

fn from_str_binary(src: &str) -> Result<Self, ParseFixedError>

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

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

fn from_str_octal(src: &str) -> Result<Self, ParseFixedError>

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

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

fn from_str_hex(src: &str) -> Result<Self, ParseFixedError>

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

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

fn saturating_from_str(src: &str) -> Result<Self, ParseFixedError>

Parses a string slice containing decimal digits to return a fixed-point number, saturating on overflow.

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

fn saturating_from_str_binary(src: &str) -> Result<Self, ParseFixedError>

Parses a string slice containing binary digits to return a fixed-point number, saturating on overflow.

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

fn saturating_from_str_octal(src: &str) -> Result<Self, ParseFixedError>

Parses a string slice containing octal digits to return a fixed-point number, saturating on overflow.

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

fn saturating_from_str_hex(src: &str) -> Result<Self, ParseFixedError>

Parses a string slice containing hexadecimal digits to return a fixed-point number, saturating on overflow.

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

fn wrapping_from_str(src: &str) -> Result<Self, ParseFixedError>

Parses a string slice containing decimal digits to return a fixed-point number, wrapping on overflow.

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

fn wrapping_from_str_binary(src: &str) -> Result<Self, ParseFixedError>

Parses a string slice containing binary digits to return a fixed-point number, wrapping on overflow.

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

fn wrapping_from_str_octal(src: &str) -> Result<Self, ParseFixedError>

Parses a string slice containing octal digits to return a fixed-point number, wrapping on overflow.

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

fn wrapping_from_str_hex(src: &str) -> Result<Self, ParseFixedError>

Parses a string slice containing hexadecimal digits to return a fixed-point number, wrapping on overflow.

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

fn overflowing_from_str(src: &str) -> Result<(Self, bool), ParseFixedError>

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

Returns a tuple of the fixed-point number and a bool, indicating whether an overflow has occurred. On overflow, the wrapped value is returned.

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

fn overflowing_from_str_binary( src: &str, ) -> Result<(Self, bool), ParseFixedError>

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

Returns a tuple of the fixed-point number and a bool, indicating whether an overflow has occurred. On overflow, the wrapped value is returned.

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

fn overflowing_from_str_octal( src: &str, ) -> Result<(Self, bool), ParseFixedError>

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

Returns a tuple of the fixed-point number and a bool, indicating whether an overflow has occurred. On overflow, the wrapped value is returned.

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

fn overflowing_from_str_hex(src: &str) -> Result<(Self, bool), ParseFixedError>

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

Returns a tuple of the fixed-point number and a bool, indicating whether an overflow has occurred. On overflow, the wrapped value is returned.

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

fn int(self) -> Self

Returns the integer part.

fn frac(self) -> Self

Returns the fractional part.

fn round_to_zero(self) -> Self

Rounds to the next integer towards 0.

fn ceil(self) -> Self

Rounds to the next integer towards +∞.

fn floor(self) -> Self

Rounds to the next integer towards −∞.

fn round(self) -> Self

Rounds to the nearest integer, with ties rounded away from zero.

fn round_ties_to_even(self) -> Self

Rounds to the nearest integer, with ties rounded to even.

fn checked_ceil(self) -> Option<Self>

Checked ceil. Rounds to the next integer towards +∞, returning None on overflow.

fn checked_floor(self) -> Option<Self>

Checked floor. Rounds to the next integer towards −∞, returning None on overflow.

fn checked_round(self) -> Option<Self>

Checked round. Rounds to the nearest integer, with ties rounded away from zero, returning None on overflow.

fn checked_round_ties_to_even(self) -> Option<Self>

Checked round. Rounds to the nearest integer, with ties rounded to even, returning None on overflow.

fn saturating_ceil(self) -> Self

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

fn saturating_floor(self) -> Self

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

fn saturating_round(self) -> Self

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

fn saturating_round_ties_to_even(self) -> Self

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

fn wrapping_ceil(self) -> Self

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

fn wrapping_floor(self) -> Self

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

fn wrapping_round(self) -> Self

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

fn wrapping_round_ties_to_even(self) -> Self

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

fn overflowing_ceil(self) -> (Self, bool)

Overflowing ceil. Rounds to the next integer towards +∞.

Returns a tuple of the fixed-point number and a bool, indicating whether an overflow has occurred. On overflow, the wrapped value is returned.

fn overflowing_floor(self) -> (Self, bool)

Overflowing floor. Rounds to the next integer towards −∞.

Returns a tuple of the fixed-point number and a bool, indicating whether an overflow has occurred. On overflow, the wrapped value is returned.

fn overflowing_round(self) -> (Self, bool)

Overflowing round. Rounds to the next integer to the nearest, with ties rounded away from zero.

Returns a tuple of the fixed-point number and a bool, indicating whether an overflow has occurred. On overflow, the wrapped value is returned.

fn overflowing_round_ties_to_even(self) -> (Self, bool)

Overflowing round. Rounds to the next integer to the nearest, with ties rounded to even.

Returns a tuple of the fixed-point number and a bool, indicating whether an overflow has occurred. On overflow, the wrapped value is returned.

fn count_ones(self) -> u32

Returns the number of ones in the binary representation.

fn count_zeros(self) -> u32

Returns the number of zeros in the binary representation.

fn leading_zeros(self) -> u32

Returns the number of leading zeros in the binary representation.

fn trailing_zeros(self) -> u32

Returns the number of trailing zeros in the binary representation.

fn rotate_left(self, n: u32) -> Self

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

fn rotate_right(self, n: u32) -> Self

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

fn div_euclid(self, rhs: Self) -> Self

Euclidean division by an integer.

Panics

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

fn rem_euclid(self, rhs: Self) -> Self

Remainder for Euclidean division.

Panics

Panics if the divisor is zero.

fn div_euclid_int(self, rhs: Self::Bits) -> Self

Euclidean division by an integer.

Panics

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

fn rem_euclid_int(self, rhs: Self::Bits) -> Self

Remainder for Euclidean division by an integer.

Panics

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

fn checked_neg(self) -> Option<Self>

Checked negation. Returns the negated value, or None on overflow.

fn checked_add(self, rhs: Self) -> Option<Self>

Checked addition. Returns the sum, or None on overflow.

fn checked_sub(self, rhs: Self) -> Option<Self>

Checked subtraction. Returns the difference, or None on overflow.

fn checked_mul(self, rhs: Self) -> Option<Self>

Checked multiplication. Returns the product, or None on overflow.

fn checked_div(self, rhs: Self) -> Option<Self>

Checked division. Returns the quotient, or None if the divisor is zero or on overflow.

fn checked_rem(self, rhs: Self) -> Option<Self>

Checked remainder. Returns the remainder, or None if the divisor is zero.

fn checked_div_euclid(self, rhs: Self) -> Option<Self>

Checked remainder for Euclidean division. Returns the remainder, or None if the divisor is zero or the division results in overflow.

fn checked_rem_euclid(self, rhs: Self) -> Option<Self>

Checked remainder for Euclidean division. Returns the remainder, or None if the divisor is zero.

fn checked_mul_int(self, rhs: Self::Bits) -> Option<Self>

Checked multiplication by an integer. Returns the product, or None on overflow.

fn checked_div_int(self, rhs: Self::Bits) -> Option<Self>

Checked division by an integer. Returns the quotient, or None if the divisor is zero or if the division results in overflow.

fn checked_rem_int(self, rhs: Self::Bits) -> Option<Self>

Checked fixed-point remainder for division by an integer. Returns the remainder, or None if the divisor is zero or if the division results in overflow.

fn checked_div_euclid_int(self, rhs: Self::Bits) -> Option<Self>

Checked Euclidean division by an integer. Returns the quotient, or None if the divisor is zero or if the division results in overflow.

fn checked_rem_euclid_int(self, rhs: Self::Bits) -> Option<Self>

Checked remainder for Euclidean division by an integer. Returns the remainder, or None if the divisor is zero or if the remainder results in overflow.

fn checked_shl(self, rhs: u32) -> Option<Self>

Checked shift left. Returns the shifted number, or None if rhs ≥ the number of bits.

fn checked_shr(self, rhs: u32) -> Option<Self>

Checked shift right. Returns the shifted number, or None if rhs ≥ the number of bits.

fn saturating_neg(self) -> Self

Saturated negation. Returns the negated value, saturating on overflow.

fn saturating_add(self, rhs: Self) -> Self

Saturating addition. Returns the sum, saturating on overflow.

fn saturating_sub(self, rhs: Self) -> Self

Saturating subtraction. Returns the difference, saturating on overflow.

fn saturating_mul(self, rhs: Self) -> Self

Saturating multiplication. Returns the product, saturating on overflow.

fn saturating_div(self, rhs: Self) -> Self

Saturating division. Returns the quotient, saturating on overflow.

Panics

Panics if the divisor is zero.

fn saturating_div_euclid(self, rhs: Self) -> Self

Saturating Euclidean division. Returns the quotient, saturating on overflow.

Panics

Panics if the divisor is zero.

fn saturating_mul_int(self, rhs: Self::Bits) -> Self

Saturating multiplication by an integer. Returns the product, saturating on overflow.

fn wrapping_neg(self) -> Self

Wrapping negation. Returns the negated value, wrapping on overflow.

fn wrapping_add(self, rhs: Self) -> Self

Wrapping addition. Returns the sum, wrapping on overflow.

fn wrapping_sub(self, rhs: Self) -> Self

Wrapping subtraction. Returns the difference, wrapping on overflow.

fn wrapping_mul(self, rhs: Self) -> Self

Wrapping multiplication. Returns the product, wrapping on overflow.

fn wrapping_div(self, rhs: Self) -> Self

Wrapping division. Returns the quotient, wrapping on overflow.

Panics

Panics if the divisor is zero.

fn wrapping_div_euclid(self, rhs: Self) -> Self

Wrapping Euclidean division. Returns the quotient, wrapping on overflow.

Panics

Panics if the divisor is zero.

fn wrapping_mul_int(self, rhs: Self::Bits) -> Self

Wrapping multiplication by an integer. Returns the product, wrapping on overflow.

fn wrapping_div_int(self, rhs: Self::Bits) -> Self

Wrapping division by an integer. Returns the quotient, wrapping on overflow.

Overflow can only occur when dividing the minimum value by −1.

Panics

Panics if the divisor is zero.

fn wrapping_div_euclid_int(self, rhs: Self::Bits) -> Self

Wrapping Euclidean division by an integer. Returns the quotient, wrapping on overflow.

Overflow can only occur when dividing the minimum value by −1.

Panics

Panics if the divisor is zero.

fn wrapping_rem_euclid_int(self, rhs: Self::Bits) -> Self

Wrapping remainder for Euclidean division by an integer. Returns the remainder, wrapping on overflow.

Panics

Panics if the divisor is zero.

fn wrapping_shl(self, rhs: u32) -> Self

Wrapping shift left. Wraps rhs if rhs ≥ the number of bits, then shifts and returns the number.

fn wrapping_shr(self, rhs: u32) -> Self

Wrapping shift right. Wraps rhs if rhs ≥ the number of bits, then shifts and returns the number.

fn overflowing_neg(self) -> (Self, bool)

Overflowing negation.

Returns a tuple of the negated value and a bool, indicating whether an overflow has occurred. On overflow, the wrapped value is returned.

fn overflowing_add(self, rhs: Self) -> (Self, bool)

Overflowing addition.

Returns a tuple of the sum and a bool, indicating whether an overflow has occurred. On overflow, the wrapped value is returned.

fn overflowing_sub(self, rhs: Self) -> (Self, bool)

Overflowing subtraction.

Returns a tuple of the difference and a bool, indicating whether an overflow has occurred. On overflow, the wrapped value is returned.

fn overflowing_mul(self, rhs: Self) -> (Self, bool)

Overflowing multiplication.

Returns a tuple of the product and a bool, indicating whether an overflow has occurred. On overflow, the wrapped value is returned.

fn overflowing_div(self, rhs: Self) -> (Self, bool)

Overflowing division.

Returns a tuple of the quotient and a bool, indicating whether an overflow has occurred. On overflow, the wrapped value is returned.

Panics

Panics if the divisor is zero.

fn overflowing_div_euclid(self, rhs: Self) -> (Self, bool)

Overflowing Euclidean division.

Returns a tuple of the quotient and a bool, indicating whether an overflow has occurred. On overflow, the wrapped value is returned.

Panics

Panics if the divisor is zero.

fn overflowing_mul_int(self, rhs: Self::Bits) -> (Self, bool)

Overflowing multiplication by an integer.

Returns a tuple of the product and a bool, indicating whether an overflow has occurred. On overflow, the wrapped value is returned.

fn overflowing_div_int(self, rhs: Self::Bits) -> (Self, bool)

Overflowing division by an integer.

Returns a tuple of the quotient and a bool, indicating whether an overflow has occurred. On overflow, the wrapped value is returned.

Panics

Panics if the divisor is zero.

fn overflowing_div_euclid_int(self, rhs: Self::Bits) -> (Self, bool)

Overflowing Euclidean division by an integer.

Returns a tuple of the quotient and a bool, indicating whether an overflow has occurred. On overflow, the wrapped value is returned.

Panics

Panics if the divisor is zero.

fn overflowing_rem_euclid_int(self, rhs: Self::Bits) -> (Self, bool)

Overflowing remainder for Euclidean division by an integer.

Returns a tuple of the remainder and a bool, indicating whether an overflow has occurred. On overflow, the wrapped value is returned.

Panics

Panics if the divisor is zero.

fn overflowing_shl(self, rhs: u32) -> (Self, bool)

Overflowing shift left.

Returns a tuple of the shifted value and a bool, indicating whether an overflow has occurred. On overflow, the wrapped value is returned.

fn overflowing_shr(self, rhs: u32) -> (Self, bool)

Overflowing shift right.

Returns a tuple of the shifted value and a bool, indicating whether an overflow has occurred. On overflow, the wrapped value is returned.

Provided Methods

fn wrapping_rem_int(self, rhs: Self::Bits) -> Self

👎Deprecated since 0.5.3: cannot overflow, use % or Rem::rem instead

Remainder for division by an integer.

Panics

Panics if the divisor is zero.

fn overflowing_rem_int(self, rhs: Self::Bits) -> (Self, bool)

👎Deprecated since 0.5.3: cannot overflow, use % or Rem::rem instead

Remainder for division by an integer.

Panics

Panics if the divisor is zero.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl<Frac: LeEqU8> Fixed for FixedI8<Frac>

type Bits = i8

type Bytes = [u8; 1]

type Frac = Frac

impl<Frac: LeEqU8> Fixed for FixedU8<Frac>

type Bits = u8

type Bytes = [u8; 1]

type Frac = Frac

impl<Frac: LeEqU16> Fixed for FixedI16<Frac>

type Bits = i16

type Bytes = [u8; 2]

type Frac = Frac

impl<Frac: LeEqU16> Fixed for FixedU16<Frac>

type Bits = u16

type Bytes = [u8; 2]

type Frac = Frac

impl<Frac: LeEqU32> Fixed for FixedI32<Frac>

type Bits = i32

type Bytes = [u8; 4]

type Frac = Frac

impl<Frac: LeEqU32> Fixed for FixedU32<Frac>

type Bits = u32

type Bytes = [u8; 4]

type Frac = Frac

impl<Frac: LeEqU64> Fixed for FixedI64<Frac>

type Bits = i64

type Bytes = [u8; 8]

type Frac = Frac

impl<Frac: LeEqU64> Fixed for FixedU64<Frac>

type Bits = u64

type Bytes = [u8; 8]

type Frac = Frac

impl<Frac: LeEqU128> Fixed for FixedI128<Frac>

type Bits = i128

type Bytes = [u8; 16]

type Frac = Frac

impl<Frac: LeEqU128> Fixed for FixedU128<Frac>

type Bits = u128

type Bytes = [u8; 16]

type Frac = Frac