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

pub trait Fixed where
    Self: Default + Hash + Ord,
    Self: Pod + TransparentWrapper<Self::Bits>,
    Self: Debug + Display + Binary + Octal + LowerHex + UpperHex,
    Self: FromStr<Err = ParseFixedError>,
    Self: FromFixed + ToFixed,
    Self: Add<Output = Self> + AddAssign,
    Self: Sub<Output = Self> + SubAssign,
    Self: Mul<Output = Self> + MulAssign,
    Self: Div<Output = Self> + DivAssign,
    Self: Rem<Output = Self> + RemAssign,
    Self: Mul<Self::Bits, Output = Self> + MulAssign<Self::Bits>,
    Self: Div<Self::Bits, Output = Self> + DivAssign<Self::Bits>,
    Self: Rem<Self::Bits, Output = Self> + RemAssign<Self::Bits>,
    Self: 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;
    type Signed: FixedSigned;
    type Unsigned: FixedUnsigned;

    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;
    fn is_zero(self) -> bool;
    #[must_use = "this returns the result of the operation, without modifying the original"]
    fn dist(self, other: Self) -> 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>;
    #[must_use = "this returns the result of the operation, without modifying the original"]
    fn checked_dist(self, other: Self) -> 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;
    #[must_use = "this returns the result of the operation, without modifying the original"]
    fn saturating_dist(self, other: Self) -> 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;
    #[must_use = "this returns the result of the operation, without modifying the original"]
    fn wrapping_dist(self, other: Self) -> 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;
    #[must_use = "this returns the result of the operation, without modifying the original"]
    fn unwrapped_dist(self, other: Self) -> 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);
    #[must_use = "this returns the result of the operation, without modifying the original"]
    fn overflowing_dist(self, other: Self) -> (Self, bool);

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

Expand description

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

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

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

Examples

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

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

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

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

use fixed::traits::Fixed;

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

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

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

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

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

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

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

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

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

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

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

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

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

Associated Types

`type Bits`[src]

Expand description

The primitive integer underlying type.

Examples

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

`type Bytes`[src]

Expand description

A byte array with the same size as the type.

Examples

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

`type Frac: Unsigned`[src]

Expand description

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

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

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

Examples

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

`type Signed: FixedSigned`[src]

Expand description

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

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

Examples

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

`type Unsigned: FixedUnsigned`[src]

Expand description

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

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

Examples

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

Loading content...

Associated Constants

`const ZERO: Self`[src]

Expand description

Zero.

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

`const DELTA: Self`[src]

Expand description

The difference between any two successive representable numbers, Δ.

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

`const MIN: Self`[src]

Expand description

The smallest value that can be represented.

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

`const MAX: Self`[src]

Expand description

The largest value that can be represented.

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

`const IS_SIGNED: bool`[src]

Expand description

true if the type is signed.

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

`const INT_NBITS: u32`[src]

Expand description

The number of integer bits.

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

`const FRAC_NBITS: u32`[src]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

Returns the integer part.

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

`fn frac(self) -> Self`[src]

Expand description

Returns the fractional part.

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

`fn round_to_zero(self) -> Self`[src]

Expand description

Rounds to the next integer towards 0.

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

`fn ceil(self) -> Self`[src]

Expand description

Rounds to the next integer towards +∞.

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

`fn floor(self) -> Self`[src]

Expand description

Rounds to the next integer towards −∞.

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

`fn round(self) -> Self`[src]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

Returns the number of ones in the binary representation.

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

`fn count_zeros(self) -> u32`[src]

Expand description

Returns the number of zeros in the binary representation.

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

`fn leading_ones(self) -> u32`[src]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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

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

`fn is_zero(self) -> bool`[src]

Expand description

Returns true if the number is zero.

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

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

Expand description

Returns the distance from self to other.

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

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

Expand description

Returns the mean of self and other.

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

`fn recip(self) -> Self`[src]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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

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

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

Expand description

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

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

`fn saturating_neg(self) -> Self`[src]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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.

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

Expand description

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

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

`fn wrapping_neg(self) -> Self`[src]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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.

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

Expand description

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

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

`fn unwrapped_neg(self) -> Self`[src]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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.

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

Expand description

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

Panics

Panics if the result does not fit.

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

`fn overflowing_neg(self) -> (Self, bool)`[src]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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]

Expand description

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.

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

Expand description

Overflowing distance.

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

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

Loading content...

Provided methods

`fn get_signed(&self) -> Option<&Self::Signed>`[src]

Expand description

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

Examples

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

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

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

`fn get_unsigned(&self) -> Option<&Self::Unsigned>`[src]

Expand description

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

Examples

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

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

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

`fn get_signed_mut(&mut self) -> Option<&mut Self::Signed>`[src]

Expand description

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

Examples

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

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

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

`fn get_unsigned_mut(&mut self) -> Option<&mut Self::Unsigned>`[src]

Expand description

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

Examples

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

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

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