Trait fixed::traits::Fixed

pub trait Fixed
where
    Self: Default + Hash + Ord + Contiguous + Pod + TransparentWrapper<Self::Bits> + Debug + Display + LowerExp + UpperExp + 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> + Rem<Self::NonZeroBits, Output = Self> + RemAssign<Self::NonZeroBits> + 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> + Sum + Product + 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<f16> + PartialOrd<bf16> + PartialOrd<f32> + PartialOrd<f64> + PartialOrd<F128> + PartialOrd<F128Bits> + FixedOptionalFeatures + Sealed,
{
    type Bits: FixedBits + From<Self::NonZeroBits>;
    type NonZeroBits: TryFrom<Self::Bits, Error = TryFromIntError>;
    type Bytes;
    type Frac: Unsigned;
    type Signed: FixedSigned;
    type Unsigned: FixedUnsigned;

    const ZERO: Self;
    const TRY_ONE: Option<Self>;
    const DELTA: Self;
    const MIN: Self;
    const MAX: Self;
    const IS_SIGNED: bool;
    const INT_NBITS: u32;
    const FRAC_NBITS: u32;

    // Required methods
    fn from_bits(bits: Self::Bits) -> Self;
    fn to_bits(self) -> Self::Bits;
    fn from_be(fixed: Self) -> Self;
    fn from_le(fixed: Self) -> Self;
    fn to_be(self) -> Self;
    fn to_le(self) -> Self;
    fn swap_bytes(self) -> Self;
    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 unwrapped_from_num<Src: ToFixed>(src: Src) -> Self;
    fn unwrapped_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 unwrapped_from_str(src: &str) -> Self;
    fn unwrapped_from_str_binary(src: &str) -> Self;
    fn unwrapped_from_str_octal(src: &str) -> Self;
    fn unwrapped_from_str_hex(src: &str) -> Self;
    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 unwrapped_ceil(self) -> Self;
    fn unwrapped_floor(self) -> Self;
    fn unwrapped_round(self) -> Self;
    fn unwrapped_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_ones(self) -> u32;
    fn leading_zeros(self) -> u32;
    fn trailing_ones(self) -> u32;
    fn trailing_zeros(self) -> u32;
    fn int_log2(self) -> i32;
    fn int_log10(self) -> i32;
    fn int_log(self, base: u32) -> i32;
    fn checked_int_log2(self) -> Option<i32>;
    fn checked_int_log10(self) -> Option<i32>;
    fn checked_int_log(self, base: u32) -> Option<i32>;
    fn reverse_bits(self) -> Self;
    fn rotate_left(self, n: u32) -> Self;
    fn rotate_right(self, n: u32) -> Self;
    fn is_zero(self) -> bool;
    fn dist(self, other: Self) -> Self;
    fn abs_diff(self, other: Self) -> Self::Unsigned;
    fn mean(self, other: Self) -> Self;
    fn hypot(self, other: Self) -> Self;
    fn recip(self) -> Self;
    fn next_multiple_of(self, other: Self) -> Self;
    fn mul_add(self, mul: Self, add: Self) -> Self;
    fn add_prod(self, a: Self, b: Self) -> Self;
    fn mul_acc(&mut self, a: Self, b: 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 sqrt(self) -> Self;
    fn lerp(self, start: Self, end: Self) -> Self;
    fn inv_lerp(self, start: Self, end: Self) -> 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_recip(self) -> Option<Self>;
    fn checked_next_multiple_of(self, other: Self) -> Option<Self>;
    fn checked_mul_add(self, mul: Self, add: Self) -> Option<Self>;
    fn checked_add_prod(self, a: Self, b: Self) -> Option<Self>;
    fn checked_mul_acc(&mut self, a: Self, b: Self) -> Option<()>;
    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 checked_dist(self, other: Self) -> Option<Self>;
    fn checked_hypot(self, other: Self) -> Option<Self>;
    fn checked_sqrt(self) -> Option<Self>;
    fn checked_lerp(self, start: Self, end: Self) -> Option<Self>;
    fn checked_inv_lerp(self, start: Self, end: Self) -> 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_recip(self) -> Self;
    fn saturating_next_multiple_of(self, other: Self) -> Self;
    fn saturating_mul_add(self, mul: Self, add: Self) -> Self;
    fn saturating_add_prod(self, a: Self, b: Self) -> Self;
    fn saturating_mul_acc(&mut self, a: Self, b: Self);
    fn saturating_div_euclid(self, rhs: Self) -> Self;
    fn saturating_mul_int(self, rhs: Self::Bits) -> Self;
    fn saturating_div_int(self, rhs: Self::Bits) -> Self;
    fn saturating_div_euclid_int(self, rhs: Self::Bits) -> Self;
    fn saturating_rem_euclid_int(self, rhs: Self::Bits) -> Self;
    fn saturating_dist(self, other: Self) -> Self;
    fn saturating_hypot(self, other: Self) -> Self;
    fn saturating_sqrt(self) -> Self;
    fn saturating_lerp(self, start: Self, end: Self) -> Self;
    fn saturating_inv_lerp(self, start: Self, end: Self) -> 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_recip(self) -> Self;
    fn wrapping_next_multiple_of(self, other: Self) -> Self;
    fn wrapping_mul_add(self, mul: Self, add: Self) -> Self;
    fn wrapping_add_prod(self, a: Self, b: Self) -> Self;
    fn wrapping_mul_acc(&mut self, a: Self, b: 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 wrapping_dist(self, other: Self) -> Self;
    fn wrapping_hypot(self, other: Self) -> Self;
    fn wrapping_sqrt(self) -> Self;
    fn wrapping_lerp(self, start: Self, end: Self) -> Self;
    fn wrapping_inv_lerp(self, start: Self, end: Self) -> Self;
    fn unwrapped_neg(self) -> Self;
    fn unwrapped_add(self, rhs: Self) -> Self;
    fn unwrapped_sub(self, rhs: Self) -> Self;
    fn unwrapped_mul(self, rhs: Self) -> Self;
    fn unwrapped_div(self, rhs: Self) -> Self;
    fn unwrapped_rem(self, rhs: Self) -> Self;
    fn unwrapped_recip(self) -> Self;
    fn unwrapped_next_multiple_of(self, other: Self) -> Self;
    fn unwrapped_mul_add(self, mul: Self, add: Self) -> Self;
    fn unwrapped_add_prod(self, a: Self, b: Self) -> Self;
    fn unwrapped_mul_acc(&mut self, a: Self, b: Self);
    fn unwrapped_div_euclid(self, rhs: Self) -> Self;
    fn unwrapped_rem_euclid(self, rhs: Self) -> Self;
    fn unwrapped_mul_int(self, rhs: Self::Bits) -> Self;
    fn unwrapped_div_int(self, rhs: Self::Bits) -> Self;
    fn unwrapped_rem_int(self, rhs: Self::Bits) -> Self;
    fn unwrapped_div_euclid_int(self, rhs: Self::Bits) -> Self;
    fn unwrapped_rem_euclid_int(self, rhs: Self::Bits) -> Self;
    fn unwrapped_shl(self, rhs: u32) -> Self;
    fn unwrapped_shr(self, rhs: u32) -> Self;
    fn unwrapped_dist(self, other: Self) -> Self;
    fn unwrapped_hypot(self, other: Self) -> Self;
    fn unwrapped_sqrt(self) -> Self;
    fn unwrapped_lerp(self, start: Self, end: Self) -> Self;
    fn unwrapped_inv_lerp(self, start: Self, end: Self) -> 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_recip(self) -> (Self, bool);
    fn overflowing_next_multiple_of(self, other: Self) -> (Self, bool);
    fn overflowing_mul_add(self, mul: Self, add: Self) -> (Self, bool);
    fn overflowing_add_prod(self, a: Self, b: Self) -> (Self, bool);
    fn overflowing_mul_acc(&mut self, a: Self, b: 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);
    fn overflowing_dist(self, other: Self) -> (Self, bool);
    fn overflowing_hypot(self, other: Self) -> (Self, bool);
    fn overflowing_sqrt(self) -> (Self, bool);
    fn overflowing_lerp(self, start: Self, end: Self) -> (Self, bool);
    fn overflowing_inv_lerp(self, start: Self, end: Self) -> (Self, bool);

    // Provided methods
    fn get_signed(&self) -> Option<&Self::Signed> { ... }
    fn get_unsigned(&self) -> Option<&Self::Unsigned> { ... }
    fn get_signed_mut(&mut self) -> Option<&mut Self::Signed> { ... }
    fn get_unsigned_mut(&mut self) -> Option<&mut Self::Unsigned> { ... }
}

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 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 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 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 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 fixed::{traits::Fixed, types::I12F4};

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: FixedBits + From<Self::NonZeroBits>

The primitive integer underlying type.

Examples

use fixed::{traits::Fixed, types::I16F16};
// 32-bit DELTA is 0x0000_0001_i32
const DELTA_BITS: <I16F16 as Fixed>::Bits = I16F16::DELTA.to_bits();
assert_eq!(DELTA_BITS, 1i32);

type NonZeroBits: TryFrom<Self::Bits, Error = TryFromIntError>

The non-zero wrapped version of Bits.

Examples

use fixed::{traits::Fixed, types::I16F16};
let val = I16F16::from_num(31);
let non_zero_5 = <I16F16 as Fixed>::NonZeroBits::new(5).unwrap();
assert_eq!(val % non_zero_5, val % 5);

type Bytes

A byte array with the same size as the type.

Examples

use fixed::{traits::Fixed, types::I16F16};
// 32-bit DELTA is 0x0000_0001_i32
const DELTA_LE_BYTES: <I16F16 as Fixed>::Bytes = I16F16::DELTA.to_le_bytes();
assert_eq!(DELTA_LE_BYTES, 1i32.to_le_bytes());

type Frac: Unsigned

The number of fractional bits as a compile-time Unsigned as provided by the typenum crate.

<F as Fixed>::Frac::U32 is equivalent to <F as Fixed>::FRAC_NBITS.

Frac can be used as the generic parameter of fixed-point number types.

Examples

use fixed::{traits::Fixed, types::extra::U16, FixedI32, FixedI64};
type Fix1 = FixedI32::<U16>;
assert_eq!(Fix1::FRAC_NBITS, 16);
assert_eq!(Fix1::INT_NBITS, 32 - 16);
type Fix2 = FixedI64::<<Fix1 as Fixed>::Frac>;
assert_eq!(Fix2::FRAC_NBITS, 16);
assert_eq!(Fix2::INT_NBITS, 64 - 16);

type Signed: FixedSigned

An unsigned fixed-point number type with the same number of integer and fractional bits as Self.

If Self is signed, then Self::Signed is the same as Self.

Examples

use fixed::{
    traits::Fixed,
    types::{I16F16, U16F16},
};
// I16F16::Signed is I16F16
assert_eq!(<I16F16 as Fixed>::Signed::FRAC_NBITS, I16F16::FRAC_NBITS);
assert_eq!(<I16F16 as Fixed>::Signed::INT_NBITS, I16F16::INT_NBITS);
assert_eq!(<I16F16 as Fixed>::Signed::IS_SIGNED, I16F16::IS_SIGNED);
// U16F16::Signed is I16F16
assert_eq!(<U16F16 as Fixed>::Signed::FRAC_NBITS, I16F16::FRAC_NBITS);
assert_eq!(<U16F16 as Fixed>::Signed::INT_NBITS, I16F16::INT_NBITS);
assert_eq!(<U16F16 as Fixed>::Signed::IS_SIGNED, I16F16::IS_SIGNED);

type Unsigned: FixedUnsigned

An unsigned fixed-point number type with the same number of integer and fractional bits as Self.

If Self is unsigned, then Self::Unsigned is the same as Self.

Examples

use fixed::{
    traits::Fixed,
    types::{I16F16, U16F16},
};
// I16F16::Unsigned is U16F16
assert_eq!(<I16F16 as Fixed>::Unsigned::FRAC_NBITS, U16F16::FRAC_NBITS);
assert_eq!(<I16F16 as Fixed>::Unsigned::INT_NBITS, U16F16::INT_NBITS);
assert_eq!(<I16F16 as Fixed>::Unsigned::IS_SIGNED, U16F16::IS_SIGNED);
// U16F16::Unsigned is U16F16
assert_eq!(<U16F16 as Fixed>::Unsigned::FRAC_NBITS, U16F16::FRAC_NBITS);
assert_eq!(<U16F16 as Fixed>::Unsigned::INT_NBITS, U16F16::INT_NBITS);
assert_eq!(<U16F16 as Fixed>::Unsigned::IS_SIGNED, U16F16::IS_SIGNED);

Required Associated Constants

const ZERO: Self

Zero.

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

const TRY_ONE: Option<Self>

One if the fixed-point number can represent it, otherwise None.

const DELTA: Self

The difference between any two successive representable numbers, Δ.

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

const MIN: Self

The smallest value that can be represented.

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

const MAX: Self

The largest value that can be represented.

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

const IS_SIGNED: bool

true if the type is signed.

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

const INT_NBITS: u32

The number of integer bits.

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

const FRAC_NBITS: u32

The number of fractional bits.

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

Required Methods

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

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

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

fn to_bits(self) -> Self::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.

fn from_be(fixed: Self) -> Self

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

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

fn from_le(fixed: Self) -> Self

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

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

fn to_be(self) -> Self

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

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

fn to_le(self) -> Self

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

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

fn swap_bytes(self) -> Self

Reverses the byte order of the fixed-point number.

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

fn from_be_bytes(bytes: Self::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.

fn from_le_bytes(bytes: Self::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.

fn from_ne_bytes(bytes: Self::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.

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.

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

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.

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

fn to_ne_bytes(self) -> Self::Bytes

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

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

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

Creates a fixed-point number from another number.

Returns the same value as src.to_fixed().

See also FixedI32::from_num and FixedU32::from_num.

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

Converts a fixed-point number to another number.

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

See also FixedI32::to_num and FixedU32::to_num.

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().

See also FixedI32::checked_from_num and FixedU32::checked_from_num.

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

See also FixedI32::checked_to_num and FixedU32::checked_to_num.

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().

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

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

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

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().

See also FixedI32::wrapping_from_num and FixedU32::wrapping_from_num.

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 Dst::wrapping_from_fixed(self).

See also FixedI32::wrapping_to_num and FixedU32::wrapping_to_num.

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

Creates a fixed-point number from another number, panicking on overflow.

Returns the same value as src.unwrapped_to_fixed().

See also FixedI32::unwrapped_from_num and FixedU32::unwrapped_from_num.

Panics

Panics if the value does not fit.

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

Converts a fixed-point number to another number, panicking on overflow.

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

See also FixedI32::unwrapped_to_num and FixedU32::unwrapped_to_num.

Panics

Panics if the value does not fit.

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().

See also FixedI32::overflowing_from_num and FixedU32::overflowing_from_num.

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

See also FixedI32::overflowing_to_num and FixedU32::overflowing_to_num.

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.

See also FixedI32::from_str_binary and FixedU32::from_str_binary.

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.

See also FixedI32::from_str_octal and FixedU32::from_str_octal.

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.

See also FixedI32::from_str_hex and FixedU32::from_str_hex.

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.

See also FixedI32::saturating_from_str and FixedU32::saturating_from_str.

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.

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

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.

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

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.

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

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.

See also FixedI32::wrapping_from_str and FixedU32::wrapping_from_str.

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.

See also FixedI32::wrapping_from_str_binary and FixedU32::wrapping_from_str_binary.

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.

See also FixedI32::wrapping_from_str_octal and FixedU32::wrapping_from_str_octal.

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.

See also FixedI32::wrapping_from_str_hex and FixedU32::wrapping_from_str_hex.

fn unwrapped_from_str(src: &str) -> Self

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

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

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

Panics

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

fn unwrapped_from_str_binary(src: &str) -> Self

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

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

See also FixedI32::unwrapped_from_str_binary and FixedU32::unwrapped_from_str_binary.

Panics

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

fn unwrapped_from_str_octal(src: &str) -> Self

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

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

See also FixedI32::unwrapped_from_str_octal and FixedU32::unwrapped_from_str_octal.

Panics

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

fn unwrapped_from_str_hex(src: &str) -> Self

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

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

See also FixedI32::unwrapped_from_str_hex and FixedU32::unwrapped_from_str_hex.

Panics

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

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.

See also FixedI32::overflowing_from_str and FixedU32::overflowing_from_str.

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.

See also FixedI32::overflowing_from_str_binary and FixedU32::overflowing_from_str_binary.

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.

See also FixedI32::overflowing_from_str_octal and FixedU32::overflowing_from_str_octal.

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.

See also FixedI32::overflowing_from_str_hex and FixedU32::overflowing_from_str_hex.

fn int(self) -> Self

Returns the integer part.

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

fn frac(self) -> Self

Returns the fractional part.

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

fn round_to_zero(self) -> Self

Rounds to the next integer towards 0.

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

fn ceil(self) -> Self

Rounds to the next integer towards +∞.

See also FixedI32::ceil and FixedU32::ceil.

fn floor(self) -> Self

Rounds to the next integer towards −∞.

See also FixedI32::floor and FixedU32::floor.

fn round(self) -> Self

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

See also FixedI32::round and FixedU32::round.

fn round_ties_to_even(self) -> Self

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

See also FixedI32::round_ties_to_even and FixedU32::round_ties_to_even.

fn checked_ceil(self) -> Option<Self>

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

See also FixedI32::checked_ceil and FixedU32::checked_ceil.

fn checked_floor(self) -> Option<Self>

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

See also FixedI32::checked_floor and FixedU32::checked_floor.

fn checked_round(self) -> Option<Self>

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

See also FixedI32::checked_round and FixedU32::checked_round.

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.

See also FixedI32::checked_round_ties_to_even and FixedU32::checked_round_ties_to_even.

fn saturating_ceil(self) -> Self

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

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

fn saturating_floor(self) -> Self

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

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

fn saturating_round(self) -> Self

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

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

fn saturating_round_ties_to_even(self) -> Self

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

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

fn wrapping_ceil(self) -> Self

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

See also FixedI32::wrapping_ceil and FixedU32::wrapping_ceil.

fn wrapping_floor(self) -> Self

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

See also FixedI32::wrapping_floor and FixedU32::wrapping_floor.

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.

See also FixedI32::wrapping_round and FixedU32::wrapping_round.

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.

See also FixedI32::wrapping_round_ties_to_even and FixedU32::wrapping_round_ties_to_even.

fn unwrapped_ceil(self) -> Self

Unwrapped ceil. Rounds to the next integer towards +∞, panicking on overflow.

See also FixedI32::unwrapped_ceil and FixedU32::unwrapped_ceil.

Panics

Panics if the result does not fit.

fn unwrapped_floor(self) -> Self

Unwrapped floor. Rounds to the next integer towards −∞, panicking on overflow.

See also FixedI32::unwrapped_floor and FixedU32::unwrapped_floor.

Panics

Panics if the result does not fit.

fn unwrapped_round(self) -> Self

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

See also FixedI32::unwrapped_round and FixedU32::unwrapped_round.

Panics

Panics if the result does not fit.

fn unwrapped_round_ties_to_even(self) -> Self

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

See also FixedI32::unwrapped_round_ties_to_even and FixedU32::unwrapped_round_ties_to_even.

Panics

Panics if the result does not fit.

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.

See also FixedI32::overflowing_ceil and FixedU32::overflowing_ceil.

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.

See also FixedI32::overflowing_floor and FixedU32::overflowing_floor.

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.

See also FixedI32::overflowing_round and FixedU32::overflowing_round.

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.

See also FixedI32::overflowing_round_ties_to_even and FixedU32::overflowing_round_ties_to_even.

fn count_ones(self) -> u32

Returns the number of ones in the binary representation.

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

fn count_zeros(self) -> u32

Returns the number of zeros in the binary representation.

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

fn leading_ones(self) -> u32

Returns the number of leading ones in the binary representation.

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

fn leading_zeros(self) -> u32

Returns the number of leading zeros in the binary representation.

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

fn trailing_ones(self) -> u32

Returns the number of trailing ones in the binary representation.

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

fn trailing_zeros(self) -> u32

Returns the number of trailing zeros in the binary representation.

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

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.

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.

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.

fn checked_int_log2(self) -> Option<i32>

Checked integer base-2 logarithm, rounded down. Returns the logarithm or None if the fixed-point number is ≤ 0.

See also FixedI32::checked_int_log2 and FixedU32::checked_int_log2.

fn checked_int_log10(self) -> Option<i32>

Checked integer base-10 logarithm, rounded down. Returns the logarithm or None if the fixed-point number is ≤ 0.

See also FixedI32::checked_int_log10 and FixedU32::checked_int_log10.

fn checked_int_log(self, base: u32) -> Option<i32>

Checked integer logarithm to the specified base, rounded down. Returns the logarithm, or None if the fixed-point number is ≤ 0 or if the base is < 2.

See also FixedI32::checked_int_log and FixedU32::checked_int_log.

fn reverse_bits(self) -> Self

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

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

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

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

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

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

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

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

fn is_zero(self) -> bool

Returns true if the number is zero.

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

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

Returns the distance from self to other.

See also FixedI32::dist and FixedU32::dist.

fn abs_diff(self, other: Self) -> Self::Unsigned

Returns the absolute value of the difference between self and other using an unsigned type without any wrapping or panicking.

See also FixedI32::abs_diff and FixedU32::abs_diff.

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

Returns the mean of self and other.

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

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

Compute the hypotenuse of a right triange.

See also FixedI32::hypot and FixedU32::hypot.

fn recip(self) -> Self

Returns the reciprocal.

See also FixedI32::recip and FixedU32::recip.

Panics

Panics if self is zero.

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

Returns the next multiple of other.

See also FixedI32::next_multiple_of and FixedU32::next_multiple_of.

Panics

Panics if other is zero.

fn mul_add(self, mul: Self, add: Self) -> Self

Multiply and add. Returns self × mul + add.

Note that the inherent mul_add method is more flexible than this method and allows the mul parameter to have a fixed-point type like self but with a different number of fractional bits.

See also FixedI32::mul_add and FixedU32::mul_add.

fn add_prod(self, a: Self, b: Self) -> Self

Adds self to the product a × b.

Note that the inherent add_prod method is more flexible than this method and allows the a and b parameters to have a fixed-point type like self but with a different number of fractional bits.

See also FixedI32::add_prod and FixedU32::add_prod.

fn mul_acc(&mut self, a: Self, b: Self)

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

Note that the inherent mul_acc method is more flexible than this method and allows the a and b parameters to have a fixed-point type like self but with a different number of fractional bits.

See also FixedI32::mul_acc and FixedU32::mul_acc.

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

Euclidean division by an integer.

See also FixedI32::div_euclid and FixedU32::div_euclid.

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.

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

Panics

Panics if the divisor is zero.

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

Euclidean division by an integer.

See also FixedI32::div_euclid_int and FixedU32::div_euclid_int.

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.

See also FixedI32::rem_euclid_int and FixedU32::rem_euclid_int.

Panics

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

fn sqrt(self) -> Self

Returns the square root.

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

Panics

Panics if the number is negative.

fn lerp(self, start: Self, end: Self) -> Self

Linear interpolation between start and end.

See also FixedI32::lerp and FixedU32::lerp.

fn inv_lerp(self, start: Self, end: Self) -> Self

Inverse linear interpolation between start and end.

See also FixedI32::inv_lerp and FixedU32::inv_lerp.

fn checked_neg(self) -> Option<Self>

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

See also FixedI32::checked_neg and FixedU32::checked_neg.

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

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

See also FixedI32::checked_add and FixedU32::checked_add.

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

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

See also FixedI32::checked_sub and FixedU32::checked_sub.

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

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

See also FixedI32::checked_mul and FixedU32::checked_mul.

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

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

See also FixedI32::checked_div and FixedU32::checked_div.

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

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

See also FixedI32::checked_rem and FixedU32::checked_rem.

fn checked_recip(self) -> Option<Self>

Checked reciprocal. Returns the reciprocal, or None if self is zero or on overflow.

See also FixedI32::checked_recip and FixedU32::checked_recip.

fn checked_next_multiple_of(self, other: Self) -> Option<Self>

Checked next multiple of other. Returns the next multiple, or None if other is zero or on overflow.

See also FixedI32::checked_next_multiple_of and FixedU32::checked_next_multiple_of.

fn checked_mul_add(self, mul: Self, add: Self) -> Option<Self>

Checked multiply and add. Returns self × mul + add, or None on overflow.

See also FixedI32::checked_mul_add and FixedU32::checked_mul_add.

fn checked_add_prod(self, a: Self, b: Self) -> Option<Self>

Adds self to the product a × b, returning None on overflow.

See also FixedI32::checked_add_prod and FixedU32::checked_add_prod.

fn checked_mul_acc(&mut self, a: Self, b: Self) -> Option<()>

Checked multiply and accumulate. Adds (a × b) to self, or returns None on overflow.

See also FixedI32::checked_mul_acc and FixedU32::checked_mul_acc.

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.

See also FixedI32::checked_div_euclid and FixedU32::checked_div_euclid.

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

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

See also FixedI32::checked_rem_euclid and FixedU32::checked_rem_euclid.

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

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

See also FixedI32::checked_mul_int and FixedU32::checked_mul_int.

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.

See also FixedI32::checked_div_int and FixedU32::checked_div_int.

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.

See also FixedI32::checked_rem_int and FixedU32::checked_rem_int.

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.

See also FixedI32::checked_div_euclid_int and FixedU32::checked_div_euclid_int.

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.

See also FixedI32::checked_rem_euclid_int and FixedU32::checked_rem_euclid_int.

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

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

See also FixedI32::checked_shl and FixedU32::checked_shl.

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

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

See also FixedI32::checked_shr and FixedU32::checked_shr.

fn checked_dist(self, other: Self) -> Option<Self>

Checked distance. Returns the distance from self to other, or None on overflow.

See also FixedI32::checked_dist and FixedU32::checked_dist.

fn checked_hypot(self, other: Self) -> Option<Self>

Compute the hypotenuse of a right triange, returning None on overflow.

See also FixedI32::checked_hypot and FixedU32::checked_hypot.

fn checked_sqrt(self) -> Option<Self>

Checked square root. Returns None for negative numbers or on overflow.

See also FixedI32::checked_sqrt and FixedU32::checked_sqrt.

fn checked_lerp(self, start: Self, end: Self) -> Option<Self>

Checked linear interpolation between start and end. Returns None on overflow.

See also FixedI32::checked_lerp and FixedU32::checked_lerp.

fn checked_inv_lerp(self, start: Self, end: Self) -> Option<Self>

Checked inverse linear interpolation between start and end. Returns None when start = end or on overflow.

See also FixedI32::checked_inv_lerp and FixedU32::checked_inv_lerp.

fn saturating_neg(self) -> Self

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

See also FixedI32::saturating_neg and FixedU32::saturating_neg.

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

Saturating addition. Returns the sum, saturating on overflow.

See also FixedI32::saturating_add and FixedU32::saturating_add.

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

Saturating subtraction. Returns the difference, saturating on overflow.

See also FixedI32::saturating_sub and FixedU32::saturating_sub.

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

Saturating multiplication. Returns the product, saturating on overflow.

See also FixedI32::saturating_mul and FixedU32::saturating_mul.

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

Saturating division. Returns the quotient, saturating on overflow.

See also FixedI32::saturating_div and FixedU32::saturating_div.

Panics

Panics if the divisor is zero.

fn saturating_recip(self) -> Self

Saturating reciprocal.

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

Panics

Panics if self is zero.

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

Saturating next multiple of other.

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

Panics

Panics if other is zero.

fn saturating_mul_add(self, mul: Self, add: Self) -> Self

Saturating multiply and add. Returns self × mul + add, saturating on overflow.

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

fn saturating_add_prod(self, a: Self, b: Self) -> Self

Adds self to the product a × b, saturating on overflow.

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

fn saturating_mul_acc(&mut self, a: Self, b: Self)

Saturating multiply and add. Adds (a × b) to self, saturating on overflow.

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

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

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

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

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.

See also FixedI32::saturating_mul_int and FixedU32::saturating_mul_int.

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

Saturating division by an integer. Returns the quotient, saturating on overflow.

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

See also FixedI32::saturating_div_int and FixedU32::saturating_div_int.

Panics

Panics if the divisor is zero.

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

Saturating Euclidean division by an integer. Returns the quotient, saturating on overflow.

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

Panics

Panics if the divisor is zero.

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

Saturating remainder for Euclidean division by an integer. Returns the remainder, saturating on overflow.

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

Panics

Panics if the divisor is zero.

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

Saturating distance. Returns the distance from self to other, saturating on overflow.

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

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

Compute the hypotenuse of a right triange, saturating on overflow.

See also FixedI32::saturating_hypot and FixedU32::saturating_hypot.

fn saturating_sqrt(self) -> Self

Returns the square root, saturating on overflow.

See also FixedI32::saturating_sqrt and FixedU32::saturating_sqrt.

Panics

Panics if the number is negative.

fn saturating_lerp(self, start: Self, end: Self) -> Self

Linear interpolation between start and end, saturating on overflow.

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

fn saturating_inv_lerp(self, start: Self, end: Self) -> Self

Inverse linear interpolation between start and end, saturating on overflow.

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

fn wrapping_neg(self) -> Self

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

See also FixedI32::wrapping_neg and FixedU32::wrapping_neg.

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

Wrapping addition. Returns the sum, wrapping on overflow.

See also FixedI32::wrapping_add and FixedU32::wrapping_add.

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

Wrapping subtraction. Returns the difference, wrapping on overflow.

See also FixedI32::wrapping_sub and FixedU32::wrapping_sub.

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

Wrapping multiplication. Returns the product, wrapping on overflow.

See also FixedI32::wrapping_mul and FixedU32::wrapping_mul.

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

Wrapping division. Returns the quotient, wrapping on overflow.

See also FixedI32::wrapping_div and FixedU32::wrapping_div.

Panics

Panics if the divisor is zero.

fn wrapping_recip(self) -> Self

Wrapping reciprocal.

See also FixedI32::wrapping_recip and FixedU32::wrapping_recip.

Panics

Panics if self is zero.

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

Wrapping next multiple of other.

See also FixedI32::wrapping_next_multiple_of and FixedU32::wrapping_next_multiple_of.

Panics

Panics if other is zero.

fn wrapping_mul_add(self, mul: Self, add: Self) -> Self

Wrapping multiply and add. Returns self × mul + add, wrapping on overflow.

See also FixedI32::wrapping_mul_add and FixedU32::wrapping_mul_add.

fn wrapping_add_prod(self, a: Self, b: Self) -> Self

Adds self to the product a × b, wrapping on overflow.

See also FixedI32::wrapping_add_prod and FixedU32::wrapping_add_prod.

fn wrapping_mul_acc(&mut self, a: Self, b: Self)

Wrapping multiply and accumulate. Adds (a × b) to self, wrapping on overflow.

See also FixedI32::wrapping_mul_acc and FixedU32::wrapping_mul_acc.

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

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

See also FixedI32::wrapping_div_euclid and FixedU32::wrapping_div_euclid.

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.

See also FixedI32::wrapping_mul_int and FixedU32::wrapping_mul_int.

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.

See also FixedI32::wrapping_div_int and FixedU32::wrapping_div_int.

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.

See also FixedI32::wrapping_div_euclid_int and FixedU32::wrapping_div_euclid_int.

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.

See also FixedI32::wrapping_rem_euclid_int and FixedU32::wrapping_rem_euclid_int.

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.

See also FixedI32::wrapping_shl and FixedU32::wrapping_shl.

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

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

See also FixedI32::wrapping_shr and FixedU32::wrapping_shr.

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

Wrapping distance. Returns the distance from self to other, wrapping on overflow.

See also FixedI32::wrapping_dist and FixedU32::wrapping_dist.

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

Compute the hypotenuse of a right triange, wrapping on overflow.

See also FixedI32::wrapping_hypot and FixedU32::wrapping_hypot.

fn wrapping_sqrt(self) -> Self

Returns the square root, wrapping on overflow.

See also FixedI32::wrapping_sqrt and FixedU32::wrapping_sqrt.

Panics

Panics if the number is negative.

fn wrapping_lerp(self, start: Self, end: Self) -> Self

Linear interpolation between start and end, wrapping on overflow.

See also FixedI32::wrapping_lerp and FixedU32::wrapping_lerp.

fn wrapping_inv_lerp(self, start: Self, end: Self) -> Self

Inverse linear interpolation between start and end, wrapping on overflow.

See also FixedI32::wrapping_inv_lerp and FixedU32::wrapping_inv_lerp.

fn unwrapped_neg(self) -> Self

Unwrapped negation. Returns the negated value, panicking on overflow.

See also FixedI32::unwrapped_neg and FixedU32::unwrapped_neg.

Panics

Panics if the result does not fit.

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

Unwrapped addition. Returns the sum, panicking on overflow.

See also FixedI32::unwrapped_add and FixedU32::unwrapped_add.

Panics

Panics if the result does not fit.

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

Unwrapped subtraction. Returns the difference, panicking on overflow.

See also FixedI32::unwrapped_sub and FixedU32::unwrapped_sub.

Panics

Panics if the result does not fit.

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

Unwrapped multiplication. Returns the product, panicking on overflow.

See also FixedI32::unwrapped_mul and FixedU32::unwrapped_mul.

Panics

Panics if the result does not fit.

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

Unwrapped division. Returns the quotient, panicking on overflow.

See also FixedI32::unwrapped_div and FixedU32::unwrapped_div.

Panics

Panics if the divisor is zero or if the result does not fit.

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

Unwrapped remainder. Returns the quotient, panicking if the divisor is zero.

See also FixedI32::unwrapped_rem and FixedU32::unwrapped_rem.

Panics

Panics if the divisor is zero.

fn unwrapped_recip(self) -> Self

Unwrapped reciprocal. Returns reciprocal, panicking on overflow.

See also FixedI32::unwrapped_recip and FixedU32::unwrapped_recip.

Panics

Panics if self is zero or on overflow.

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

Unwrapped next multiple of other. Returns the next multiple, panicking on overflow.

See also FixedI32::unwrapped_next_multiple_of and FixedU32::unwrapped_next_multiple_of.

Panics

Panics if other is zero or on overflow.

fn unwrapped_mul_add(self, mul: Self, add: Self) -> Self

Unwrapped multiply and add. Returns self × mul + add, panicking on overflow.

See also FixedI32::unwrapped_mul_add and FixedU32::unwrapped_mul_add.

Panics

Panics if the result does not fit.

fn unwrapped_add_prod(self, a: Self, b: Self) -> Self

Adds self to the product a × b, panicking on overflow.

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

Panics

Panics if the result does not fit.

fn unwrapped_mul_acc(&mut self, a: Self, b: Self)

Unwrapped multiply and accumulate. Adds (a × b) to self, panicking on overflow.

See also FixedI32::unwrapped_mul_acc and FixedU32::unwrapped_mul_acc.

Panics

Panics if the result does not fit.

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

Unwrapped Euclidean division. Returns the quotient, panicking on overflow.

See also FixedI32::unwrapped_div_euclid and FixedU32::unwrapped_div_euclid.

Panics

Panics if the divisor is zero or if the result does not fit.

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

Unwrapped remainder for Euclidean division. Returns the remainder, panicking if the divisor is zero.

See also FixedI32::unwrapped_rem_euclid and FixedU32::unwrapped_rem_euclid.

Panics

Panics if the divisor is zero.

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

Unwrapped multiplication by an integer. Returns the product, panicking on overflow.

See also FixedI32::unwrapped_mul_int and FixedU32::unwrapped_mul_int.

Panics

Panics if the result does not fit.

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

Unwrapped division by an integer. Returns the quotient, panicking on overflow.

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

See also FixedI32::unwrapped_div_int and FixedU32::unwrapped_div_int.

Panics

Panics if the divisor is zero or if the result does not fit.

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

Unwrapped remainder for division by an integer. Returns the remainder, panicking if the divisor is zero.

See also FixedI32::unwrapped_rem_int and FixedU32::unwrapped_rem_int.

Panics

Panics if the divisor is zero.

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

Unwrapped Euclidean division by an integer. Returns the quotient, panicking on overflow.

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

See also FixedI32::unwrapped_div_euclid_int and FixedU32::unwrapped_div_euclid_int.

Panics

Panics if the divisor is zero or if the result does not fit.

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

Unwrapped remainder for Euclidean division by an integer. Returns the remainder, panicking on overflow.

See also FixedI32::unwrapped_rem_euclid_int and FixedU32::unwrapped_rem_euclid_int.

Panics

Panics if the divisor is zero or if the result does not fit.

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

Unwrapped shift left. Panics if rhs ≥ the number of bits.

See also FixedI32::unwrapped_shl and FixedU32::unwrapped_shl.

Panics

Panics if rhs ≥ the number of bits.

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

Unwrapped shift right. Panics if rhs ≥ the number of bits.

See also FixedI32::unwrapped_shr and FixedU32::unwrapped_shr.

Panics

Panics if rhs ≥ the number of bits.

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

Unwrapped distance. Returns the distance from self to other, panicking on overflow.

Panics

Panics if the result does not fit.

See also FixedI32::unwrapped_dist and FixedU32::unwrapped_dist.

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

Compute the hypotenuse of a right triange, panicking on overflow.

Panics

Panics if the result does not fit.

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

fn unwrapped_sqrt(self) -> Self

Returns the square root, panicking if the number is negative or on overflow.

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

Panics

Panics if the number is negative or on overflow.

fn unwrapped_lerp(self, start: Self, end: Self) -> Self

Linear interpolation between start and end, panicking on overflow.

Panics

Panics if the result does not fit.

See also FixedI32::unwrapped_lerp and FixedU32::unwrapped_lerp.

fn unwrapped_inv_lerp(self, start: Self, end: Self) -> Self

Inverse linear interpolation between start and end, panicking on overflow.

Panics

Panics when start = end or when the results overflows.

See also FixedI32::unwrapped_inv_lerp and FixedU32::unwrapped_inv_lerp.

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.

See also FixedI32::overflowing_neg and FixedU32::overflowing_neg.

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.

See also FixedI32::overflowing_add and FixedU32::overflowing_add.

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.

See also FixedI32::overflowing_sub and FixedU32::overflowing_sub.

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.

See also FixedI32::overflowing_mul and FixedU32::overflowing_mul.

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.

See also FixedI32::overflowing_div and FixedU32::overflowing_div.

Panics

Panics if the divisor is zero.

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

Overflowing reciprocal.

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

See also FixedI32::overflowing_recip and FixedU32::overflowing_recip.

Panics

Panics if self is zero.

fn overflowing_next_multiple_of(self, other: Self) -> (Self, bool)

Overflowing next multiple of other.

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

See also FixedI32::overflowing_next_multiple_of and FixedU32::overflowing_next_multiple_of.

Panics

Panics if other is zero.

fn overflowing_mul_add(self, mul: Self, add: Self) -> (Self, bool)

Overflowing multiply and add.

Returns a tuple of self × mul + add and a bool, indicating whether an overflow has occurred. On overflow, the wrapped value is returned.

See also FixedI32::overflowing_mul_add and FixedU32::overflowing_mul_add.

fn overflowing_add_prod(self, a: Self, b: Self) -> (Self, bool)

Adds self to the product a × b.

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

See also FixedI32::overflowing_add_prod and FixedU32::overflowing_add_prod.

fn overflowing_mul_acc(&mut self, a: Self, b: Self) -> bool

Overflowing multiply and accumulate. Adds (a × b) to self, wrapping and returning true if overflow occurs.

See also FixedI32::overflowing_mul_acc and FixedU32::overflowing_mul_acc.

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.

See also FixedI32::overflowing_div_euclid and FixedU32::overflowing_div_euclid.

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.

See also FixedI32::overflowing_mul_int and FixedU32::overflowing_mul_int.

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.

See also FixedI32::overflowing_div_int and FixedU32::overflowing_div_int.

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.

See also FixedI32::overflowing_div_euclid_int and FixedU32::overflowing_div_euclid_int.

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.

See also FixedI32::overflowing_rem_euclid_int and FixedU32::overflowing_rem_euclid_int.

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.

See also FixedI32::overflowing_shl and FixedU32::overflowing_shl.

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.

See also FixedI32::overflowing_shr and FixedU32::overflowing_shr.

fn overflowing_dist(self, other: Self) -> (Self, bool)

Overflowing distance.

Returns a tuple of the distance from self to other and a bool, indicating whether an overflow has occurred. On overflow, the wrapped value is returned.

See also FixedI32::overflowing_dist and FixedU32::overflowing_dist.

fn overflowing_hypot(self, other: Self) -> (Self, bool)

Compute the hypotenuse of a right triange.

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

See also FixedI32::overflowing_hypot and FixedU32::overflowing_hypot.

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

Compute the square root.

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

See also FixedI32::overflowing_sqrt and FixedU32::overflowing_sqrt.

Panics

Panics if the number is negative.

fn overflowing_lerp(self, start: Self, end: Self) -> (Self, bool)

Overflowing linear interpolation between start and end.

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

See also FixedI32::overflowing_lerp and FixedU32::overflowing_lerp.

fn overflowing_inv_lerp(self, start: Self, end: Self) -> (Self, bool)

Overflowing inverse linear interpolation between start and end.

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

See also FixedI32::overflowing_inv_lerp and FixedU32::overflowing_inv_lerp.

Provided Methods

fn get_signed(&self) -> Option<&Self::Signed>

Returns a reference to self as FixedSigned if the type is signed, or None if it is unsigned.

Examples

use fixed::{
    traits::Fixed,
    types::{I16F16, U16F16},
};

let i = I16F16::from_num(-3.5);
match i.get_signed() {
    Some(signed) => assert_eq!(signed.signum(), -1),
    None => unreachable!(),
}

let u = U16F16::from_num(3.5);
assert!(u.get_signed().is_none());

fn get_unsigned(&self) -> Option<&Self::Unsigned>

Returns a reference to self as FixedUnsigned if the type is unsigned, or None if it is signed.

Examples

use fixed::{
    traits::Fixed,
    types::{I16F16, U16F16},
};

let u = U16F16::from_num(3.5);
match u.get_unsigned() {
    Some(unsigned) => assert_eq!(unsigned.next_power_of_two(), 4),
    None => unreachable!(),
}

let i = I16F16::from_num(3.5);
assert!(i.get_unsigned().is_none());

fn get_signed_mut(&mut self) -> Option<&mut Self::Signed>

Returns a mutable reference to self as FixedSigned if the type is signed, or None if it is unsigned.

Examples

use fixed::{
    traits::Fixed,
    types::{I16F16, U16F16},
};

let mut i = I16F16::from_num(-3.5);
match i.get_signed_mut() {
    Some(signed) => *signed = signed.signum(),
    None => unreachable!(),
}
assert_eq!(i, -1);

let mut u = U16F16::from_num(3.5);
assert!(u.get_signed_mut().is_none());

fn get_unsigned_mut(&mut self) -> Option<&mut Self::Unsigned>

Returns a mutable reference to self as FixedUnsigned if the type is unsigned, or None if it is signed.

Examples

use fixed::{
    traits::Fixed,
    types::{I16F16, U16F16},
};

let mut u = U16F16::from_num(3.5);
match u.get_unsigned_mut() {
    Some(unsigned) => *unsigned = unsigned.next_power_of_two(),
    None => unreachable!(),
}
assert_eq!(u, 4);

let mut i = I16F16::from_num(3.5);
assert!(i.get_unsigned_mut().is_none());

Object Safety

This trait is not object safe.

Implementors

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

type Bits = i8

type NonZeroBits = NonZero<i8>

type Bytes = [u8; 1]

type Frac = Frac

type Signed = FixedI8<Frac>

type Unsigned = FixedU8<Frac>

const ZERO: Self = Self::ZERO

const TRY_ONE: Option<Self> = Self::TRY_ONE

const DELTA: Self = Self::DELTA

const MIN: Self = Self::MIN

const MAX: Self = Self::MAX

const IS_SIGNED: bool = true

const INT_NBITS: u32 = Self::INT_NBITS

const FRAC_NBITS: u32 = Self::FRAC_NBITS

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

type Bits = u8

type NonZeroBits = NonZero<u8>

type Bytes = [u8; 1]

type Frac = Frac

type Signed = FixedI8<Frac>

type Unsigned = FixedU8<Frac>

const ZERO: Self = Self::ZERO

const TRY_ONE: Option<Self> = Self::TRY_ONE

const DELTA: Self = Self::DELTA

const MIN: Self = Self::MIN

const MAX: Self = Self::MAX

const IS_SIGNED: bool = false

const INT_NBITS: u32 = Self::INT_NBITS

const FRAC_NBITS: u32 = Self::FRAC_NBITS

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

type Bits = i16

type NonZeroBits = NonZero<i16>

type Bytes = [u8; 2]

type Frac = Frac

type Signed = FixedI16<Frac>

type Unsigned = FixedU16<Frac>

const ZERO: Self = Self::ZERO

const TRY_ONE: Option<Self> = Self::TRY_ONE

const DELTA: Self = Self::DELTA

const MIN: Self = Self::MIN

const MAX: Self = Self::MAX

const IS_SIGNED: bool = true

const INT_NBITS: u32 = Self::INT_NBITS

const FRAC_NBITS: u32 = Self::FRAC_NBITS

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

type Bits = u16

type NonZeroBits = NonZero<u16>

type Bytes = [u8; 2]

type Frac = Frac

type Signed = FixedI16<Frac>

type Unsigned = FixedU16<Frac>

const ZERO: Self = Self::ZERO

const TRY_ONE: Option<Self> = Self::TRY_ONE

const DELTA: Self = Self::DELTA

const MIN: Self = Self::MIN

const MAX: Self = Self::MAX

const IS_SIGNED: bool = false

const INT_NBITS: u32 = Self::INT_NBITS

const FRAC_NBITS: u32 = Self::FRAC_NBITS

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

type Bits = i32

type NonZeroBits = NonZero<i32>

type Bytes = [u8; 4]

type Frac = Frac

type Signed = FixedI32<Frac>

type Unsigned = FixedU32<Frac>

const ZERO: Self = Self::ZERO

const TRY_ONE: Option<Self> = Self::TRY_ONE

const DELTA: Self = Self::DELTA

const MIN: Self = Self::MIN

const MAX: Self = Self::MAX

const IS_SIGNED: bool = true

const INT_NBITS: u32 = Self::INT_NBITS

const FRAC_NBITS: u32 = Self::FRAC_NBITS

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

type Bits = u32

type NonZeroBits = NonZero<u32>

type Bytes = [u8; 4]

type Frac = Frac

type Signed = FixedI32<Frac>

type Unsigned = FixedU32<Frac>

const ZERO: Self = Self::ZERO

const TRY_ONE: Option<Self> = Self::TRY_ONE

const DELTA: Self = Self::DELTA

const MIN: Self = Self::MIN

const MAX: Self = Self::MAX

const IS_SIGNED: bool = false

const INT_NBITS: u32 = Self::INT_NBITS

const FRAC_NBITS: u32 = Self::FRAC_NBITS

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

type Bits = i64

type NonZeroBits = NonZero<i64>

type Bytes = [u8; 8]

type Frac = Frac

type Signed = FixedI64<Frac>

type Unsigned = FixedU64<Frac>

const ZERO: Self = Self::ZERO

const TRY_ONE: Option<Self> = Self::TRY_ONE

const DELTA: Self = Self::DELTA

const MIN: Self = Self::MIN

const MAX: Self = Self::MAX

const IS_SIGNED: bool = true

const INT_NBITS: u32 = Self::INT_NBITS

const FRAC_NBITS: u32 = Self::FRAC_NBITS

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

type Bits = u64

type NonZeroBits = NonZero<u64>

type Bytes = [u8; 8]

type Frac = Frac

type Signed = FixedI64<Frac>

type Unsigned = FixedU64<Frac>

const ZERO: Self = Self::ZERO

const TRY_ONE: Option<Self> = Self::TRY_ONE

const DELTA: Self = Self::DELTA

const MIN: Self = Self::MIN

const MAX: Self = Self::MAX

const IS_SIGNED: bool = false

const INT_NBITS: u32 = Self::INT_NBITS

const FRAC_NBITS: u32 = Self::FRAC_NBITS

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

type Bits = i128

type NonZeroBits = NonZero<i128>

type Bytes = [u8; 16]

type Frac = Frac

type Signed = FixedI128<Frac>

type Unsigned = FixedU128<Frac>

const ZERO: Self = Self::ZERO

const TRY_ONE: Option<Self> = Self::TRY_ONE

const DELTA: Self = Self::DELTA

const MIN: Self = Self::MIN

const MAX: Self = Self::MAX

const IS_SIGNED: bool = true

const INT_NBITS: u32 = Self::INT_NBITS

const FRAC_NBITS: u32 = Self::FRAC_NBITS

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

type Bits = u128

type NonZeroBits = NonZero<u128>

type Bytes = [u8; 16]

type Frac = Frac

type Signed = FixedI128<Frac>

type Unsigned = FixedU128<Frac>

const ZERO: Self = Self::ZERO

const TRY_ONE: Option<Self> = Self::TRY_ONE

const DELTA: Self = Self::DELTA

const MIN: Self = Self::MIN

const MAX: Self = Self::MAX

const IS_SIGNED: bool = false

const INT_NBITS: u32 = Self::INT_NBITS

const FRAC_NBITS: u32 = Self::FRAC_NBITS