Struct fixed::F128Bits[−][src]

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

Expand description

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

Trait Implementations

`impl<Frac: LeEqU8> Cast<F128Bits> for FixedI8<Frac>`[src]

`fn cast(self) -> F128Bits`[src]

Casts the value.

`impl<Frac: LeEqU16> Cast<F128Bits> for FixedI16<Frac>`[src]

`fn cast(self) -> F128Bits`[src]

Casts the value.

`impl<Frac: LeEqU32> Cast<F128Bits> for FixedI32<Frac>`[src]

`fn cast(self) -> F128Bits`[src]

Casts the value.

`impl<Frac: LeEqU64> Cast<F128Bits> for FixedI64<Frac>`[src]

`fn cast(self) -> F128Bits`[src]

Casts the value.

`impl<Frac: LeEqU128> Cast<F128Bits> for FixedI128<Frac>`[src]

`fn cast(self) -> F128Bits`[src]

Casts the value.

`impl<Frac: LeEqU8> Cast<F128Bits> for FixedU8<Frac>`[src]

`fn cast(self) -> F128Bits`[src]

Casts the value.

`impl<Frac: LeEqU16> Cast<F128Bits> for FixedU16<Frac>`[src]

`fn cast(self) -> F128Bits`[src]

Casts the value.

`impl<Frac: LeEqU32> Cast<F128Bits> for FixedU32<Frac>`[src]

`fn cast(self) -> F128Bits`[src]

Casts the value.

`impl<Frac: LeEqU64> Cast<F128Bits> for FixedU64<Frac>`[src]

`fn cast(self) -> F128Bits`[src]

Casts the value.

`impl<Frac: LeEqU128> Cast<F128Bits> for FixedU128<Frac>`[src]

`fn cast(self) -> F128Bits`[src]

Casts the value.

`impl<Frac: LeEqU128> Cast<FixedI128<Frac>> for F128Bits`[src]

`fn cast(self) -> FixedI128<Frac>`[src]

Casts the value.

`impl<Frac: LeEqU16> Cast<FixedI16<Frac>> for F128Bits`[src]

`fn cast(self) -> FixedI16<Frac>`[src]

Casts the value.

`impl<Frac: LeEqU32> Cast<FixedI32<Frac>> for F128Bits`[src]

`fn cast(self) -> FixedI32<Frac>`[src]

Casts the value.

`impl<Frac: LeEqU64> Cast<FixedI64<Frac>> for F128Bits`[src]

`fn cast(self) -> FixedI64<Frac>`[src]

Casts the value.

`impl<Frac: LeEqU8> Cast<FixedI8<Frac>> for F128Bits`[src]

`fn cast(self) -> FixedI8<Frac>`[src]

Casts the value.

`impl<Frac: LeEqU128> Cast<FixedU128<Frac>> for F128Bits`[src]

`fn cast(self) -> FixedU128<Frac>`[src]

Casts the value.

`impl<Frac: LeEqU16> Cast<FixedU16<Frac>> for F128Bits`[src]

`fn cast(self) -> FixedU16<Frac>`[src]

Casts the value.

`impl<Frac: LeEqU32> Cast<FixedU32<Frac>> for F128Bits`[src]

`fn cast(self) -> FixedU32<Frac>`[src]

Casts the value.

`impl<Frac: LeEqU64> Cast<FixedU64<Frac>> for F128Bits`[src]

`fn cast(self) -> FixedU64<Frac>`[src]

Casts the value.

`impl<Frac: LeEqU8> Cast<FixedU8<Frac>> for F128Bits`[src]

`fn cast(self) -> FixedU8<Frac>`[src]

Casts the value.

`impl<Frac: LeEqU8> CheckedCast<F128Bits> for FixedI8<Frac>`[src]

`fn checked_cast(self) -> Option<F128Bits>`[src]

Casts the value.

`impl<Frac: LeEqU16> CheckedCast<F128Bits> for FixedI16<Frac>`[src]

`fn checked_cast(self) -> Option<F128Bits>`[src]

Casts the value.

`impl<Frac: LeEqU32> CheckedCast<F128Bits> for FixedI32<Frac>`[src]

`fn checked_cast(self) -> Option<F128Bits>`[src]

Casts the value.

`impl<Frac: LeEqU64> CheckedCast<F128Bits> for FixedI64<Frac>`[src]

`fn checked_cast(self) -> Option<F128Bits>`[src]

