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

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,
    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: 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 Bytes;
    type Frac: Unsigned;

    const ZERO: Self;
    const DELTA: Self;
    const MIN: Self;
    const MAX: Self;
    const IS_SIGNED: bool;
    const INT_NBITS: u32;
    const FRAC_NBITS: u32;

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

    #[must_use = "this returns the result of the operation, without modifying the original"]
    fn reverse_bits(self) -> Self;

    #[must_use = "this returns the result of the operation, without modifying the original"]
    fn rotate_left(self, n: u32) -> Self;

    #[must_use = "this returns the result of the operation, without modifying the original"]
    fn rotate_right(self, n: u32) -> Self;

    #[must_use = "this returns the result of the operation, without modifying the original"]
    fn mean(self, other: Self) -> Self;

    fn recip(self) -> Self;

    #[must_use = "this returns the result of the operation, without modifying the original"]
    fn mul_add(self, mul: Self, add: Self) -> Self;

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

    #[must_use = "this returns the result of the operation, without modifying the original"]
    fn div_euclid(self, rhs: Self) -> Self;

    #[must_use = "this returns the result of the operation, without modifying the original"]
    fn rem_euclid(self, rhs: Self) -> Self;

    #[must_use = "this returns the result of the operation, without modifying the original"]
    fn div_euclid_int(self, rhs: Self::Bits) -> Self;

    #[must_use = "this returns the result of the operation, without modifying the original"]
    fn rem_euclid_int(self, rhs: Self::Bits) -> Self;

    fn checked_neg(self) -> Option<Self>;

    #[must_use = "this returns the result of the operation, without modifying the original"]
    fn checked_add(self, rhs: Self) -> Option<Self>;

    #[must_use = "this returns the result of the operation, without modifying the original"]
    fn checked_sub(self, rhs: Self) -> Option<Self>;

    #[must_use = "this returns the result of the operation, without modifying the original"]
    fn checked_mul(self, rhs: Self) -> Option<Self>;

    #[must_use = "this returns the result of the operation, without modifying the original"]
    fn checked_div(self, rhs: Self) -> Option<Self>;

    #[must_use = "this returns the result of the operation, without modifying the original"]
    fn checked_rem(self, rhs: Self) -> Option<Self>;

    fn checked_recip(self) -> Option<Self>;

    #[must_use = "this returns the result of the operation, without modifying the original"]
    fn checked_mul_add(self, mul: Self, add: Self) -> Option<Self>;

    #[must_use = "this `Option` may be a `None` variant indicating overflow, which should be handled"]
    fn checked_mul_acc(&mut self, a: Self, b: Self) -> Option<()>;

    #[must_use = "this returns the result of the operation, without modifying the original"]
    fn checked_div_euclid(self, rhs: Self) -> Option<Self>;

    #[must_use = "this returns the result of the operation, without modifying the original"]
    fn checked_rem_euclid(self, rhs: Self) -> Option<Self>;

    #[must_use = "this returns the result of the operation, without modifying the original"]
    fn checked_mul_int(self, rhs: Self::Bits) -> Option<Self>;

    #[must_use = "this returns the result of the operation, without modifying the original"]
    fn checked_div_int(self, rhs: Self::Bits) -> Option<Self>;

    #[must_use = "this returns the result of the operation, without modifying the original"]
    fn checked_rem_int(self, rhs: Self::Bits) -> Option<Self>;

    #[must_use = "this returns the result of the operation, without modifying the original"]
    fn checked_div_euclid_int(self, rhs: Self::Bits) -> Option<Self>;

    #[must_use = "this returns the result of the operation, without modifying the original"]
    fn checked_rem_euclid_int(self, rhs: Self::Bits) -> Option<Self>;

    #[must_use = "this returns the result of the operation, without modifying the original"]
    fn checked_shl(self, rhs: u32) -> Option<Self>;

    #[must_use = "this returns the result of the operation, without modifying the original"]
    fn checked_shr(self, rhs: u32) -> Option<Self>;

    fn saturating_neg(self) -> Self;

    #[must_use = "this returns the result of the operation, without modifying the original"]
    fn saturating_add(self, rhs: Self) -> Self;

    #[must_use = "this returns the result of the operation, without modifying the original"]
    fn saturating_sub(self, rhs: Self) -> Self;

    #[must_use = "this returns the result of the operation, without modifying the original"]
    fn saturating_mul(self, rhs: Self) -> Self;

    #[must_use = "this returns the result of the operation, without modifying the original"]
    fn saturating_div(self, rhs: Self) -> Self;

    fn saturating_recip(self) -> Self;

    #[must_use = "this returns the result of the operation, without modifying the original"]
    fn saturating_mul_add(self, mul: Self, add: Self) -> Self;

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

    #[must_use = "this returns the result of the operation, without modifying the original"]
    fn saturating_div_euclid(self, rhs: Self) -> Self;

    #[must_use = "this returns the result of the operation, without modifying the original"]
    fn saturating_mul_int(self, rhs: Self::Bits) -> Self;

    #[must_use = "this returns the result of the operation, without modifying the original"]
    fn saturating_div_euclid_int(self, rhs: Self::Bits) -> Self;

    #[must_use = "this returns the result of the operation, without modifying the original"]
    fn saturating_rem_euclid_int(self, rhs: Self::Bits) -> Self;

    fn wrapping_neg(self) -> Self;

    #[must_use = "this returns the result of the operation, without modifying the original"]
    fn wrapping_add(self, rhs: Self) -> Self;

    #[must_use = "this returns the result of the operation, without modifying the original"]
    fn wrapping_sub(self, rhs: Self) -> Self;

    #[must_use = "this returns the result of the operation, without modifying the original"]
    fn wrapping_mul(self, rhs: Self) -> Self;

    #[must_use = "this returns the result of the operation, without modifying the original"]
    fn wrapping_div(self, rhs: Self) -> Self;

    fn wrapping_recip(self) -> Self;

    #[must_use = "this returns the result of the operation, without modifying the original"]
    fn wrapping_mul_add(self, mul: Self, add: Self) -> Self;

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

    #[must_use = "this returns the result of the operation, without modifying the original"]
    fn wrapping_div_euclid(self, rhs: Self) -> Self;

    #[must_use = "this returns the result of the operation, without modifying the original"]
    fn wrapping_mul_int(self, rhs: Self::Bits) -> Self;

    #[must_use = "this returns the result of the operation, without modifying the original"]
    fn wrapping_div_int(self, rhs: Self::Bits) -> Self;

    #[must_use = "this returns the result of the operation, without modifying the original"]
    fn wrapping_div_euclid_int(self, rhs: Self::Bits) -> Self;

    #[must_use = "this returns the result of the operation, without modifying the original"]
    fn wrapping_rem_euclid_int(self, rhs: Self::Bits) -> Self;

    #[must_use = "this returns the result of the operation, without modifying the original"]
    fn wrapping_shl(self, rhs: u32) -> Self;

    #[must_use = "this returns the result of the operation, without modifying the original"]
    fn wrapping_shr(self, rhs: u32) -> Self;

    fn unwrapped_neg(self) -> Self;

    #[must_use = "this returns the result of the operation, without modifying the original"]
    fn unwrapped_add(self, rhs: Self) -> Self;

    #[must_use = "this returns the result of the operation, without modifying the original"]
    fn unwrapped_sub(self, rhs: Self) -> Self;

    #[must_use = "this returns the result of the operation, without modifying the original"]
    fn unwrapped_mul(self, rhs: Self) -> Self;

    #[must_use = "this returns the result of the operation, without modifying the original"]
    fn unwrapped_div(self, rhs: Self) -> Self;

    #[must_use = "this returns the result of the operation, without modifying the original"]
    fn unwrapped_rem(self, rhs: Self) -> Self;

    fn unwrapped_recip(self) -> Self;

    #[must_use = "this returns the result of the operation, without modifying the original"]
    fn unwrapped_mul_add(self, mul: Self, add: Self) -> Self;

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

    #[must_use = "this returns the result of the operation, without modifying the original"]
    fn unwrapped_div_euclid(self, rhs: Self) -> Self;

    #[must_use = "this returns the result of the operation, without modifying the original"]
    fn unwrapped_rem_euclid(self, rhs: Self) -> Self;

    #[must_use = "this returns the result of the operation, without modifying the original"]
    fn unwrapped_mul_int(self, rhs: Self::Bits) -> Self;

    #[must_use = "this returns the result of the operation, without modifying the original"]
    fn unwrapped_div_int(self, rhs: Self::Bits) -> Self;

    #[must_use = "this returns the result of the operation, without modifying the original"]
    fn unwrapped_rem_int(self, rhs: Self::Bits) -> Self;

    #[must_use = "this returns the result of the operation, without modifying the original"]
    fn unwrapped_div_euclid_int(self, rhs: Self::Bits) -> Self;

    #[must_use = "this returns the result of the operation, without modifying the original"]
    fn unwrapped_rem_euclid_int(self, rhs: Self::Bits) -> Self;

    #[must_use = "this returns the result of the operation, without modifying the original"]
    fn unwrapped_shl(self, rhs: u32) -> Self;

    #[must_use = "this returns the result of the operation, without modifying the original"]
    fn unwrapped_shr(self, rhs: u32) -> Self;

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

    #[must_use = "this returns the result of the operation, without modifying the original"]
    fn overflowing_add(self, rhs: Self) -> (Self, bool);

    #[must_use = "this returns the result of the operation, without modifying the original"]
    fn overflowing_sub(self, rhs: Self) -> (Self, bool);

    #[must_use = "this returns the result of the operation, without modifying the original"]
    fn overflowing_mul(self, rhs: Self) -> (Self, bool);

    #[must_use = "this returns the result of the operation, without modifying the original"]
    fn overflowing_div(self, rhs: Self) -> (Self, bool);

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

    #[must_use = "this returns the result of the operation, without modifying the original"]
    fn overflowing_mul_add(self, mul: Self, add: Self) -> (Self, bool);

    #[must_use = "this returns whether overflow occurs; use `wrapping_mul_acc` if the flag is not needed"]
    fn overflowing_mul_acc(&mut self, a: Self, b: Self) -> bool;

    #[must_use = "this returns the result of the operation, without modifying the original"]
    fn overflowing_div_euclid(self, rhs: Self) -> (Self, bool);

    #[must_use = "this returns the result of the operation, without modifying the original"]
    fn overflowing_mul_int(self, rhs: Self::Bits) -> (Self, bool);

    #[must_use = "this returns the result of the operation, without modifying the original"]
    fn overflowing_div_int(self, rhs: Self::Bits) -> (Self, bool);

    #[must_use = "this returns the result of the operation, without modifying the original"]
    fn overflowing_div_euclid_int(self, rhs: Self::Bits) -> (Self, bool);

    #[must_use = "this returns the result of the operation, without modifying the original"]
    fn overflowing_rem_euclid_int(self, rhs: Self::Bits) -> (Self, bool);

    #[must_use = "this returns the result of the operation, without modifying the original"]
    fn overflowing_shl(self, rhs: u32) -> (Self, bool);

    #[must_use = "this returns the result of the operation, without modifying the original"]
    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.

