Struct fixed::F128Bits

#[repr(transparent)]
pub struct F128Bits(pub u128);

The bit representation of a binary128 floating-point number (f128).

This type can be used to

• convert between fixed-point numbers and the bit representation of 128-bit floating-point numbers.
• compare fixed-point numbers and the bit representation of 128-bit floating-point numbers.

Examples

use fixed::{types::I16F16, F128Bits};
// binary128 representation for 1.0 is 0x3FFF << 112
let one = F128Bits(0x3FFF_u128 << 112);

assert_eq!(I16F16::ONE.to_num::<F128Bits>(), one);
assert_eq!(I16F16::from_num(one), I16F16::ONE);

// fixed-point numbers can be compared directly to F128Bits values
assert!(I16F16::from_num(1.5) > one);
assert!(I16F16::from_num(0.5) < one);

Tuple Fields

0: u128

Trait Implementations

impl<Frac: LeEqU128> Cast<F128Bits> for FixedI128<Frac>

fn cast(self) -> F128Bits

Casts the value.

impl<Frac: LeEqU16> Cast<F128Bits> for FixedI16<Frac>

fn cast(self) -> F128Bits

Casts the value.

impl<Frac: LeEqU32> Cast<F128Bits> for FixedI32<Frac>

fn cast(self) -> F128Bits

Casts the value.

impl<Frac: LeEqU64> Cast<F128Bits> for FixedI64<Frac>

fn cast(self) -> F128Bits

Casts the value.

impl<Frac: LeEqU8> Cast<F128Bits> for FixedI8<Frac>

fn cast(self) -> F128Bits

Casts the value.

impl<Frac: LeEqU128> Cast<F128Bits> for FixedU128<Frac>

fn cast(self) -> F128Bits

Casts the value.

impl<Frac: LeEqU16> Cast<F128Bits> for FixedU16<Frac>

fn cast(self) -> F128Bits

Casts the value.

impl<Frac: LeEqU32> Cast<F128Bits> for FixedU32<Frac>

fn cast(self) -> F128Bits

Casts the value.

impl<Frac: LeEqU64> Cast<F128Bits> for FixedU64<Frac>

fn cast(self) -> F128Bits

Casts the value.

impl<Frac: LeEqU8> Cast<F128Bits> for FixedU8<Frac>

fn cast(self) -> F128Bits

Casts the value.

impl<Frac: LeEqU128> Cast<FixedI128<Frac>> for F128Bits

fn cast(self) -> FixedI128<Frac>

Casts the value.

impl<Frac: LeEqU16> Cast<FixedI16<Frac>> for F128Bits

fn cast(self) -> FixedI16<Frac>

Casts the value.

impl<Frac: LeEqU32> Cast<FixedI32<Frac>> for F128Bits

fn cast(self) -> FixedI32<Frac>

Casts the value.

impl<Frac: LeEqU64> Cast<FixedI64<Frac>> for F128Bits

fn cast(self) -> FixedI64<Frac>

Casts the value.

impl<Frac: LeEqU8> Cast<FixedI8<Frac>> for F128Bits

fn cast(self) -> FixedI8<Frac>

Casts the value.

impl<Frac: LeEqU128> Cast<FixedU128<Frac>> for F128Bits

fn cast(self) -> FixedU128<Frac>

Casts the value.

impl<Frac: LeEqU16> Cast<FixedU16<Frac>> for F128Bits

fn cast(self) -> FixedU16<Frac>

Casts the value.

impl<Frac: LeEqU32> Cast<FixedU32<Frac>> for F128Bits

fn cast(self) -> FixedU32<Frac>

Casts the value.

impl<Frac: LeEqU64> Cast<FixedU64<Frac>> for F128Bits

fn cast(self) -> FixedU64<Frac>

Casts the value.

impl<Frac: LeEqU8> Cast<FixedU8<Frac>> for F128Bits

fn cast(self) -> FixedU8<Frac>

Casts the value.

impl<Frac: LeEqU128> CheckedCast<F128Bits> for FixedI128<Frac>

fn checked_cast(self) -> Option<F128Bits>

Casts the value.

impl<Frac: LeEqU16> CheckedCast<F128Bits> for FixedI16<Frac>

fn checked_cast(self) -> Option<F128Bits>

Casts the value.

impl<Frac: LeEqU32> CheckedCast<F128Bits> for FixedI32<Frac>

fn checked_cast(self) -> Option<F128Bits>

Casts the value.

impl<Frac: LeEqU64> CheckedCast<F128Bits> for FixedI64<Frac>

fn checked_cast(self) -> Option<F128Bits>

Casts the value.

impl<Frac: LeEqU8> CheckedCast<F128Bits> for FixedI8<Frac>

fn checked_cast(self) -> Option<F128Bits>

Casts the value.

impl<Frac: LeEqU128> CheckedCast<F128Bits> for FixedU128<Frac>

fn checked_cast(self) -> Option<F128Bits>

Casts the value.

impl<Frac: LeEqU16> CheckedCast<F128Bits> for FixedU16<Frac>

fn checked_cast(self) -> Option<F128Bits>

Casts the value.

impl<Frac: LeEqU32> CheckedCast<F128Bits> for FixedU32<Frac>

fn checked_cast(self) -> Option<F128Bits>

Casts the value.

impl<Frac: LeEqU64> CheckedCast<F128Bits> for FixedU64<Frac>

fn checked_cast(self) -> Option<F128Bits>

Casts the value.

impl<Frac: LeEqU8> CheckedCast<F128Bits> for FixedU8<Frac>