Casts the value.

`impl<Frac: LeEqU128> CheckedCast<F128Bits> for FixedI128<Frac>`[src]

`fn checked_cast(self) -> Option<F128Bits>`[src]

Casts the value.

`impl<Frac: LeEqU8> CheckedCast<F128Bits> for FixedU8<Frac>`[src]

`fn checked_cast(self) -> Option<F128Bits>`[src]

Casts the value.

`impl<Frac: LeEqU16> CheckedCast<F128Bits> for FixedU16<Frac>`[src]

`fn checked_cast(self) -> Option<F128Bits>`[src]

Casts the value.

`impl<Frac: LeEqU32> CheckedCast<F128Bits> for FixedU32<Frac>`[src]

`fn checked_cast(self) -> Option<F128Bits>`[src]

Casts the value.

`impl<Frac: LeEqU64> CheckedCast<F128Bits> for FixedU64<Frac>`[src]

`fn checked_cast(self) -> Option<F128Bits>`[src]

Casts the value.

`impl<Frac: LeEqU128> CheckedCast<F128Bits> for FixedU128<Frac>`[src]

`fn checked_cast(self) -> Option<F128Bits>`[src]

Casts the value.

`impl<Frac: LeEqU128> CheckedCast<FixedI128<Frac>> for F128Bits`[src]

`fn checked_cast(self) -> Option<FixedI128<Frac>>`[src]

Casts the value.

`impl<Frac: LeEqU16> CheckedCast<FixedI16<Frac>> for F128Bits`[src]

`fn checked_cast(self) -> Option<FixedI16<Frac>>`[src]

Casts the value.

`impl<Frac: LeEqU32> CheckedCast<FixedI32<Frac>> for F128Bits`[src]

`fn checked_cast(self) -> Option<FixedI32<Frac>>`[src]

Casts the value.

`impl<Frac: LeEqU64> CheckedCast<FixedI64<Frac>> for F128Bits`[src]

`fn checked_cast(self) -> Option<FixedI64<Frac>>`[src]

Casts the value.

`impl<Frac: LeEqU8> CheckedCast<FixedI8<Frac>> for F128Bits`[src]

`fn checked_cast(self) -> Option<FixedI8<Frac>>`[src]

Casts the value.

`impl<Frac: LeEqU128> CheckedCast<FixedU128<Frac>> for F128Bits`[src]

`fn checked_cast(self) -> Option<FixedU128<Frac>>`[src]

Casts the value.

`impl<Frac: LeEqU16> CheckedCast<FixedU16<Frac>> for F128Bits`[src]

`fn checked_cast(self) -> Option<FixedU16<Frac>>`[src]

Casts the value.

`impl<Frac: LeEqU32> CheckedCast<FixedU32<Frac>> for F128Bits`[src]

`fn checked_cast(self) -> Option<FixedU32<Frac>>`[src]

Casts the value.

`impl<Frac: LeEqU64> CheckedCast<FixedU64<Frac>> for F128Bits`[src]

`fn checked_cast(self) -> Option<FixedU64<Frac>>`[src]

Casts the value.

`impl<Frac: LeEqU8> CheckedCast<FixedU8<Frac>> for F128Bits`[src]

`fn checked_cast(self) -> Option<FixedU8<Frac>>`[src]

Casts the value.

`impl Clone for F128Bits`[src]

`fn clone(&self) -> F128Bits`[src]

Returns a copy of the value. Read more

`fn clone_from(&mut self, source: &Self)`1.0.0 [src]

Performs copy-assignment from source. Read more

`impl Debug for F128Bits`[src]

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

Formats the value using the given formatter. Read more

`impl Default for F128Bits`[src]

`fn default() -> F128Bits`[src]

Returns the “default value” for a type. Read more

`impl<Frac: LeEqU16> From<FixedI16<Frac>> for F128Bits`[src]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

`fn hash<H: Hasher>(&self, state: &mut H)`[src]

Feeds this value into the given Hasher. Read more

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

Feeds a slice of this type into the given Hasher. Read more

`impl<Frac: LeEqU16> LosslessTryFrom<FixedI16<Frac>> for F128Bits`[src]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

`fn lossy_from(src: i128) -> F128Bits`[src]

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

`fn lossy_from(src: i16) -> F128Bits`[src]

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

`fn lossy_from(src: i32) -> F128Bits`[src]

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

`fn lossy_from(src: i64) -> F128Bits`[src]

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

