Struct F64 

#[repr(transparent)]
pub struct F64 {
    pub bits: u64,
}

A newtype containing the raw bits of an IEEE 754 binary64 floating point number.

Values of this type are hashable and have a well-defined total order: the one given by Self::total_cmp. As a consequence, +0.0 is not equal to -0.0, and NaN compares equal to NaN if both NaN values have exactly the same bit pattern.

Fields

bits: u64

The raw bits representing this float value.

Implementations

impl F64

pub const fn from_bits(bits: u64) -> Self

Constructs a wrapped float from the raw float bits.

pub const fn to_bits(&self) -> u64

Returns the raw float bits.

impl F64

pub const fn from_float(float: f64) -> Self

Constructs a wrapped float from a Rust float.

pub const fn to_float(&self) -> f64

Returns the Rust float which this wrapped float represents.

impl F64

pub const BITS: usize = 64usize

Number of total bits in the representation.

pub const EXP_BITS: usize = 11usize

Number of bits in the exponent representation.

pub const MANTISSA_BITS: usize = 52usize

Number of bits in the mantissa representation.

pub const MANTISSA_DIGITS: usize = 53usize

Number of significant digits in base 2.

Note that the size of the mantissa in the bitwise representation is one smaller than this, since the leading 1 is not stored explicitly.

pub const ZERO: Self

Positive zero (+0.0).

pub const ONE: Self

Positive one (+1.0).

pub const INFINITY: Self

Positive infinity (+∞).

pub const SNAN: Self

Not a Number (NaN) with sign bit 0, is_quiet bit 0, and arbitrary payload.

pub const QNAN: Self

Not a Number (NaN) with sign bit 0, is_quiet bit 1, and arbitrary payload.

pub const NEG_ZERO: Self

Negative zero (−0.0).

pub const NEG_ONE: Self

Negative one (−1.0).

pub const NEG_INFINITY: Self

Negative infinity (−∞).

pub const NEG_SNAN: Self

Not a Number (NaN) with sign bit 1, is_quiet bit 0, and arbitrary payload.

pub const NEG_QNAN: Self

Not a Number (NaN) with sign bit 1, is_quiet bit 1, and arbitrary payload.

pub const MAX: Self

The positive normal value with the greatest possible absolute magnitude.

pub const MIN: Self

The negative normal value with the greatest possible absolute magnitude.

pub const MIN_POSITIVE: Self

The positive normal value with the least possible absolute magnitude.

pub const MAX_NEGATIVE: Self

The negative normal value with the least possible absolute magnitude.

pub const fn is_sign_positive(&self) -> bool

Returns true if self has a positive sign, including +0.0, +∞, and NaN with positive sign bit.

pub const fn is_sign_negative(&self) -> bool

Returns true if self has a negative sign, including -0.0, -∞, and NaN with negative sign bit.

pub const fn classify(&self) -> FpCategory

Returns the floating point category of the number.

pub const fn is_zero(&self) -> bool

Returns true if the number is +0.0 or -0.0.

pub const fn is_subnormal(&self) -> bool

Returns true if the number is subnormal.

pub const fn is_normal(&self) -> bool

Returns true if the number is neither zero, infinite, subnormal, or NaN.

pub const fn is_infinite(&self) -> bool

Returns true if the number is subnormal.

pub const fn is_nan(&self) -> bool

Returns true if this value is NaN.

pub const fn is_finite(&self) -> bool

Returns true if this number is neither infinite nor NaN.

pub const fn abs(&self) -> Self

Computes the absolute value of self.

The result is always exact. The result will always test true with Self::is_sign_positive.

pub const fn neg(&self) -> Self

Computes the negation of self.

The result is always exact.

pub const fn signum(&self) -> Self

Returns a number that represents the sign of self.

• Self::ONE if the number is positive, including +0.0 or +∞
• Self::NEG_ONE if the number is negative, including -0.0 or -∞
• self if the number is NaN

pub const fn copysign(&self, sign: Self) -> Self

Returns a number composed of the magnitude of self and the sign of sign.

pub const fn total_cmp(&self, rhs: Self) -> Ordering

Returns the ordering between self and rhs.

Unlike the standard partial comparison between floating point numbers, this comparison always produces an ordering in accordance to the totalOrder predicate as defined in the IEEE 754 (2008 revision) floating point standard. The values are ordered in the following sequence:

• negative quiet NaN
• negative signaling NaN
• negative infinity
• negative numbers
• negative subnormal numbers
• negative zero
• positive zero
• positive subnormal numbers
• positive numbers
• positive infinity
• positive signaling NaN
• positive quiet NaN

pub const fn clamp(&self, min: Self, max: Self) -> Self

Restrict a value to a certain interval unless it is NaN.

Returns max if self is greater than max, and min if self is less than min. Otherwise this returns self.

Note that this function returns NaN if the initial value was NaN as well.

Panics

Panics if min > max, min is NaN, or max is NaN.

Trait Implementations

impl Clone for F64

fn clone(&self) -> F64

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for F64

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

Formats the value using the given formatter.

impl Default for F64

fn default() -> Self

Returns Self::ZERO.

impl Display for F64

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

Formats the value using the given formatter.

impl From<F64> for f64

fn from(val: F64) -> f64

Converts to this type from the input type.

impl From<f64> for F64

fn from(float: f64) -> Self

Converts to this type from the input type.

impl FromStr for F64

type Err = ParseFloatError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Hash for F64

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 Ord for F64

fn cmp(&self, rhs: &Self) -> Ordering

This method returns an Ordering between self and other.

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

where Self: Sized,

Compares and returns the maximum of two values.

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

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for F64

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl PartialOrd for F64

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

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

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

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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

impl Copy for F64

impl Eq for F64

impl StructuralPartialEq for F64