ⓘ
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

type Bits[src]

The primitive integer underlying type.

type Bytes[src]

A byte array with the same size as the type.

type Frac: Unsigned[src]

The number of fractional bits.

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

Loading content...

Associated Constants

const ZERO: Self[src]

Zero.

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

const DELTA: Self[src]

The difference between any two successive representable numbers, Δ.

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

const MIN: Self[src]

The smallest value that can be represented.

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

const MAX: Self[src]

The largest value that can be represented.

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

const IS_SIGNED: bool[src]

true if the type is signed.

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

const INT_NBITS: u32[src]

The number of integer bits.

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

const FRAC_NBITS: u32[src]

The number of fractional bits.

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

Loading content...

Required methods

fn from_bits(bits: Self::Bits) -> Self[src]

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[src]

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[src]

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[src]

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[src]

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[src]

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[src]

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[src]

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[src]

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[src]

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[src]

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[src]

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[src]

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[src]

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[src]

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>[src]

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>[src]

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[src]

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[src]

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[src]

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[src]

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[src]

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[src]

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)[src]

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)[src]

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>[src]

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>[src]

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>[src]

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>[src]

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>[src]

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>[src]

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>[src]

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>[src]

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>[src]

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>[src]

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>[src]

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 overflowing_from_str(src: &str) -> Result<(Self, bool), ParseFixedError>[src]

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>[src]

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>[src]

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>[src]

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[src]