`fn lossy_from(src: i8) -> F128Bits`[src]

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

`fn lossy_from(src: isize) -> F128Bits`[src]

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

`fn lossy_from(src: u128) -> F128Bits`[src]

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

`fn lossy_from(src: u16) -> F128Bits`[src]

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

`fn lossy_from(src: u32) -> F128Bits`[src]

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

`fn lossy_from(src: u64) -> F128Bits`[src]

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

`fn lossy_from(src: u8) -> F128Bits`[src]

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

`fn lossy_from(src: usize) -> F128Bits`[src]

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

`fn cmp(&self, other: &F128Bits) -> Ordering`[src]

This method returns an Ordering between self and other. Read more

`#[must_use] fn max(self, other: Self) -> Self`1.21.0 [src]

Compares and returns the maximum of two values. Read more

`#[must_use] fn min(self, other: Self) -> Self`1.21.0 [src]

Compares and returns the minimum of two values. Read more

`#[must_use] fn clamp(self, min: Self, max: Self) -> Self`1.50.0 [src]

Restrict a value to a certain interval. Read more

`impl<Frac: LeEqU8> OverflowingCast<F128Bits> for FixedI8<Frac>`[src]

`fn overflowing_cast(self) -> (F128Bits, bool)`[src]

Casts the value.

`impl<Frac: LeEqU16> OverflowingCast<F128Bits> for FixedI16<Frac>`[src]

`fn overflowing_cast(self) -> (F128Bits, bool)`[src]

Casts the value.

`impl<Frac: LeEqU32> OverflowingCast<F128Bits> for FixedI32<Frac>`[src]

`fn overflowing_cast(self) -> (F128Bits, bool)`[src]

Casts the value.

`impl<Frac: LeEqU64> OverflowingCast<F128Bits> for FixedI64<Frac>`[src]

`fn overflowing_cast(self) -> (F128Bits, bool)`[src]

Casts the value.

`impl<Frac: LeEqU128> OverflowingCast<F128Bits> for FixedI128<Frac>`[src]

`fn overflowing_cast(self) -> (F128Bits, bool)`[src]

Casts the value.

`impl<Frac: LeEqU8> OverflowingCast<F128Bits> for FixedU8<Frac>`[src]

`fn overflowing_cast(self) -> (F128Bits, bool)`[src]

Casts the value.

`impl<Frac: LeEqU16> OverflowingCast<F128Bits> for FixedU16<Frac>`[src]

`fn overflowing_cast(self) -> (F128Bits, bool)`[src]

Casts the value.

`impl<Frac: LeEqU32> OverflowingCast<F128Bits> for FixedU32<Frac>`[src]

`fn overflowing_cast(self) -> (F128Bits, bool)`[src]

Casts the value.

`impl<Frac: LeEqU64> OverflowingCast<F128Bits> for FixedU64<Frac>`[src]

`fn overflowing_cast(self) -> (F128Bits, bool)`[src]

Casts the value.

`impl<Frac: LeEqU128> OverflowingCast<F128Bits> for FixedU128<Frac>`[src]

`fn overflowing_cast(self) -> (F128Bits, bool)`[src]

Casts the value.

`impl<Frac: LeEqU128> OverflowingCast<FixedI128<Frac>> for F128Bits`[src]

`fn overflowing_cast(self) -> (FixedI128<Frac>, bool)`[src]

Casts the value.

`impl<Frac: LeEqU16> OverflowingCast<FixedI16<Frac>> for F128Bits`[src]

`fn overflowing_cast(self) -> (FixedI16<Frac>, bool)`[src]

Casts the value.

`impl<Frac: LeEqU32> OverflowingCast<FixedI32<Frac>> for F128Bits`[src]

`fn overflowing_cast(self) -> (FixedI32<Frac>, bool)`[src]

Casts the value.

`impl<Frac: LeEqU64> OverflowingCast<FixedI64<Frac>> for F128Bits`[src]

`fn overflowing_cast(self) -> (FixedI64<Frac>, bool)`[src]

Casts the value.

`impl<Frac: LeEqU8> OverflowingCast<FixedI8<Frac>> for F128Bits`[src]

`fn overflowing_cast(self) -> (FixedI8<Frac>, bool)`[src]

Casts the value.

`impl<Frac: LeEqU128> OverflowingCast<FixedU128<Frac>> for F128Bits`[src]

`fn overflowing_cast(self) -> (FixedU128<Frac>, bool)`[src]

