Trait fixed::traits::Fixed[−][src]

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

Show 7 associated constants and 177 methods
    const ZERO: Self;
    const DELTA: Self;
    const MIN: Self;
    const MAX: Self;
    const IS_SIGNED: bool;
    const INT_NBITS: u32;
    const FRAC_NBITS: u32;

    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 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 checked_int_log2(self) -> Option<i32>;

    fn checked_int_log10(self) -> 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 mean(self, other: Self) -> Self;

    fn recip(self) -> Self;

    fn mul_add(self, mul: Self, add: 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 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_mul_add(self, mul: Self, add: 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 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_mul_add(self, mul: Self, add: 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_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 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_mul_add(self, mul: Self, add: 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 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_mul_add(self, mul: Self, add: 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 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_mul_add(self, mul: Self, add: 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 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> { ... }

}
Expand description

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

Associated Types

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

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

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

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

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

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

Associated Constants

Zero.

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

The difference between any two successive representable numbers, Δ.

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

The smallest value that can be represented.

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

The largest value that can be represented.

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

true if the type is signed.

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

The number of integer bits.

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

The number of fractional bits.

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

Required methods

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

See also FixedI32::from_bits and FixedU32::from_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.

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

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

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

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

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

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

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

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

Reverses the byte order of the fixed-point number.

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

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

Returns the integer part.

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

Returns the fractional part.

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

Rounds to the next integer towards 0.

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

Rounds to the next integer towards +∞.

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

Rounds to the next integer towards −∞.

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

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

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

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

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

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

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

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

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

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.

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.

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

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

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

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

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.

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.

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

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

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

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

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

Returns the number of ones in the binary representation.

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

Returns the number of zeros in the binary representation.

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

Returns the number of leading ones in the binary representation.

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

Returns the number of leading zeros in the binary representation.

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

Returns the number of trailing ones in the binary representation.

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

Returns the number of trailing zeros in the binary representation.

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

Integer base-2 logarithm, rounded down.

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

Panics

Panics if the fixed-point number is ≤ 0.

Integer base-10 logarithm, rounded down.

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

Panics

Panics if the fixed-point number is ≤ 0.

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.

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.

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

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

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

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

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

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

Returns true if the number is zero.

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

Returns the distance from self to other.

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

Returns the mean of self and other.

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

Returns the reciprocal.

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

Panics

Panics if self is zero.

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.

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.

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.

Remainder for Euclidean division.

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

Panics

Panics if the divisor is zero.

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.

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.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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.

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.

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.

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

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

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.

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.

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.

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.

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

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

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

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

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

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

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

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

Saturating addition. Returns the sum, saturating on overflow.

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

Saturating subtraction. Returns the difference, saturating on overflow.

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

Saturating multiplication. Returns the product, saturating on overflow.

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

Saturating division. Returns the quotient, saturating on overflow.

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

Panics

Panics if the divisor is zero.

Saturating reciprocal.

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

Panics

Panics if self is zero.

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

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

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

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

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.

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

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

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.

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.

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

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

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

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

Wrapping addition. Returns the sum, wrapping on overflow.

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

Wrapping subtraction. Returns the difference, wrapping on overflow.

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

Wrapping multiplication. Returns the product, wrapping on overflow.

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

Wrapping division. Returns the quotient, wrapping on overflow.

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

Panics

Panics if the divisor is zero.

Wrapping reciprocal.

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

Panics

Panics if self is zero.

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

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

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

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

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.

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

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

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.

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.

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.

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.

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.

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

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

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

Provided methods

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

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

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

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

Implementors