Returns the integer part.

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

fn frac(self) -> Self[src]

Returns the fractional part.

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

fn round_to_zero(self) -> Self[src]

Rounds to the next integer towards 0.

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

fn ceil(self) -> Self[src]

Rounds to the next integer towards +∞.

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

fn floor(self) -> Self[src]

Rounds to the next integer towards −∞.

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

fn round(self) -> Self[src]

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[src]

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>[src]

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>[src]

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>[src]

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>[src]

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[src]

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[src]

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[src]

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[src]

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[src]

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[src]

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[src]

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[src]

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[src]

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[src]

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[src]

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[src]

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)[src]

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)[src]

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)[src]

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)[src]

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[src]

Returns the number of ones in the binary representation.

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

fn count_zeros(self) -> u32[src]

Returns the number of zeros in the binary representation.

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

fn leading_ones(self) -> u32[src]

Returns the number of leading ones in the binary representation.

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

fn leading_zeros(self) -> u32[src]

Returns the number of leading zeros in the binary representation.

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

fn trailing_ones(self) -> u32[src]

Returns the number of trailing ones in the binary representation.

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

fn trailing_zeros(self) -> u32[src]

Returns the number of trailing zeros in the binary representation.

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

fn int_log2(self) -> i32[src]

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[src]

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 checked_int_log2(self) -> Option<i32>[src]

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>[src]

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.