Casts the value.

`impl<Frac: LeEqU16> OverflowingCast<FixedU16<Frac>> for F128Bits`[src]

`fn overflowing_cast(self) -> (FixedU16<Frac>, bool)`[src]

Casts the value.

`impl<Frac: LeEqU32> OverflowingCast<FixedU32<Frac>> for F128Bits`[src]

`fn overflowing_cast(self) -> (FixedU32<Frac>, bool)`[src]

Casts the value.

`impl<Frac: LeEqU64> OverflowingCast<FixedU64<Frac>> for F128Bits`[src]

`fn overflowing_cast(self) -> (FixedU64<Frac>, bool)`[src]

Casts the value.

`impl<Frac: LeEqU8> OverflowingCast<FixedU8<Frac>> for F128Bits`[src]

`fn overflowing_cast(self) -> (FixedU8<Frac>, bool)`[src]

Casts the value.

`impl<Frac: LeEqU8> PartialEq<F128Bits> for FixedI8<Frac>`[src]

`fn eq(&self, rhs: &F128Bits) -> bool`[src]

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

`#[must_use] fn ne(&self, other: &Rhs) -> bool`1.0.0 [src]

This method tests for !=.

`impl<Frac: LeEqU16> PartialEq<F128Bits> for FixedI16<Frac>`[src]

`fn eq(&self, rhs: &F128Bits) -> bool`[src]

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

`#[must_use] fn ne(&self, other: &Rhs) -> bool`1.0.0 [src]

This method tests for !=.

`impl PartialEq<F128Bits> for F128Bits`[src]

`fn eq(&self, other: &F128Bits) -> bool`[src]

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

`fn ne(&self, other: &F128Bits) -> bool`[src]

This method tests for !=.

`impl<Frac: LeEqU32> PartialEq<F128Bits> for FixedI32<Frac>`[src]

`fn eq(&self, rhs: &F128Bits) -> bool`[src]

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

`#[must_use] fn ne(&self, other: &Rhs) -> bool`1.0.0 [src]

This method tests for !=.

`impl<Frac: LeEqU64> PartialEq<F128Bits> for FixedI64<Frac>`[src]

`fn eq(&self, rhs: &F128Bits) -> bool`[src]

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

`#[must_use] fn ne(&self, other: &Rhs) -> bool`1.0.0 [src]

This method tests for !=.

`impl<Frac: LeEqU128> PartialEq<F128Bits> for FixedI128<Frac>`[src]

`fn eq(&self, rhs: &F128Bits) -> bool`[src]

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

`#[must_use] fn ne(&self, other: &Rhs) -> bool`1.0.0 [src]

This method tests for !=.

`impl<Frac: LeEqU8> PartialEq<F128Bits> for FixedU8<Frac>`[src]

`fn eq(&self, rhs: &F128Bits) -> bool`[src]

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

`#[must_use] fn ne(&self, other: &Rhs) -> bool`1.0.0 [src]

This method tests for !=.

`impl<Frac: LeEqU16> PartialEq<F128Bits> for FixedU16<Frac>`[src]

`fn eq(&self, rhs: &F128Bits) -> bool`[src]

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

`#[must_use] fn ne(&self, other: &Rhs) -> bool`1.0.0 [src]

This method tests for !=.

`impl<Frac: LeEqU32> PartialEq<F128Bits> for FixedU32<Frac>`[src]

`fn eq(&self, rhs: &F128Bits) -> bool`[src]

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

`#[must_use] fn ne(&self, other: &Rhs) -> bool`1.0.0 [src]

This method tests for !=.

`impl<Frac: LeEqU64> PartialEq<F128Bits> for FixedU64<Frac>`[src]

`fn eq(&self, rhs: &F128Bits) -> bool`[src]

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

`#[must_use] fn ne(&self, other: &Rhs) -> bool`1.0.0 [src]

This method tests for !=.

`impl<Frac: LeEqU128> PartialEq<F128Bits> for FixedU128<Frac>`[src]

`fn eq(&self, rhs: &F128Bits) -> bool`[src]

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

`#[must_use] fn ne(&self, other: &Rhs) -> bool`1.0.0 [src]

This method tests for !=.

`impl<Frac: LeEqU128> PartialEq<FixedI128<Frac>> for F128Bits`[src]

`fn eq(&self, rhs: &FixedI128<Frac>) -> bool`[src]

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