fn checked_cast(self) -> Option<F128Bits>

Casts the value.

impl<Frac: LeEqU128> CheckedCast<FixedI128<Frac>> for F128Bits

fn checked_cast(self) -> Option<FixedI128<Frac>>

Casts the value.

impl<Frac: LeEqU16> CheckedCast<FixedI16<Frac>> for F128Bits

fn checked_cast(self) -> Option<FixedI16<Frac>>

Casts the value.

impl<Frac: LeEqU32> CheckedCast<FixedI32<Frac>> for F128Bits

fn checked_cast(self) -> Option<FixedI32<Frac>>

Casts the value.

impl<Frac: LeEqU64> CheckedCast<FixedI64<Frac>> for F128Bits

fn checked_cast(self) -> Option<FixedI64<Frac>>

Casts the value.

impl<Frac: LeEqU8> CheckedCast<FixedI8<Frac>> for F128Bits

fn checked_cast(self) -> Option<FixedI8<Frac>>

Casts the value.

impl<Frac: LeEqU128> CheckedCast<FixedU128<Frac>> for F128Bits

fn checked_cast(self) -> Option<FixedU128<Frac>>

Casts the value.

impl<Frac: LeEqU16> CheckedCast<FixedU16<Frac>> for F128Bits

fn checked_cast(self) -> Option<FixedU16<Frac>>

Casts the value.

impl<Frac: LeEqU32> CheckedCast<FixedU32<Frac>> for F128Bits

fn checked_cast(self) -> Option<FixedU32<Frac>>

Casts the value.

impl<Frac: LeEqU64> CheckedCast<FixedU64<Frac>> for F128Bits

fn checked_cast(self) -> Option<FixedU64<Frac>>

Casts the value.

impl<Frac: LeEqU8> CheckedCast<FixedU8<Frac>> for F128Bits

fn checked_cast(self) -> Option<FixedU8<Frac>>

Casts the value.

impl Clone for F128Bits

fn clone(&self) -> F128Bits

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for F128Bits

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for F128Bits

fn default() -> F128Bits

Returns the “default value” for a type.

impl<Frac: LeEqU16> From<FixedI16<Frac>> for F128Bits

fn from(src: FixedI16<Frac>) -> F128Bits

Converts a fixed-point number to a floating-point number.

This conversion never fails (infallible) and does not lose any precision (lossless).

impl<Frac: LeEqU32> From<FixedI32<Frac>> for F128Bits

fn from(src: FixedI32<Frac>) -> F128Bits

Converts a fixed-point number to a floating-point number.

This conversion never fails (infallible) and does not lose any precision (lossless).

impl<Frac: LeEqU64> From<FixedI64<Frac>> for F128Bits

fn from(src: FixedI64<Frac>) -> F128Bits

Converts a fixed-point number to a floating-point number.

This conversion never fails (infallible) and does not lose any precision (lossless).

impl<Frac: LeEqU8> From<FixedI8<Frac>> for F128Bits

fn from(src: FixedI8<Frac>) -> F128Bits

Converts a fixed-point number to a floating-point number.

This conversion never fails (infallible) and does not lose any precision (lossless).

impl<Frac: LeEqU16> From<FixedU16<Frac>> for F128Bits

fn from(src: FixedU16<Frac>) -> F128Bits

Converts a fixed-point number to a floating-point number.

This conversion never fails (infallible) and does not lose any precision (lossless).

impl<Frac: LeEqU32> From<FixedU32<Frac>> for F128Bits

fn from(src: FixedU32<Frac>) -> F128Bits

Converts a fixed-point number to a floating-point number.

This conversion never fails (infallible) and does not lose any precision (lossless).

impl<Frac: LeEqU64> From<FixedU64<Frac>> for F128Bits

fn from(src: FixedU64<Frac>) -> F128Bits

Converts a fixed-point number to a floating-point number.

This conversion never fails (infallible) and does not lose any precision (lossless).

impl<Frac: LeEqU8> From<FixedU8<Frac>> for F128Bits

fn from(src: FixedU8<Frac>) -> F128Bits

Converts a fixed-point number to a floating-point number.

This conversion never fails (infallible) and does not lose any precision (lossless).

impl FromFixed for F128Bits

fn from_fixed<F: Fixed>(src: F) -> Self

Converts a fixed-point number to a floating-point number.

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

Panics

When debug assertions are enabled, panics if the value does not fit. When debug assertions are not enabled, the wrapped value can be returned, but it is not considered a breaking change if in the future it panics; if wrapping is required use wrapping_from_fixed instead.

fn checked_from_fixed<F: Fixed>(src: F) -> Option<Self>

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

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

fn saturating_from_fixed<F: Fixed>(src: F) -> Self

Converts a fixed-point number to a floating-point number, saturating if it does not fit.

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

fn wrapping_from_fixed<F: Fixed>(src: F) -> Self

Converts a fixed-point number to a floating-point number, wrapping if it does not fit.

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

fn overflowing_from_fixed<F: Fixed>(src: F) -> (Self, bool)

Converts a fixed-point number to a floating-point number.

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

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

fn unwrapped_from_fixed<F: Fixed>(src: F) -> Self

Converts a fixed-point number to a floating-point number, panicking if it does not fit.

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

Panics

Panics if the value does not fit, even when debug assertions are not enabled.

impl Hash for F128Bits

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where
    H: Hasher,
    Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<Frac: LeEqU16> LosslessTryFrom<FixedI16<Frac>> for F128Bits

fn lossless_try_from(src: FixedI16<Frac>) -> Option<F128Bits>