#[must_use = "this returns the result of the operation, without modifying the original"]
fn reverse_bits(self) -> Self[src]

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

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

#[must_use = "this returns the result of the operation, without modifying the original"]
fn rotate_left(self, n: u32) -> Self[src]

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

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

#[must_use = "this returns the result of the operation, without modifying the original"]
fn rotate_right(self, n: u32) -> Self[src]

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

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

#[must_use = "this returns the result of the operation, without modifying the original"]
fn mean(self, other: Self) -> Self[src]

Returns the mean of self and other.

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

fn recip(self) -> Self[src]

Returns the reciprocal.

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

Panics

Panics if self is zero.

#[must_use = "this returns the result of the operation, without modifying the original"]
fn mul_add(self, mul: Self, add: Self) -> Self[src]

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 mul_acc(&mut self, a: Self, b: Self)[src]

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.

#[must_use = "this returns the result of the operation, without modifying the original"]
fn div_euclid(self, rhs: Self) -> Self[src]

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.

#[must_use = "this returns the result of the operation, without modifying the original"]
fn rem_euclid(self, rhs: Self) -> Self[src]

Remainder for Euclidean division.

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

Panics

Panics if the divisor is zero.

#[must_use = "this returns the result of the operation, without modifying the original"]
fn div_euclid_int(self, rhs: Self::Bits) -> Self[src]

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.

#[must_use = "this returns the result of the operation, without modifying the original"]
fn rem_euclid_int(self, rhs: Self::Bits) -> Self[src]

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 checked_neg(self) -> Option<Self>[src]

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

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

#[must_use = "this returns the result of the operation, without modifying the original"]
fn checked_add(self, rhs: Self) -> Option<Self>[src]

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

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

#[must_use = "this returns the result of the operation, without modifying the original"]
fn checked_sub(self, rhs: Self) -> Option<Self>[src]

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

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

#[must_use = "this returns the result of the operation, without modifying the original"]
fn checked_mul(self, rhs: Self) -> Option<Self>[src]

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

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

#[must_use = "this returns the result of the operation, without modifying the original"]
fn checked_div(self, rhs: Self) -> Option<Self>[src]

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

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

#[must_use = "this returns the result of the operation, without modifying the original"]
fn checked_rem(self, rhs: Self) -> Option<Self>[src]

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>[src]

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

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

#[must_use = "this returns the result of the operation, without modifying the original"]
fn checked_mul_add(self, mul: Self, add: Self) -> Option<Self>[src]

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

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

#[must_use = "this `Option` may be a `None` variant indicating overflow, which should be handled"]
fn checked_mul_acc(&mut self, a: Self, b: Self) -> Option<()>[src]

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.

#[must_use = "this returns the result of the operation, without modifying the original"]
fn checked_div_euclid(self, rhs: Self) -> Option<Self>[src]

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.

#[must_use = "this returns the result of the operation, without modifying the original"]
fn checked_rem_euclid(self, rhs: Self) -> Option<Self>[src]

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.

#[must_use = "this returns the result of the operation, without modifying the original"]
fn checked_mul_int(self, rhs: Self::Bits) -> Option<Self>[src]

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

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

#[must_use = "this returns the result of the operation, without modifying the original"]
fn checked_div_int(self, rhs: Self::Bits) -> Option<Self>[src]

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.

#[must_use = "this returns the result of the operation, without modifying the original"]
fn checked_rem_int(self, rhs: Self::Bits) -> Option<Self>[src]

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.

#[must_use = "this returns the result of the operation, without modifying the original"]
fn checked_div_euclid_int(self, rhs: Self::Bits) -> Option<Self>[src]

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.