`#[must_use] fn ne(&self, other: &Rhs) -> bool`1.0.0 [src]

This method tests for !=.

`impl<Frac: LeEqU16> PartialEq<FixedI16<Frac>> for F128Bits`[src]

`fn eq(&self, rhs: &FixedI16<Frac>) -> bool`[src]

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

`#[must_use] fn ne(&self, other: &Rhs) -> bool`1.0.0 [src]

This method tests for !=.

`impl<Frac: LeEqU32> PartialEq<FixedI32<Frac>> for F128Bits`[src]

`fn eq(&self, rhs: &FixedI32<Frac>) -> bool`[src]

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

`#[must_use] fn ne(&self, other: &Rhs) -> bool`1.0.0 [src]

This method tests for !=.

`impl<Frac: LeEqU64> PartialEq<FixedI64<Frac>> for F128Bits`[src]

`fn eq(&self, rhs: &FixedI64<Frac>) -> bool`[src]

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

`#[must_use] fn ne(&self, other: &Rhs) -> bool`1.0.0 [src]

This method tests for !=.

`impl<Frac: LeEqU8> PartialEq<FixedI8<Frac>> for F128Bits`[src]

`fn eq(&self, rhs: &FixedI8<Frac>) -> bool`[src]

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

`#[must_use] fn ne(&self, other: &Rhs) -> bool`1.0.0 [src]

This method tests for !=.

`impl<Frac: LeEqU128> PartialEq<FixedU128<Frac>> for F128Bits`[src]

`fn eq(&self, rhs: &FixedU128<Frac>) -> bool`[src]

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

`#[must_use] fn ne(&self, other: &Rhs) -> bool`1.0.0 [src]

This method tests for !=.

`impl<Frac: LeEqU16> PartialEq<FixedU16<Frac>> for F128Bits`[src]

`fn eq(&self, rhs: &FixedU16<Frac>) -> bool`[src]

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

`#[must_use] fn ne(&self, other: &Rhs) -> bool`1.0.0 [src]

This method tests for !=.

`impl<Frac: LeEqU32> PartialEq<FixedU32<Frac>> for F128Bits`[src]

`fn eq(&self, rhs: &FixedU32<Frac>) -> bool`[src]

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

`#[must_use] fn ne(&self, other: &Rhs) -> bool`1.0.0 [src]

This method tests for !=.

`impl<Frac: LeEqU64> PartialEq<FixedU64<Frac>> for F128Bits`[src]

`fn eq(&self, rhs: &FixedU64<Frac>) -> bool`[src]

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

`#[must_use] fn ne(&self, other: &Rhs) -> bool`1.0.0 [src]

This method tests for !=.

`impl<Frac: LeEqU8> PartialEq<FixedU8<Frac>> for F128Bits`[src]

`fn eq(&self, rhs: &FixedU8<Frac>) -> bool`[src]

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

`#[must_use] fn ne(&self, other: &Rhs) -> bool`1.0.0 [src]

This method tests for !=.

`impl<Frac: LeEqU8> PartialOrd<F128Bits> for FixedI8<Frac>`[src]

`fn partial_cmp(&self, rhs: &F128Bits) -> Option<Ordering>`[src]

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

`fn lt(&self, rhs: &F128Bits) -> bool`[src]

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

`fn le(&self, rhs: &F128Bits) -> bool`[src]

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

`fn gt(&self, rhs: &F128Bits) -> bool`[src]

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

`fn ge(&self, rhs: &F128Bits) -> bool`[src]

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

`impl<Frac: LeEqU16> PartialOrd<F128Bits> for FixedI16<Frac>`[src]

`fn partial_cmp(&self, rhs: &F128Bits) -> Option<Ordering>`[src]

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

`fn lt(&self, rhs: &F128Bits) -> bool`[src]

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

`fn le(&self, rhs: &F128Bits) -> bool`[src]

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

`fn gt(&self, rhs: &F128Bits) -> bool`[src]

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

`fn ge(&self, rhs: &F128Bits) -> bool`[src]

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

`impl PartialOrd<F128Bits> for F128Bits`[src]

`fn partial_cmp(&self, other: &F128Bits) -> Option<Ordering>`[src]

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

`#[must_use] fn lt(&self, other: &Rhs) -> bool`1.0.0 [src]

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

`#[must_use] fn le(&self, other: &Rhs) -> bool`1.0.0 [src]

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