Converts a fixed-point number to a floating-point number.

This conversion actually never fails (infallible) but does not lose any precision (lossless).

impl<Frac: LeEqU32> LosslessTryFrom<FixedI32<Frac>> for F128Bits

fn lossless_try_from(src: FixedI32<Frac>) -> Option<F128Bits>

Converts a fixed-point number to a floating-point number.

This conversion actually never fails (infallible) but does not lose any precision (lossless).

impl<Frac: LeEqU64> LosslessTryFrom<FixedI64<Frac>> for F128Bits

fn lossless_try_from(src: FixedI64<Frac>) -> Option<F128Bits>

Converts a fixed-point number to a floating-point number.

This conversion actually never fails (infallible) but does not lose any precision (lossless).

impl<Frac: LeEqU8> LosslessTryFrom<FixedI8<Frac>> for F128Bits

fn lossless_try_from(src: FixedI8<Frac>) -> Option<F128Bits>

Converts a fixed-point number to a floating-point number.

This conversion actually never fails (infallible) but does not lose any precision (lossless).

impl<Frac: LeEqU16> LosslessTryFrom<FixedU16<Frac>> for F128Bits

fn lossless_try_from(src: FixedU16<Frac>) -> Option<F128Bits>

Converts a fixed-point number to a floating-point number.

This conversion actually never fails (infallible) but does not lose any precision (lossless).

impl<Frac: LeEqU32> LosslessTryFrom<FixedU32<Frac>> for F128Bits

fn lossless_try_from(src: FixedU32<Frac>) -> Option<F128Bits>

Converts a fixed-point number to a floating-point number.

This conversion actually never fails (infallible) but does not lose any precision (lossless).

impl<Frac: LeEqU64> LosslessTryFrom<FixedU64<Frac>> for F128Bits

fn lossless_try_from(src: FixedU64<Frac>) -> Option<F128Bits>

Converts a fixed-point number to a floating-point number.

This conversion actually never fails (infallible) but does not lose any precision (lossless).

impl<Frac: LeEqU8> LosslessTryFrom<FixedU8<Frac>> for F128Bits

fn lossless_try_from(src: FixedU8<Frac>) -> Option<F128Bits>

Converts a fixed-point number to a floating-point number.

This conversion actually never fails (infallible) but does not lose any precision (lossless).

impl LosslessTryFrom<i16> for F128Bits

fn lossless_try_from(src: i16) -> Option<F128Bits>

Converts an integer to a floating-point number.

This conversion actually never fails (infallible) and does not lose precision (lossless).

impl LosslessTryFrom<i32> for F128Bits

fn lossless_try_from(src: i32) -> Option<F128Bits>

Converts an integer to a floating-point number.

This conversion actually never fails (infallible) and does not lose precision (lossless).

impl LosslessTryFrom<i64> for F128Bits

fn lossless_try_from(src: i64) -> Option<F128Bits>

Converts an integer to a floating-point number.

This conversion actually never fails (infallible) and does not lose precision (lossless).

impl LosslessTryFrom<i8> for F128Bits

fn lossless_try_from(src: i8) -> Option<F128Bits>

Converts an integer to a floating-point number.

This conversion actually never fails (infallible) and does not lose precision (lossless).

impl LosslessTryFrom<u16> for F128Bits

fn lossless_try_from(src: u16) -> Option<F128Bits>

Converts an integer to a floating-point number.

This conversion actually never fails (infallible) and does not lose precision (lossless).

impl LosslessTryFrom<u32> for F128Bits

fn lossless_try_from(src: u32) -> Option<F128Bits>

Converts an integer to a floating-point number.

This conversion actually never fails (infallible) and does not lose precision (lossless).

impl LosslessTryFrom<u64> for F128Bits

fn lossless_try_from(src: u64) -> Option<F128Bits>

Converts an integer to a floating-point number.

This conversion actually never fails (infallible) and does not lose precision (lossless).

impl LosslessTryFrom<u8> for F128Bits

fn lossless_try_from(src: u8) -> Option<F128Bits>

Converts an integer to a floating-point number.

This conversion actually never fails (infallible) and does not lose precision (lossless).

impl<Frac: LeEqU128> LossyFrom<FixedI128<Frac>> for F128Bits

fn lossy_from(src: FixedI128<Frac>) -> F128Bits

Converts a fixed-point number to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl<Frac: LeEqU16> LossyFrom<FixedI16<Frac>> for F128Bits

fn lossy_from(src: FixedI16<Frac>) -> F128Bits

Converts a fixed-point number to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl<Frac: LeEqU32> LossyFrom<FixedI32<Frac>> for F128Bits

fn lossy_from(src: FixedI32<Frac>) -> F128Bits

Converts a fixed-point number to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl<Frac: LeEqU64> LossyFrom<FixedI64<Frac>> for F128Bits

fn lossy_from(src: FixedI64<Frac>) -> F128Bits

Converts a fixed-point number to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl<Frac: LeEqU8> LossyFrom<FixedI8<Frac>> for F128Bits

fn lossy_from(src: FixedI8<Frac>) -> F128Bits

Converts a fixed-point number to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl<Frac: LeEqU128> LossyFrom<FixedU128<Frac>> for F128Bits

fn lossy_from(src: FixedU128<Frac>) -> F128Bits

Converts a fixed-point number to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl<Frac: LeEqU16> LossyFrom<FixedU16<Frac>> for F128Bits

fn lossy_from(src: FixedU16<Frac>) -> F128Bits

Converts a fixed-point number to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl<Frac: LeEqU32> LossyFrom<FixedU32<Frac>> for F128Bits