#[must_use = "this returns the result of the operation, without modifying the original"]
fn checked_rem_euclid_int(self, rhs: Self::Bits) -> Option<Self>[src]

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.

#[must_use = "this returns the result of the operation, without modifying the original"]
fn checked_shl(self, rhs: u32) -> Option<Self>[src]

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

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

#[must_use = "this returns the result of the operation, without modifying the original"]
fn checked_shr(self, rhs: u32) -> Option<Self>[src]

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 saturating_neg(self) -> Self[src]

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

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

#[must_use = "this returns the result of the operation, without modifying the original"]
fn saturating_add(self, rhs: Self) -> Self[src]

Saturating addition. Returns the sum, saturating on overflow.

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

#[must_use = "this returns the result of the operation, without modifying the original"]
fn saturating_sub(self, rhs: Self) -> Self[src]

Saturating subtraction. Returns the difference, saturating on overflow.

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

#[must_use = "this returns the result of the operation, without modifying the original"]
fn saturating_mul(self, rhs: Self) -> Self[src]

Saturating multiplication. Returns the product, saturating on overflow.

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

#[must_use = "this returns the result of the operation, without modifying the original"]
fn saturating_div(self, rhs: Self) -> Self[src]

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[src]

Saturating reciprocal.

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

Panics

Panics if self is zero.

#[must_use = "this returns the result of the operation, without modifying the original"]
fn saturating_mul_add(self, mul: Self, add: Self) -> Self[src]

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

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

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

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

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

#[must_use = "this returns the result of the operation, without modifying the original"]
fn saturating_div_euclid(self, rhs: Self) -> Self[src]

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.

#[must_use = "this returns the result of the operation, without modifying the original"]
fn saturating_mul_int(self, rhs: Self::Bits) -> Self[src]

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

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

#[must_use = "this returns the result of the operation, without modifying the original"]
fn saturating_div_euclid_int(self, rhs: Self::Bits) -> Self[src]

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.

#[must_use = "this returns the result of the operation, without modifying the original"]
fn saturating_rem_euclid_int(self, rhs: Self::Bits) -> Self[src]

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 wrapping_neg(self) -> Self[src]

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

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

#[must_use = "this returns the result of the operation, without modifying the original"]
fn wrapping_add(self, rhs: Self) -> Self[src]

Wrapping addition. Returns the sum, wrapping on overflow.

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

#[must_use = "this returns the result of the operation, without modifying the original"]
fn wrapping_sub(self, rhs: Self) -> Self[src]

Wrapping subtraction. Returns the difference, wrapping on overflow.

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

#[must_use = "this returns the result of the operation, without modifying the original"]
fn wrapping_mul(self, rhs: Self) -> Self[src]

Wrapping multiplication. Returns the product, wrapping on overflow.

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

#[must_use = "this returns the result of the operation, without modifying the original"]
fn wrapping_div(self, rhs: Self) -> Self[src]

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[src]

Wrapping reciprocal.

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

Panics

Panics if self is zero.

#[must_use = "this returns the result of the operation, without modifying the original"]
fn wrapping_mul_add(self, mul: Self, add: Self) -> Self[src]

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

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

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

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

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

#[must_use = "this returns the result of the operation, without modifying the original"]
fn wrapping_div_euclid(self, rhs: Self) -> Self[src]

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.

#[must_use = "this returns the result of the operation, without modifying the original"]
fn wrapping_mul_int(self, rhs: Self::Bits) -> Self[src]

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

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

#[must_use = "this returns the result of the operation, without modifying the original"]
fn wrapping_div_int(self, rhs: Self::Bits) -> Self[src]

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.

#[must_use = "this returns the result of the operation, without modifying the original"]
fn wrapping_div_euclid_int(self, rhs: Self::Bits) -> Self[src]

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.

#[must_use = "this returns the result of the operation, without modifying the original"]
fn wrapping_rem_euclid_int(self, rhs: Self::Bits) -> Self[src]

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.

#[must_use = "this returns the result of the operation, without modifying the original"]
fn wrapping_shl(self, rhs: u32) -> Self[src]

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.

#[must_use = "this returns the result of the operation, without modifying the original"]
fn wrapping_shr(self, rhs: u32) -> Self[src]

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 unwrapped_neg(self) -> Self[src]

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.

#[must_use = "this returns the result of the operation, without modifying the original"]
fn unwrapped_add(self, rhs: Self) -> Self[src]

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.