`#[must_use] fn gt(&self, other: &Rhs) -> bool`1.0.0 [src]

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

`#[must_use] fn ge(&self, other: &Rhs) -> bool`1.0.0 [src]

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

`impl<Frac: LeEqU32> PartialOrd<F128Bits> for FixedI32<Frac>`[src]

`fn partial_cmp(&self, rhs: &F128Bits) -> Option<Ordering>`[src]

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

`fn lt(&self, rhs: &F128Bits) -> bool`[src]

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

`fn le(&self, rhs: &F128Bits) -> bool`[src]

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

`fn gt(&self, rhs: &F128Bits) -> bool`[src]

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

`fn ge(&self, rhs: &F128Bits) -> bool`[src]

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

`impl<Frac: LeEqU64> PartialOrd<F128Bits> for FixedI64<Frac>`[src]

`fn partial_cmp(&self, rhs: &F128Bits) -> Option<Ordering>`[src]

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

`fn lt(&self, rhs: &F128Bits) -> bool`[src]

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

`fn le(&self, rhs: &F128Bits) -> bool`[src]

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

`fn gt(&self, rhs: &F128Bits) -> bool`[src]

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

`fn ge(&self, rhs: &F128Bits) -> bool`[src]

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

`impl<Frac: LeEqU128> PartialOrd<F128Bits> for FixedI128<Frac>`[src]

`fn partial_cmp(&self, rhs: &F128Bits) -> Option<Ordering>`[src]

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

`fn lt(&self, rhs: &F128Bits) -> bool`[src]

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

`fn le(&self, rhs: &F128Bits) -> bool`[src]

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

`fn gt(&self, rhs: &F128Bits) -> bool`[src]

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

`fn ge(&self, rhs: &F128Bits) -> bool`[src]

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

`impl<Frac: LeEqU8> PartialOrd<F128Bits> for FixedU8<Frac>`[src]

`fn partial_cmp(&self, rhs: &F128Bits) -> Option<Ordering>`[src]

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

`fn lt(&self, rhs: &F128Bits) -> bool`[src]

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

`fn le(&self, rhs: &F128Bits) -> bool`[src]

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

`fn gt(&self, rhs: &F128Bits) -> bool`[src]

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

`fn ge(&self, rhs: &F128Bits) -> bool`[src]

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

`impl<Frac: LeEqU16> PartialOrd<F128Bits> for FixedU16<Frac>`[src]

`fn partial_cmp(&self, rhs: &F128Bits) -> Option<Ordering>`[src]

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

`fn lt(&self, rhs: &F128Bits) -> bool`[src]

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

`fn le(&self, rhs: &F128Bits) -> bool`[src]

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

`fn gt(&self, rhs: &F128Bits) -> bool`[src]

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

`fn ge(&self, rhs: &F128Bits) -> bool`[src]

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

`impl<Frac: LeEqU32> PartialOrd<F128Bits> for FixedU32<Frac>`[src]

`fn partial_cmp(&self, rhs: &F128Bits) -> Option<Ordering>`[src]

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

`fn lt(&self, rhs: &F128Bits) -> bool`[src]

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

`fn le(&self, rhs: &F128Bits) -> bool`[src]

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

`fn gt(&self, rhs: &F128Bits) -> bool`[src]

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

`fn ge(&self, rhs: &F128Bits) -> bool`[src]

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

`impl<Frac: LeEqU64> PartialOrd<F128Bits> for FixedU64<Frac>`[src]

`fn partial_cmp(&self, rhs: &F128Bits) -> Option<Ordering>`[src]

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

`fn lt(&self, rhs: &F128Bits) -> bool`[src]

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

`fn le(&self, rhs: &F128Bits) -> bool`[src]

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

`fn gt(&self, rhs: &F128Bits) -> bool`[src]

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

`fn ge(&self, rhs: &F128Bits) -> bool`[src]

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

`impl<Frac: LeEqU128> PartialOrd<F128Bits> for FixedU128<Frac>`[src]

`fn partial_cmp(&self, rhs: &F128Bits) -> Option<Ordering>`[src]

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

`fn lt(&self, rhs: &F128Bits) -> bool`[src]

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

`fn le(&self, rhs: &F128Bits) -> bool`[src]

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

`fn gt(&self, rhs: &F128Bits) -> bool`[src]

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

`fn ge(&self, rhs: &F128Bits) -> bool`[src]

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