fn lossy_from(src: FixedU32<Frac>) -> F128Bits

Converts a fixed-point number to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl<Frac: LeEqU64> LossyFrom<FixedU64<Frac>> for F128Bits

fn lossy_from(src: FixedU64<Frac>) -> F128Bits

Converts a fixed-point number to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl<Frac: LeEqU8> LossyFrom<FixedU8<Frac>> for F128Bits

fn lossy_from(src: FixedU8<Frac>) -> F128Bits

Converts a fixed-point number to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl LossyFrom<i128> for F128Bits

fn lossy_from(src: i128) -> F128Bits

Converts an integer to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl LossyFrom<i16> for F128Bits

fn lossy_from(src: i16) -> F128Bits

Converts an integer to a floating-point number.

This conversion never fails (infallible) and actually does not lose precision (lossless).

impl LossyFrom<i32> for F128Bits

fn lossy_from(src: i32) -> F128Bits

Converts an integer to a floating-point number.

This conversion never fails (infallible) and actually does not lose precision (lossless).

impl LossyFrom<i64> for F128Bits

fn lossy_from(src: i64) -> F128Bits

Converts an integer to a floating-point number.

This conversion never fails (infallible) and actually does not lose precision (lossless).

impl LossyFrom<i8> for F128Bits

fn lossy_from(src: i8) -> F128Bits

Converts an integer to a floating-point number.

This conversion never fails (infallible) and actually does not lose precision (lossless).

impl LossyFrom<isize> for F128Bits

fn lossy_from(src: isize) -> F128Bits

Converts an integer to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl LossyFrom<u128> for F128Bits

fn lossy_from(src: u128) -> F128Bits

Converts an integer to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl LossyFrom<u16> for F128Bits

fn lossy_from(src: u16) -> F128Bits

Converts an integer to a floating-point number.

This conversion never fails (infallible) and actually does not lose precision (lossless).

impl LossyFrom<u32> for F128Bits

fn lossy_from(src: u32) -> F128Bits

Converts an integer to a floating-point number.

This conversion never fails (infallible) and actually does not lose precision (lossless).

impl LossyFrom<u64> for F128Bits

fn lossy_from(src: u64) -> F128Bits

Converts an integer to a floating-point number.

This conversion never fails (infallible) and actually does not lose precision (lossless).

impl LossyFrom<u8> for F128Bits

fn lossy_from(src: u8) -> F128Bits

Converts an integer to a floating-point number.

This conversion never fails (infallible) and actually does not lose precision (lossless).

impl LossyFrom<usize> for F128Bits

fn lossy_from(src: usize) -> F128Bits

Converts an integer to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl Ord for F128Bits

fn cmp(&self, other: &F128Bits) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Selfwhere
    Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Selfwhere
    Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere
    Self: Sized + PartialOrd<Self>,

Restrict a value to a certain interval.

impl<Frac: LeEqU128> OverflowingCast<F128Bits> for FixedI128<Frac>

fn overflowing_cast(self) -> (F128Bits, bool)

Casts the value.

impl<Frac: LeEqU16> OverflowingCast<F128Bits> for FixedI16<Frac>

fn overflowing_cast(self) -> (F128Bits, bool)

Casts the value.

impl<Frac: LeEqU32> OverflowingCast<F128Bits> for FixedI32<Frac>

fn overflowing_cast(self) -> (F128Bits, bool)

Casts the value.

impl<Frac: LeEqU64> OverflowingCast<F128Bits> for FixedI64<Frac>

fn overflowing_cast(self) -> (F128Bits, bool)

Casts the value.

impl<Frac: LeEqU8> OverflowingCast<F128Bits> for FixedI8<Frac>

fn overflowing_cast(self) -> (F128Bits, bool)

Casts the value.

impl<Frac: LeEqU128> OverflowingCast<F128Bits> for FixedU128<Frac>

fn overflowing_cast(self) -> (F128Bits, bool)

Casts the value.

impl<Frac: LeEqU16> OverflowingCast<F128Bits> for FixedU16<Frac>

fn overflowing_cast(self) -> (F128Bits, bool)

Casts the value.

impl<Frac: LeEqU32> OverflowingCast<F128Bits> for FixedU32<Frac>

fn overflowing_cast(self) -> (F128Bits, bool)

Casts the value.

impl<Frac: LeEqU64> OverflowingCast<F128Bits> for FixedU64<Frac>

fn overflowing_cast(self) -> (F128Bits, bool)

Casts the value.

impl<Frac: LeEqU8> OverflowingCast<F128Bits> for FixedU8<Frac>

fn overflowing_cast(self) -> (F128Bits, bool)

Casts the value.

impl<Frac: LeEqU128> OverflowingCast<FixedI128<Frac>> for F128Bits

fn overflowing_cast(self) -> (FixedI128<Frac>, bool)

Casts the value.

impl<Frac: LeEqU16> OverflowingCast<FixedI16<Frac>> for F128Bits

fn overflowing_cast(self) -> (FixedI16<Frac>, bool)

Casts the value.

impl<Frac: LeEqU32> OverflowingCast<FixedI32<Frac>> for F128Bits

fn overflowing_cast(self) -> (FixedI32<Frac>, bool)

Casts the value.

impl<Frac: LeEqU64> OverflowingCast<FixedI64<Frac>> for F128Bits

fn overflowing_cast(self) -> (FixedI64<Frac>, bool)

Casts the value.

impl<Frac: LeEqU8> OverflowingCast<FixedI8<Frac>> for F128Bits