#[must_use = "this returns the result of the operation, without modifying the original"]
fn unwrapped_sub(self, rhs: Self) -> Self[src]

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.

#[must_use = "this returns the result of the operation, without modifying the original"]
fn unwrapped_mul(self, rhs: Self) -> Self[src]

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.

#[must_use = "this returns the result of the operation, without modifying the original"]
fn unwrapped_div(self, rhs: Self) -> Self[src]

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.

#[must_use = "this returns the result of the operation, without modifying the original"]
fn unwrapped_rem(self, rhs: Self) -> Self[src]

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[src]

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.

#[must_use = "this returns the result of the operation, without modifying the original"]
fn unwrapped_mul_add(self, mul: Self, add: Self) -> Self[src]

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_mul_acc(&mut self, a: Self, b: Self)[src]

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.

#[must_use = "this returns the result of the operation, without modifying the original"]
fn unwrapped_div_euclid(self, rhs: Self) -> Self[src]

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.

#[must_use = "this returns the result of the operation, without modifying the original"]
fn unwrapped_rem_euclid(self, rhs: Self) -> Self[src]

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.

#[must_use = "this returns the result of the operation, without modifying the original"]
fn unwrapped_mul_int(self, rhs: Self::Bits) -> Self[src]

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.

#[must_use = "this returns the result of the operation, without modifying the original"]
fn unwrapped_div_int(self, rhs: Self::Bits) -> Self[src]

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.

#[must_use = "this returns the result of the operation, without modifying the original"]
fn unwrapped_rem_int(self, rhs: Self::Bits) -> Self[src]

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.

#[must_use = "this returns the result of the operation, without modifying the original"]
fn unwrapped_div_euclid_int(self, rhs: Self::Bits) -> Self[src]

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.

#[must_use = "this returns the result of the operation, without modifying the original"]
fn unwrapped_rem_euclid_int(self, rhs: Self::Bits) -> Self[src]

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.

#[must_use = "this returns the result of the operation, without modifying the original"]
fn unwrapped_shl(self, rhs: u32) -> Self[src]

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.

#[must_use = "this returns the result of the operation, without modifying the original"]
fn unwrapped_shr(self, rhs: u32) -> Self[src]

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 overflowing_neg(self) -> (Self, bool)[src]

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.

#[must_use = "this returns the result of the operation, without modifying the original"]
fn overflowing_add(self, rhs: Self) -> (Self, bool)[src]

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.

#[must_use = "this returns the result of the operation, without modifying the original"]
fn overflowing_sub(self, rhs: Self) -> (Self, bool)[src]

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.

#[must_use = "this returns the result of the operation, without modifying the original"]
fn overflowing_mul(self, rhs: Self) -> (Self, bool)[src]

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.

#[must_use = "this returns the result of the operation, without modifying the original"]
fn overflowing_div(self, rhs: Self) -> (Self, bool)[src]

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)[src]

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.

#[must_use = "this returns the result of the operation, without modifying the original"]
fn overflowing_mul_add(self, mul: Self, add: Self) -> (Self, bool)[src]

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.

#[must_use = "this returns whether overflow occurs; use `wrapping_mul_acc` if the flag is not needed"]
fn overflowing_mul_acc(&mut self, a: Self, b: Self) -> bool[src]

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.

#[must_use = "this returns the result of the operation, without modifying the original"]
fn overflowing_div_euclid(self, rhs: Self) -> (Self, bool)[src]

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.

#[must_use = "this returns the result of the operation, without modifying the original"]
fn overflowing_mul_int(self, rhs: Self::Bits) -> (Self, bool)[src]

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.

#[must_use = "this returns the result of the operation, without modifying the original"]
fn overflowing_div_int(self, rhs: Self::Bits) -> (Self, bool)[src]

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.

#[must_use = "this returns the result of the operation, without modifying the original"]
fn overflowing_div_euclid_int(self, rhs: Self::Bits) -> (Self, bool)[src]

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.

#[must_use = "this returns the result of the operation, without modifying the original"]
fn overflowing_rem_euclid_int(self, rhs: Self::Bits) -> (Self, bool)[src]

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.

#[must_use = "this returns the result of the operation, without modifying the original"]
fn overflowing_shl(self, rhs: u32) -> (Self, bool)[src]

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.

#[must_use = "this returns the result of the operation, without modifying the original"]
fn overflowing_shr(self, rhs: u32) -> (Self, bool)[src]

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.

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