`impl<Frac: LeEqU128> PartialOrd<FixedI128<Frac>> for F128Bits`[src]

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

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

`fn lt(&self, rhs: &FixedI128<Frac>) -> bool`[src]

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

`fn le(&self, rhs: &FixedI128<Frac>) -> bool`[src]

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

`fn gt(&self, rhs: &FixedI128<Frac>) -> bool`[src]

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

`fn ge(&self, rhs: &FixedI128<Frac>) -> bool`[src]

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

`impl<Frac: LeEqU16> PartialOrd<FixedI16<Frac>> for F128Bits`[src]

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

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

`fn lt(&self, rhs: &FixedI16<Frac>) -> bool`[src]

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

`fn le(&self, rhs: &FixedI16<Frac>) -> bool`[src]

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

`fn gt(&self, rhs: &FixedI16<Frac>) -> bool`[src]

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

`fn ge(&self, rhs: &FixedI16<Frac>) -> bool`[src]

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

`impl<Frac: LeEqU32> PartialOrd<FixedI32<Frac>> for F128Bits`[src]

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

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

`fn lt(&self, rhs: &FixedI32<Frac>) -> bool`[src]

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

`fn le(&self, rhs: &FixedI32<Frac>) -> bool`[src]

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

`fn gt(&self, rhs: &FixedI32<Frac>) -> bool`[src]

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

`fn ge(&self, rhs: &FixedI32<Frac>) -> bool`[src]

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

`impl<Frac: LeEqU64> PartialOrd<FixedI64<Frac>> for F128Bits`[src]

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

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

`fn lt(&self, rhs: &FixedI64<Frac>) -> bool`[src]

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

`fn le(&self, rhs: &FixedI64<Frac>) -> bool`[src]

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

`fn gt(&self, rhs: &FixedI64<Frac>) -> bool`[src]

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

`fn ge(&self, rhs: &FixedI64<Frac>) -> bool`[src]

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

`impl<Frac: LeEqU8> PartialOrd<FixedI8<Frac>> for F128Bits`[src]

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

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

`fn lt(&self, rhs: &FixedI8<Frac>) -> bool`[src]

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

`fn le(&self, rhs: &FixedI8<Frac>) -> bool`[src]

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

`fn gt(&self, rhs: &FixedI8<Frac>) -> bool`[src]

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

`fn ge(&self, rhs: &FixedI8<Frac>) -> bool`[src]

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

`impl<Frac: LeEqU128> PartialOrd<FixedU128<Frac>> for F128Bits`[src]

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

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

`fn lt(&self, rhs: &FixedU128<Frac>) -> bool`[src]

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

`fn le(&self, rhs: &FixedU128<Frac>) -> bool`[src]

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

`fn gt(&self, rhs: &FixedU128<Frac>) -> bool`[src]

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

`fn ge(&self, rhs: &FixedU128<Frac>) -> bool`[src]

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

`impl<Frac: LeEqU16> PartialOrd<FixedU16<Frac>> for F128Bits`[src]

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

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

`fn lt(&self, rhs: &FixedU16<Frac>) -> bool`[src]

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

`fn le(&self, rhs: &FixedU16<Frac>) -> bool`[src]

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

`fn gt(&self, rhs: &FixedU16<Frac>) -> bool`[src]

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

`fn ge(&self, rhs: &FixedU16<Frac>) -> bool`[src]

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

`impl<Frac: LeEqU32> PartialOrd<FixedU32<Frac>> for F128Bits`[src]

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

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

`fn lt(&self, rhs: &FixedU32<Frac>) -> bool`[src]

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

`fn le(&self, rhs: &FixedU32<Frac>) -> bool`[src]

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

`fn gt(&self, rhs: &FixedU32<Frac>) -> bool`[src]

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

`fn ge(&self, rhs: &FixedU32<Frac>) -> bool`[src]

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

`impl<Frac: LeEqU64> PartialOrd<FixedU64<Frac>> for F128Bits`[src]

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

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

`fn lt(&self, rhs: &FixedU64<Frac>) -> bool`[src]

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

`fn le(&self, rhs: &FixedU64<Frac>) -> bool`[src]

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

`fn gt(&self, rhs: &FixedU64<Frac>) -> bool`[src]

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

`fn ge(&self, rhs: &FixedU64<Frac>) -> bool`[src]

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

`impl<Frac: LeEqU8> PartialOrd<FixedU8<Frac>> for F128Bits`[src]

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

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

