Enum DecomposeResult 

pub enum DecomposeResult {
    Normal {
        is_neg: bool,
        exp: i32,
        mantissa: u128,
    },
    Zero,
    NegZero,
    Infinity,
    NegInfinity,
    NotANumber,
}

It’s literally DecomposeResult, not a number. If it were a number, Zero and NegZero has to be equal. But they’re not equal because they’re results of decompositions of different bit patterns. Also, that’s why it implements Eq but not Ord.

Variants

Normal

n = (-1)^is_neg * 2^exp * mantissa / 2^127

always 2^127 <= mantissa < 2^128

Fields

is_neg: bool

exp: i32

mantissa: u128

Zero

NegZero

Infinity

NegInfinity

NotANumber

It treats NaNs equal, and that’s intentional. IEEE754 treats NaNs unequal because NaN is an indicator of an invalid operation. Here, DecomposeResult::NotANumber is a result of a successful n.decompose(), so it has to implement Eq.

Trait Implementations

impl Clone for DecomposeResult

fn clone(&self) -> DecomposeResult

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for DecomposeResult

impl Debug for DecomposeResult

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

Formats the value using the given formatter.

impl Display for DecomposeResult

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

Formats the value using the given formatter.

impl Eq for DecomposeResult

impl From<DecomposeResult> for f32

It implements From<DecomposeResult>, not TryFrom<DecomposeResult>. If DecomposeResult is too big, it returns INFINITY or NEG_INFINITY instead of throwing an overflow error. If it’s too small, it returns 0.0 or -0.0 instead of throwing an underflow error.

fn from(r: DecomposeResult) -> f32

Converts to this type from the input type.

impl From<DecomposeResult> for f64

It implements From<DecomposeResult>, not TryFrom<DecomposeResult>. If DecomposeResult is too big, it returns INFINITY or NEG_INFINITY instead of throwing an overflow error. If it’s too small, it returns 0.0 or -0.0 instead of throwing an underflow error.

fn from(r: DecomposeResult) -> f64

Converts to this type from the input type.

impl Hash for DecomposeResult

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 PartialEq for DecomposeResult

fn eq(&self, other: &DecomposeResult) -> 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 StructuralPartialEq for DecomposeResult