fn overflowing_cast(self) -> (FixedI8<Frac>, bool)

Casts the value.

impl<Frac: LeEqU128> OverflowingCast<FixedU128<Frac>> for F128Bits

fn overflowing_cast(self) -> (FixedU128<Frac>, bool)

Casts the value.

impl<Frac: LeEqU16> OverflowingCast<FixedU16<Frac>> for F128Bits

fn overflowing_cast(self) -> (FixedU16<Frac>, bool)

Casts the value.

impl<Frac: LeEqU32> OverflowingCast<FixedU32<Frac>> for F128Bits

fn overflowing_cast(self) -> (FixedU32<Frac>, bool)

Casts the value.

impl<Frac: LeEqU64> OverflowingCast<FixedU64<Frac>> for F128Bits

fn overflowing_cast(self) -> (FixedU64<Frac>, bool)

Casts the value.

impl<Frac: LeEqU8> OverflowingCast<FixedU8<Frac>> for F128Bits

fn overflowing_cast(self) -> (FixedU8<Frac>, bool)

Casts the value.

impl PartialEq<F128Bits> for F128Bits

fn eq(&self, other: &F128Bits) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<Frac: LeEqU128> PartialEq<F128Bits> for FixedI128<Frac>

fn eq(&self, rhs: &F128Bits) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<Frac: LeEqU16> PartialEq<F128Bits> for FixedI16<Frac>

fn eq(&self, rhs: &F128Bits) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<Frac: LeEqU32> PartialEq<F128Bits> for FixedI32<Frac>

fn eq(&self, rhs: &F128Bits) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<Frac: LeEqU64> PartialEq<F128Bits> for FixedI64<Frac>

fn eq(&self, rhs: &F128Bits) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<Frac: LeEqU8> PartialEq<F128Bits> for FixedI8<Frac>

fn eq(&self, rhs: &F128Bits) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<Frac: LeEqU128> PartialEq<F128Bits> for FixedU128<Frac>

fn eq(&self, rhs: &F128Bits) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<Frac: LeEqU16> PartialEq<F128Bits> for FixedU16<Frac>

fn eq(&self, rhs: &F128Bits) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<Frac: LeEqU32> PartialEq<F128Bits> for FixedU32<Frac>

fn eq(&self, rhs: &F128Bits) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<Frac: LeEqU64> PartialEq<F128Bits> for FixedU64<Frac>

fn eq(&self, rhs: &F128Bits) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<Frac: LeEqU8> PartialEq<F128Bits> for FixedU8<Frac>

fn eq(&self, rhs: &F128Bits) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<Frac: LeEqU128> PartialEq<FixedI128<Frac>> for F128Bits

fn eq(&self, rhs: &FixedI128<Frac>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<Frac: LeEqU16> PartialEq<FixedI16<Frac>> for F128Bits

fn eq(&self, rhs: &FixedI16<Frac>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<Frac: LeEqU32> PartialEq<FixedI32<Frac>> for F128Bits

fn eq(&self, rhs: &FixedI32<Frac>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<Frac: LeEqU64> PartialEq<FixedI64<Frac>> for F128Bits

fn eq(&self, rhs: &FixedI64<Frac>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<Frac: LeEqU8> PartialEq<FixedI8<Frac>> for F128Bits

fn eq(&self, rhs: &FixedI8<Frac>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<Frac: LeEqU128> PartialEq<FixedU128<Frac>> for F128Bits

fn eq(&self, rhs: &FixedU128<Frac>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<Frac: LeEqU16> PartialEq<FixedU16<Frac>> for F128Bits

fn eq(&self, rhs: &FixedU16<Frac>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<Frac: LeEqU32> PartialEq<FixedU32<Frac>> for F128Bits

fn eq(&self, rhs: &FixedU32<Frac>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<Frac: LeEqU64> PartialEq<FixedU64<Frac>> for F128Bits

fn eq(&self, rhs: &FixedU64<Frac>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<Frac: LeEqU8> PartialEq<FixedU8<Frac>> for F128Bits

fn eq(&self, rhs: &FixedU8<Frac>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd<F128Bits> for F128Bits

fn partial_cmp(&self, other: &F128Bits) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<Frac: LeEqU128> PartialOrd<F128Bits> for FixedI128<Frac>

fn partial_cmp(&self, rhs: &F128Bits) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, rhs: &F128Bits) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, rhs: &F128Bits) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, rhs: &F128Bits) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, rhs: &F128Bits) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<Frac: LeEqU16> PartialOrd<F128Bits> for FixedI16<Frac>

fn partial_cmp(&self, rhs: &F128Bits) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, rhs: &F128Bits) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, rhs: &F128Bits) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, rhs: &F128Bits) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, rhs: &F128Bits) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<Frac: LeEqU32> PartialOrd<F128Bits> for FixedI32<Frac>

fn partial_cmp(&self, rhs: &F128Bits) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, rhs: &F128Bits) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, rhs: &F128Bits) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, rhs: &F128Bits) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, rhs: &F128Bits) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<Frac: LeEqU64> PartialOrd<F128Bits> for FixedI64<Frac>

fn partial_cmp(&self, rhs: &F128Bits) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, rhs: &F128Bits) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, rhs: &F128Bits) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, rhs: &F128Bits) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, rhs: &F128Bits) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<Frac: LeEqU8> PartialOrd<F128Bits> for FixedI8<Frac>

fn partial_cmp(&self, rhs: &F128Bits) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, rhs: &F128Bits) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, rhs: &F128Bits) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, rhs: &F128Bits) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, rhs: &F128Bits) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<Frac: LeEqU128> PartialOrd<F128Bits> for FixedU128<Frac>

