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

pub trait Fixed where
    Self: Copy + Default + Hash + Ord,
    Self: Debug + Display + Binary + Octal + LowerHex + UpperHex,
    Self: FromStr<Err = ParseFixedError>,
    Self: FromFixed + ToFixed,
    Self: Add<Output = Self> + AddAssign + Sub<Output = Self> + SubAssign,
    Self: Mul<Output = Self> + MulAssign + 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: Not<Output = Self> + BitAnd<Output = Self> + BitAndAssign,
    Self: BitOr<Output = Self> + BitOrAssign + BitXor<Output = Self> + BitXorAssign,
    Self: Shl<u32, Output = Self> + ShlAssign<u32> + Shr<u32, Output = Self> + ShrAssign<u32>,
    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<f32> + PartialOrd<f64>,
    Self: FixedOptionalFeatures,
    Self: Sealed, {
    type Bits;
    type Bytes;
    type Frac: Unsigned;

    const MIN: Self;
    const MAX: Self;
    const INT_NBITS: u32;
    const FRAC_NBITS: u32;

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

    fn to_bits(self) -> Self::Bits;

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

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

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

    fn to_be_bytes(self) -> Self::Bytes;

    fn to_le_bytes(self) -> Self::Bytes;

    fn to_ne_bytes(self) -> Self::Bytes;

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

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

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

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

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

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

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

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

    fn 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 rotate_left(self, n: u32) -> Self;

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

    fn recip(self) -> Self;

    fn mul_add(self, mul: Self, add: Self) -> 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_div_euclid(self, rhs: Self) -> Option<Self>;

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

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

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

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

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

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

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

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

    fn saturating_neg(self) -> Self;

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

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

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

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

    fn saturating_recip(self) -> Self;

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

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

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

    fn wrapping_neg(self) -> Self;

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

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

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

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

    fn wrapping_recip(self) -> Self;

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

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

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

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

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

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

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

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

    fn 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_recip(self) -> Self;

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

    fn unwrapped_div_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_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 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_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);
}

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.

ⓘThis example deliberately fails to compile
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.

ⓘThis example deliberately fails 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

type Bits

The primitive integer underlying type.

type Bytes

A byte array with the same size as the type.

type Frac: Unsigned

The number of fractional bits.

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

Loading content...

Associated Constants

const MIN: Self

The smallest value that can be represented.

const MAX: Self

The largest value that can be represented.

const INT_NBITS: u32

The number of integer bits.

const FRAC_NBITS: u32

The number of fractional bits.

Loading content...

Required methods

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

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

fn to_bits(self) -> Self::Bits

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

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

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

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

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

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

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

fn to_be_bytes(self) -> Self::Bytes

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

fn to_le_bytes(self) -> Self::Bytes

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

fn to_ne_bytes(self) -> Self::Bytes

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

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

Creates a fixed-point number from another number.

Returns the same value as src.to_fixed().

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

Converts a fixed-point number to another number.

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

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

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

Returns the same value as src.checked_to_fixed().

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

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

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

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

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

Returns the same value as src.saturating_to_fixed().

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

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

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

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

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

Returns the same value as src.wrapping_to_fixed().

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

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

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

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

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

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.

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

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

Converts a fixed-point number to another number.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

fn int(self) -> Self

Returns the integer part.

fn frac(self) -> Self

Returns the fractional part.

fn round_to_zero(self) -> Self

Rounds to the next integer towards 0.

fn ceil(self) -> Self

Rounds to the next integer towards +∞.

fn floor(self) -> Self

Rounds to the next integer towards −∞.

fn round(self) -> Self

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

fn round_ties_to_even(self) -> Self

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

fn checked_ceil(self) -> Option<Self>

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

fn checked_floor(self) -> Option<Self>

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

fn checked_round(self) -> Option<Self>

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

fn checked_round_ties_to_even(self) -> Option<Self>

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

fn saturating_ceil(self) -> Self

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

fn saturating_floor(self) -> Self

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

fn saturating_round(self) -> Self

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

fn saturating_round_ties_to_even(self) -> Self

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

fn wrapping_ceil(self) -> Self

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

fn wrapping_floor(self) -> Self

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

fn wrapping_round(self) -> Self

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

fn wrapping_round_ties_to_even(self) -> Self

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

fn unwrapped_ceil(self) -> Self

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

Panics

Panics if the result does not fit.

fn unwrapped_floor(self) -> Self

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

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.

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.

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.

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

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

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

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

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

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

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

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

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

fn count_ones(self) -> u32

Returns the number of ones in the binary representation.

fn count_zeros(self) -> u32

Returns the number of zeros in the binary representation.

fn leading_ones(self) -> u32

Returns the number of leading ones in the binary representation.

fn leading_zeros(self) -> u32

Returns the number of leading zeros in the binary representation.

fn trailing_ones(self) -> u32

Returns the number of trailing ones in the binary representation.

fn trailing_zeros(self) -> u32

Returns the number of trailing zeros in the binary representation.

fn int_log2(self) -> i32

Integer base-2 logarithm, rounded down.

Panics

Panics if the fixed-point number is ≤ 0.