`fn lt(&self, rhs: &FixedU8<Frac>) -> bool`[src]

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

`fn le(&self, rhs: &FixedU8<Frac>) -> bool`[src]

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

`fn gt(&self, rhs: &FixedU8<Frac>) -> bool`[src]

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

`fn ge(&self, rhs: &FixedU8<Frac>) -> bool`[src]

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

`impl<Frac: LeEqU8> SaturatingCast<F128Bits> for FixedI8<Frac>`[src]

`fn saturating_cast(self) -> F128Bits`[src]

Casts the value.

`impl<Frac: LeEqU16> SaturatingCast<F128Bits> for FixedI16<Frac>`[src]

`fn saturating_cast(self) -> F128Bits`[src]

Casts the value.

`impl<Frac: LeEqU32> SaturatingCast<F128Bits> for FixedI32<Frac>`[src]

`fn saturating_cast(self) -> F128Bits`[src]

Casts the value.

`impl<Frac: LeEqU64> SaturatingCast<F128Bits> for FixedI64<Frac>`[src]

`fn saturating_cast(self) -> F128Bits`[src]

Casts the value.

`impl<Frac: LeEqU128> SaturatingCast<F128Bits> for FixedI128<Frac>`[src]

`fn saturating_cast(self) -> F128Bits`[src]

Casts the value.

`impl<Frac: LeEqU8> SaturatingCast<F128Bits> for FixedU8<Frac>`[src]

`fn saturating_cast(self) -> F128Bits`[src]

Casts the value.

`impl<Frac: LeEqU16> SaturatingCast<F128Bits> for FixedU16<Frac>`[src]

`fn saturating_cast(self) -> F128Bits`[src]

Casts the value.

`impl<Frac: LeEqU32> SaturatingCast<F128Bits> for FixedU32<Frac>`[src]

`fn saturating_cast(self) -> F128Bits`[src]

Casts the value.

`impl<Frac: LeEqU64> SaturatingCast<F128Bits> for FixedU64<Frac>`[src]

`fn saturating_cast(self) -> F128Bits`[src]

Casts the value.

`impl<Frac: LeEqU128> SaturatingCast<F128Bits> for FixedU128<Frac>`[src]

`fn saturating_cast(self) -> F128Bits`[src]

Casts the value.

`impl<Frac: LeEqU128> SaturatingCast<FixedI128<Frac>> for F128Bits`[src]

`fn saturating_cast(self) -> FixedI128<Frac>`[src]

Casts the value.

`impl<Frac: LeEqU16> SaturatingCast<FixedI16<Frac>> for F128Bits`[src]

`fn saturating_cast(self) -> FixedI16<Frac>`[src]

Casts the value.

`impl<Frac: LeEqU32> SaturatingCast<FixedI32<Frac>> for F128Bits`[src]

`fn saturating_cast(self) -> FixedI32<Frac>`[src]

Casts the value.

`impl<Frac: LeEqU64> SaturatingCast<FixedI64<Frac>> for F128Bits`[src]

`fn saturating_cast(self) -> FixedI64<Frac>`[src]

Casts the value.

`impl<Frac: LeEqU8> SaturatingCast<FixedI8<Frac>> for F128Bits`[src]

`fn saturating_cast(self) -> FixedI8<Frac>`[src]

Casts the value.

`impl<Frac: LeEqU128> SaturatingCast<FixedU128<Frac>> for F128Bits`[src]

`fn saturating_cast(self) -> FixedU128<Frac>`[src]

Casts the value.

`impl<Frac: LeEqU16> SaturatingCast<FixedU16<Frac>> for F128Bits`[src]

`fn saturating_cast(self) -> FixedU16<Frac>`[src]

Casts the value.

`impl<Frac: LeEqU32> SaturatingCast<FixedU32<Frac>> for F128Bits`[src]

`fn saturating_cast(self) -> FixedU32<Frac>`[src]

Casts the value.

`impl<Frac: LeEqU64> SaturatingCast<FixedU64<Frac>> for F128Bits`[src]

`fn saturating_cast(self) -> FixedU64<Frac>`[src]

Casts the value.

`impl<Frac: LeEqU8> SaturatingCast<FixedU8<Frac>> for F128Bits`[src]

`fn saturating_cast(self) -> FixedU8<Frac>`[src]

Casts the value.

`impl ToFixed for F128Bits`[src]

`fn to_fixed<F: Fixed>(self) -> F`[src]

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.