fn partial_cmp(&self, rhs: &F128Bits) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, rhs: &F128Bits) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, rhs: &F128Bits) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, rhs: &F128Bits) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, rhs: &F128Bits) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<Frac: LeEqU16> PartialOrd<F128Bits> for FixedU16<Frac>

fn partial_cmp(&self, rhs: &F128Bits) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, rhs: &F128Bits) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, rhs: &F128Bits) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, rhs: &F128Bits) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, rhs: &F128Bits) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<Frac: LeEqU32> PartialOrd<F128Bits> for FixedU32<Frac>

fn partial_cmp(&self, rhs: &F128Bits) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, rhs: &F128Bits) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, rhs: &F128Bits) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, rhs: &F128Bits) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, rhs: &F128Bits) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<Frac: LeEqU64> PartialOrd<F128Bits> for FixedU64<Frac>

fn partial_cmp(&self, rhs: &F128Bits) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, rhs: &F128Bits) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, rhs: &F128Bits) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, rhs: &F128Bits) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, rhs: &F128Bits) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<Frac: LeEqU8> PartialOrd<F128Bits> for FixedU8<Frac>

fn partial_cmp(&self, rhs: &F128Bits) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, rhs: &F128Bits) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, rhs: &F128Bits) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, rhs: &F128Bits) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, rhs: &F128Bits) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<Frac: LeEqU128> PartialOrd<FixedI128<Frac>> for F128Bits

fn partial_cmp(&self, rhs: &FixedI128<Frac>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, rhs: &FixedI128<Frac>) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, rhs: &FixedI128<Frac>) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, rhs: &FixedI128<Frac>) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, rhs: &FixedI128<Frac>) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<Frac: LeEqU16> PartialOrd<FixedI16<Frac>> for F128Bits

fn partial_cmp(&self, rhs: &FixedI16<Frac>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, rhs: &FixedI16<Frac>) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, rhs: &FixedI16<Frac>) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, rhs: &FixedI16<Frac>) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, rhs: &FixedI16<Frac>) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<Frac: LeEqU32> PartialOrd<FixedI32<Frac>> for F128Bits

fn partial_cmp(&self, rhs: &FixedI32<Frac>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, rhs: &FixedI32<Frac>) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, rhs: &FixedI32<Frac>) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, rhs: &FixedI32<Frac>) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, rhs: &FixedI32<Frac>) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<Frac: LeEqU64> PartialOrd<FixedI64<Frac>> for F128Bits

fn partial_cmp(&self, rhs: &FixedI64<Frac>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, rhs: &FixedI64<Frac>) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, rhs: &FixedI64<Frac>) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, rhs: &FixedI64<Frac>) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, rhs: &FixedI64<Frac>) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<Frac: LeEqU8> PartialOrd<FixedI8<Frac>> for F128Bits

fn partial_cmp(&self, rhs: &FixedI8<Frac>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, rhs: &FixedI8<Frac>) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, rhs: &FixedI8<Frac>) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, rhs: &FixedI8<Frac>) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, rhs: &FixedI8<Frac>) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<Frac: LeEqU128> PartialOrd<FixedU128<Frac>> for F128Bits

fn partial_cmp(&self, rhs: &FixedU128<Frac>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, rhs: &FixedU128<Frac>) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, rhs: &FixedU128<Frac>) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, rhs: &FixedU128<Frac>) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, rhs: &FixedU128<Frac>) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<Frac: LeEqU16> PartialOrd<FixedU16<Frac>> for F128Bits

fn partial_cmp(&self, rhs: &FixedU16<Frac>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, rhs: &FixedU16<Frac>) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, rhs: &FixedU16<Frac>) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, rhs: &FixedU16<Frac>) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, rhs: &FixedU16<Frac>) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<Frac: LeEqU32> PartialOrd<FixedU32<Frac>> for F128Bits

fn partial_cmp(&self, rhs: &FixedU32<Frac>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, rhs: &FixedU32<Frac>) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, rhs: &FixedU32<Frac>) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, rhs: &FixedU32<Frac>) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, rhs: &FixedU32<Frac>) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<Frac: LeEqU64> PartialOrd<FixedU64<Frac>> for F128Bits

fn partial_cmp(&self, rhs: &FixedU64<Frac>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, rhs: &FixedU64<Frac>) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, rhs: &FixedU64<Frac>) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, rhs: &FixedU64<Frac>) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, rhs: &FixedU64<Frac>) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<Frac: LeEqU8> PartialOrd<FixedU8<Frac>> for F128Bits

fn partial_cmp(&self, rhs: &FixedU8<Frac>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, rhs: &FixedU8<Frac>) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, rhs: &FixedU8<Frac>) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, rhs: &FixedU8<Frac>) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, rhs: &FixedU8<Frac>) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<Frac: LeEqU128> SaturatingCast<F128Bits> for FixedI128<Frac>

fn saturating_cast(self) -> F128Bits

Casts the value.

impl<Frac: LeEqU16> SaturatingCast<F128Bits> for FixedI16<Frac>

fn saturating_cast(self) -> F128Bits

Casts the value.

impl<Frac: LeEqU32> SaturatingCast<F128Bits> for FixedI32<Frac>

fn saturating_cast(self) -> F128Bits

Casts the value.

impl<Frac: LeEqU64> SaturatingCast<F128Bits> for FixedI64<Frac>

fn saturating_cast(self) -> F128Bits

Casts the value.

impl<Frac: LeEqU8> SaturatingCast<F128Bits> for FixedI8<Frac>