fn int_log10(self) -> i32

Integer base-10 logarithm, rounded down.

Panics

Panics if the fixed-point number is ≤ 0.

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.

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.

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

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

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

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

fn recip(self) -> Self

Returns the reciprocal.

Panics

Panics if self 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.

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

Euclidean division by an integer.

Panics

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

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

Remainder for Euclidean division.

Panics

Panics if the divisor is zero.

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

Euclidean division by an integer.

Panics

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

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

Remainder for Euclidean division by an integer.

Panics

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

fn checked_neg(self) -> Option<Self>

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

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

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

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

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

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

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

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

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

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

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

fn checked_recip(self) -> Option<Self>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

fn saturating_neg(self) -> Self

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

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

Saturating addition. Returns the sum, saturating on overflow.

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

Saturating subtraction. Returns the difference, saturating on overflow.

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

Saturating multiplication. Returns the product, saturating on overflow.

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

Saturating division. Returns the quotient, saturating on overflow.

Panics

Panics if the divisor is zero.

fn saturating_recip(self) -> Self

Saturating reciprocal.

Panics

Panics if self is zero.

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

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

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

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

Panics

Panics if the divisor is zero.

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

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

fn wrapping_neg(self) -> Self

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

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

Wrapping addition. Returns the sum, wrapping on overflow.

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

Wrapping subtraction. Returns the difference, wrapping on overflow.

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

Wrapping multiplication. Returns the product, wrapping on overflow.

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

Wrapping division. Returns the quotient, wrapping on overflow.

Panics

Panics if the divisor is zero.

fn wrapping_recip(self) -> Self

Wrapping reciprocal.

Panics

Panics if self is zero.

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

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

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

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

Panics

Panics if the divisor is zero.

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

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

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

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

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

Panics

Panics if the divisor is zero.

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

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

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

Panics

Panics if the divisor is zero.

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

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

Panics

Panics if the divisor is zero.

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

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

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

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

fn unwrapped_neg(self) -> Self

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

Panics

Panics if the result does not fit.

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

Unwrapped addition. Returns the sum, panicking on overflow.

Panics

Panics if the result does not fit.

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

Unwrapped subtraction. Returns the difference, panicking on overflow.

Panics

Panics if the result does not fit.

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

Unwrapped multiplication. Returns the product, panicking on overflow.

Panics

Panics if the result does not fit.

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

Unwrapped division. Returns the quotient, panicking on overflow.

Panics

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

fn unwrapped_recip(self) -> Self

Unwrapped reciprocal. Returns reciprocal, panicking on overflow.

Panics

Panics if self 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.

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.

Panics

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

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

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

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.

Panics

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

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.

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.

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.

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.

Panics

Panics if rhs ≥ the number of bits.

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

Overflowing negation.

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

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

Overflowing addition.

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

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

Overflowing subtraction.

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

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

Overflowing multiplication.

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

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

Overflowing division.

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

Panics

Panics if the divisor is zero.

fn overflowing_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.

Panics

Panics if self 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.

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

Overflowing Euclidean division.

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

Panics

Panics if the divisor is zero.

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

Overflowing multiplication by an integer.

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

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

Overflowing division by an integer.

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

Panics

Panics if the divisor is zero.

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

Overflowing Euclidean division by an integer.

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

Panics

Panics if the divisor is zero.

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

Overflowing remainder for Euclidean division by an integer.

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

Panics

Panics if the divisor is zero.

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

Overflowing shift left.

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

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

Overflowing shift right.

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

Loading content...

Implementors

impl<Frac: LeEqU8> Fixed for FixedI8<Frac>[src]

type Bits = i8

type Bytes = [u8; 1]

type Frac = Frac

impl<Frac: LeEqU8> Fixed for FixedU8<Frac>[src]

type Bits = u8

type Bytes = [u8; 1]

type Frac = Frac

impl<Frac: LeEqU16> Fixed for FixedI16<Frac>[src]

type Bits = i16

type Bytes = [u8; 2]

type Frac = Frac

impl<Frac: LeEqU16> Fixed for FixedU16<Frac>[src]

type Bits = u16

type Bytes = [u8; 2]

type Frac = Frac

impl<Frac: LeEqU32> Fixed for FixedI32<Frac>[src]

type Bits = i32

type Bytes = [u8; 4]

type Frac = Frac

impl<Frac: LeEqU32> Fixed for FixedU32<Frac>[src]

type Bits = u32

type Bytes = [u8; 4]

type Frac = Frac

impl<Frac: LeEqU64> Fixed for FixedI64<Frac>[src]

type Bits = i64

type Bytes = [u8; 8]

type Frac = Frac

impl<Frac: LeEqU64> Fixed for FixedU64<Frac>[src]

type Bits = u64

type Bytes = [u8; 8]

type Frac = Frac

impl<Frac: LeEqU128> Fixed for FixedI128<Frac>[src]

type Bits = i128

type Bytes = [u8; 16]

type Frac = Frac

impl<Frac: LeEqU128> Fixed for FixedU128<Frac>[src]

type Bits = u128

type Bytes = [u8; 16]

type Frac = Frac

Loading content...