Enum FloatClass 

#[repr(u8)]
pub enum FloatClass {
    NegativeInfinity = 0,
    NegativeNormal = 1,
    NegativeSubnormal = 2,
    NegativeZero = 3,
    PositiveInfinity = 4,
    PositiveNormal = 5,
    PositiveSubnormal = 6,
    PositiveZero = 7,
    QuietNaN = 8,
    SignalingNaN = 9,
}

float classification

Variants

NegativeInfinity = 0

negative infinity

NegativeNormal = 1

negative normal

NegativeSubnormal = 2

negative subnormal

NegativeZero = 3

negative zero

PositiveInfinity = 4

positive infinity

PositiveNormal = 5

positive normal

PositiveSubnormal = 6

positive subnormal

PositiveZero = 7

positive zero

QuietNaN = 8

quiet NaN

SignalingNaN = 9

signaling NaN

Implementations

impl FloatClass

pub fn sign(self) -> Option<Sign>

get sign of non-NaN values

pub fn abs(self) -> Self

convert negative to positive

pub fn is_negative_infinity(self) -> bool

return true if self is NegativeInfinity

pub fn is_negative_normal(self) -> bool

return true if self is NegativeNormal

pub fn is_negative_subnormal(self) -> bool

return true if self is NegativeSubnormal

pub fn is_negative_zero(self) -> bool

return true if self is NegativeZero

pub fn is_positive_infinity(self) -> bool

return true if self is PositiveInfinity

pub fn is_positive_normal(self) -> bool

return true if self is PositiveNormal

pub fn is_positive_subnormal(self) -> bool

return true if self is PositiveSubnormal

pub fn is_positive_zero(self) -> bool

return true if self is PositiveZero

pub fn is_quiet_nan(self) -> bool

return true if self is QuietNaN

pub fn is_signaling_nan(self) -> bool

return true if self is SignalingNaN

pub fn is_infinity(self) -> bool

return true if self is infinity

pub fn is_normal(self) -> bool

return true if self is NegativeNormal or PositiveNormal

pub fn is_subnormal(self) -> bool

return true if self is subnormal

pub fn is_zero(self) -> bool

return true if self is zero

pub fn is_nan(self) -> bool

return true if self is NaN

pub fn is_finite(self) -> bool

return true if self is finite (not NaN or infinity)

pub fn is_subnormal_or_zero(self) -> bool

return true if self is subnormal or zero

Trait Implementations

impl Clone for FloatClass

fn clone(&self) -> FloatClass

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for FloatClass

impl Debug for FloatClass

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

Formats the value using the given formatter.

impl Eq for FloatClass

impl Hash for FloatClass

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 Neg for FloatClass

type Output = FloatClass

The resulting type after applying the - operator.

fn neg(self) -> Self

Performs the unary - operation.

impl PartialEq for FloatClass

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