fn saturating_cast(self) -> F128Bits

Casts the value.

impl<Frac: LeEqU128> SaturatingCast<F128Bits> for FixedU128<Frac>

fn saturating_cast(self) -> F128Bits

Casts the value.

impl<Frac: LeEqU16> SaturatingCast<F128Bits> for FixedU16<Frac>

fn saturating_cast(self) -> F128Bits

Casts the value.

impl<Frac: LeEqU32> SaturatingCast<F128Bits> for FixedU32<Frac>

fn saturating_cast(self) -> F128Bits

Casts the value.

impl<Frac: LeEqU64> SaturatingCast<F128Bits> for FixedU64<Frac>

fn saturating_cast(self) -> F128Bits

Casts the value.

impl<Frac: LeEqU8> SaturatingCast<F128Bits> for FixedU8<Frac>

fn saturating_cast(self) -> F128Bits

Casts the value.

impl<Frac: LeEqU128> SaturatingCast<FixedI128<Frac>> for F128Bits

fn saturating_cast(self) -> FixedI128<Frac>

Casts the value.

impl<Frac: LeEqU16> SaturatingCast<FixedI16<Frac>> for F128Bits

fn saturating_cast(self) -> FixedI16<Frac>

Casts the value.

impl<Frac: LeEqU32> SaturatingCast<FixedI32<Frac>> for F128Bits

fn saturating_cast(self) -> FixedI32<Frac>

Casts the value.

impl<Frac: LeEqU64> SaturatingCast<FixedI64<Frac>> for F128Bits

fn saturating_cast(self) -> FixedI64<Frac>

Casts the value.

impl<Frac: LeEqU8> SaturatingCast<FixedI8<Frac>> for F128Bits

fn saturating_cast(self) -> FixedI8<Frac>

Casts the value.

impl<Frac: LeEqU128> SaturatingCast<FixedU128<Frac>> for F128Bits

fn saturating_cast(self) -> FixedU128<Frac>

Casts the value.

impl<Frac: LeEqU16> SaturatingCast<FixedU16<Frac>> for F128Bits

fn saturating_cast(self) -> FixedU16<Frac>

Casts the value.

impl<Frac: LeEqU32> SaturatingCast<FixedU32<Frac>> for F128Bits

fn saturating_cast(self) -> FixedU32<Frac>

Casts the value.

impl<Frac: LeEqU64> SaturatingCast<FixedU64<Frac>> for F128Bits

fn saturating_cast(self) -> FixedU64<Frac>

Casts the value.

impl<Frac: LeEqU8> SaturatingCast<FixedU8<Frac>> for F128Bits

fn saturating_cast(self) -> FixedU8<Frac>

Casts the value.

impl ToFixed for F128Bits

fn to_fixed<F: Fixed>(self) -> F

Converts a floating-point number to a fixed-point number.

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

Panics

Panics if self is not finite.

When debug assertions are enabled, also panics if the value does not fit. When debug assertions are not enabled, the wrapped value can be returned, but it is not considered a breaking change if in the future it panics; if wrapping is required use wrapping_to_fixed instead.

fn checked_to_fixed<F: Fixed>(self) -> Option<F>

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

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

fn saturating_to_fixed<F: Fixed>(self) -> F

Converts a floating-point number to a fixed-point number, saturating if it does not fit.

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

Panics

Panics if self is NaN.

fn wrapping_to_fixed<F: Fixed>(self) -> F

Converts a floating-point number to a fixed-point number, wrapping if it does not fit.

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

Panics

Panics if self is not finite.

fn overflowing_to_fixed<F: Fixed>(self) -> (F, bool)

Converts a floating-point number to 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.

Panics

Panics if self is not finite.

fn unwrapped_to_fixed<F: Fixed>(self) -> F

Converts a floating-point number to a fixed-point number, panicking if it does not fit.

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

Panics

Panics if self is not finite or if the value does not fit, even when debug assertions are not enabled.

impl<Frac: LeEqU128> UnwrappedCast<F128Bits> for FixedI128<Frac>

fn unwrapped_cast(self) -> F128Bits

Casts the value.

impl<Frac: LeEqU16> UnwrappedCast<F128Bits> for FixedI16<Frac>

fn unwrapped_cast(self) -> F128Bits

Casts the value.

impl<Frac: LeEqU32> UnwrappedCast<F128Bits> for FixedI32<Frac>

fn unwrapped_cast(self) -> F128Bits

Casts the value.

impl<Frac: LeEqU64> UnwrappedCast<F128Bits> for FixedI64<Frac>

fn unwrapped_cast(self) -> F128Bits

Casts the value.

impl<Frac: LeEqU8> UnwrappedCast<F128Bits> for FixedI8<Frac>

fn unwrapped_cast(self) -> F128Bits

Casts the value.

impl<Frac: LeEqU128> UnwrappedCast<F128Bits> for FixedU128<Frac>

fn unwrapped_cast(self) -> F128Bits

Casts the value.

impl<Frac: LeEqU16> UnwrappedCast<F128Bits> for FixedU16<Frac>

fn unwrapped_cast(self) -> F128Bits

Casts the value.

impl<Frac: LeEqU32> UnwrappedCast<F128Bits> for FixedU32<Frac>

fn unwrapped_cast(self) -> F128Bits

Casts the value.

impl<Frac: LeEqU64> UnwrappedCast<F128Bits> for FixedU64<Frac>

fn unwrapped_cast(self) -> F128Bits

Casts the value.

impl<Frac: LeEqU8> UnwrappedCast<F128Bits> for FixedU8<Frac>

fn unwrapped_cast(self) -> F128Bits

Casts the value.

impl<Frac: LeEqU128> UnwrappedCast<FixedI128<Frac>> for F128Bits

fn unwrapped_cast(self) -> FixedI128<Frac>

Casts the value.

impl<Frac: LeEqU16> UnwrappedCast<FixedI16<Frac>> for F128Bits

fn unwrapped_cast(self) -> FixedI16<Frac>

Casts the value.

impl<Frac: LeEqU32> UnwrappedCast<FixedI32<Frac>> for F128Bits

fn unwrapped_cast(self) -> FixedI32<Frac>

Casts the value.

impl<Frac: LeEqU64> UnwrappedCast<FixedI64<Frac>> for F128Bits

fn unwrapped_cast(self) -> FixedI64<Frac>

Casts the value.

impl<Frac: LeEqU8> UnwrappedCast<FixedI8<Frac>> for F128Bits

fn unwrapped_cast(self) -> FixedI8<Frac>

Casts the value.

impl<Frac: LeEqU128> UnwrappedCast<FixedU128<Frac>> for F128Bits

fn unwrapped_cast(self) -> FixedU128<Frac>

Casts the value.

impl<Frac: LeEqU16> UnwrappedCast<FixedU16<Frac>> for F128Bits

fn unwrapped_cast(self) -> FixedU16<Frac>

Casts the value.

impl<Frac: LeEqU32> UnwrappedCast<FixedU32<Frac>> for F128Bits

fn unwrapped_cast(self) -> FixedU32<Frac>

Casts the value.

impl<Frac: LeEqU64> UnwrappedCast<FixedU64<Frac>> for F128Bits

fn unwrapped_cast(self) -> FixedU64<Frac>

Casts the value.

impl<Frac: LeEqU8> UnwrappedCast<FixedU8<Frac>> for F128Bits

fn unwrapped_cast(self) -> FixedU8<Frac>

Casts the value.

impl<Frac: LeEqU128> WrappingCast<F128Bits> for FixedI128<Frac>

fn wrapping_cast(self) -> F128Bits

Casts the value.

impl<Frac: LeEqU16> WrappingCast<F128Bits> for FixedI16<Frac>

fn wrapping_cast(self) -> F128Bits

Casts the value.

impl<Frac: LeEqU32> WrappingCast<F128Bits> for FixedI32<Frac>

fn wrapping_cast(self) -> F128Bits

Casts the value.

impl<Frac: LeEqU64> WrappingCast<F128Bits> for FixedI64<Frac>

fn wrapping_cast(self) -> F128Bits

Casts the value.

impl<Frac: LeEqU8> WrappingCast<F128Bits> for FixedI8<Frac>

fn wrapping_cast(self) -> F128Bits

Casts the value.

impl<Frac: LeEqU128> WrappingCast<F128Bits> for FixedU128<Frac>

fn wrapping_cast(self) -> F128Bits

Casts the value.

impl<Frac: LeEqU16> WrappingCast<F128Bits> for FixedU16<Frac>

fn wrapping_cast(self) -> F128Bits

Casts the value.

impl<Frac: LeEqU32> WrappingCast<F128Bits> for FixedU32<Frac>

fn wrapping_cast(self) -> F128Bits

Casts the value.

impl<Frac: LeEqU64> WrappingCast<F128Bits> for FixedU64<Frac>

fn wrapping_cast(self) -> F128Bits

Casts the value.

impl<Frac: LeEqU8> WrappingCast<F128Bits> for FixedU8<Frac>

fn wrapping_cast(self) -> F128Bits

Casts the value.

impl<Frac: LeEqU128> WrappingCast<FixedI128<Frac>> for F128Bits

fn wrapping_cast(self) -> FixedI128<Frac>

Casts the value.

impl<Frac: LeEqU16> WrappingCast<FixedI16<Frac>> for F128Bits

fn wrapping_cast(self) -> FixedI16<Frac>

Casts the value.

impl<Frac: LeEqU32> WrappingCast<FixedI32<Frac>> for F128Bits

fn wrapping_cast(self) -> FixedI32<Frac>

Casts the value.

impl<Frac: LeEqU64> WrappingCast<FixedI64<Frac>> for F128Bits

fn wrapping_cast(self) -> FixedI64<Frac>

Casts the value.

impl<Frac: LeEqU8> WrappingCast<FixedI8<Frac>> for F128Bits

fn wrapping_cast(self) -> FixedI8<Frac>

Casts the value.

impl<Frac: LeEqU128> WrappingCast<FixedU128<Frac>> for F128Bits

fn wrapping_cast(self) -> FixedU128<Frac>

Casts the value.

impl<Frac: LeEqU16> WrappingCast<FixedU16<Frac>> for F128Bits

fn wrapping_cast(self) -> FixedU16<Frac>

Casts the value.

impl<Frac: LeEqU32> WrappingCast<FixedU32<Frac>> for F128Bits

fn wrapping_cast(self) -> FixedU32<Frac>

Casts the value.

impl<Frac: LeEqU64> WrappingCast<FixedU64<Frac>> for F128Bits

fn wrapping_cast(self) -> FixedU64<Frac>

Casts the value.

impl<Frac: LeEqU8> WrappingCast<FixedU8<Frac>> for F128Bits

fn wrapping_cast(self) -> FixedU8<Frac>

Casts the value.

impl Copy for F128Bits

impl Eq for F128Bits

impl StructuralEq for F128Bits

impl StructuralPartialEq for F128Bits