Trait Float 

pub trait Float: Number + Neg<Output = Self> {
    type Unsigned: UnsignedInteger;

    const ZERO: Self;
    const ONE: Self;
    const TWO: Self;
    const MAX: Self;
    const MIN: Self;
    const INFINITY: Self;
    const NEG_INFINITY: Self;
    const NAN: Self;
    const BITS: usize;
    const SIGN_MASK: Self::Unsigned;
    const EXPONENT_MASK: Self::Unsigned;
    const HIDDEN_BIT_MASK: Self::Unsigned;
    const MANTISSA_MASK: Self::Unsigned;
    const CARRY_MASK: Self::Unsigned;
    const INFINITY_BITS: Self::Unsigned;
    const NEGATIVE_INFINITY_BITS: Self::Unsigned;
    const EXPONENT_SIZE: i32;
    const MANTISSA_SIZE: i32;
    const EXPONENT_BIAS: i32;
    const DENORMAL_EXPONENT: i32;
    const MAX_EXPONENT: i32;

    // Required methods
    fn to_bits(self) -> Self::Unsigned;
    fn from_bits(u: Self::Unsigned) -> Self;
    fn ln(self) -> Self;
    fn floor(self) -> Self;
    fn is_sign_positive(self) -> bool;
    fn is_sign_negative(self) -> bool;

    // Provided methods
    fn is_denormal(self) -> bool { ... }
    fn is_special(self) -> bool { ... }
    fn is_nan(self) -> bool { ... }
    fn is_inf(self) -> bool { ... }
    fn is_odd(self) -> bool { ... }
    fn is_even(self) -> bool { ... }
    fn needs_negative_sign(self) -> bool { ... }
    fn exponent(self) -> i32 { ... }
    fn mantissa(self) -> Self::Unsigned { ... }
    fn next(self) -> Self { ... }
    fn next_positive(self) -> Self { ... }
    fn prev(self) -> Self { ... }
    fn prev_positive(self) -> Self { ... }
    fn round_positive_even(self) -> Self { ... }
    fn max_finite(self, f: Self) -> Self { ... }
    fn min_finite(self, f: Self) -> Self { ... }
}

Float information for native float types.

Required Associated Constants

const ZERO: Self

const ONE: Self

const TWO: Self

const MAX: Self

const MIN: Self

const INFINITY: Self

const NEG_INFINITY: Self

const NAN: Self

const BITS: usize

const SIGN_MASK: Self::Unsigned

Bitmask for the sign bit.

const EXPONENT_MASK: Self::Unsigned

Bitmask for the exponent, including the hidden bit.

const HIDDEN_BIT_MASK: Self::Unsigned

Bitmask for the hidden bit in exponent, which is an implicit 1 in the fraction.

const MANTISSA_MASK: Self::Unsigned

Bitmask for the mantissa (fraction), excluding the hidden bit.

const CARRY_MASK: Self::Unsigned

Mask to determine if a full-carry occurred (1 in bit above hidden bit).

const INFINITY_BITS: Self::Unsigned

Positive infinity as bits.

const NEGATIVE_INFINITY_BITS: Self::Unsigned

Positive infinity as bits.

const EXPONENT_SIZE: i32

Size of the exponent.

const MANTISSA_SIZE: i32

Size of the significand (mantissa) without hidden bit.

const EXPONENT_BIAS: i32

Bias of the exponent.

const DENORMAL_EXPONENT: i32

Exponent portion of a denormal float.

const MAX_EXPONENT: i32

Maximum exponent value in float.

Required Associated Types

type Unsigned: UnsignedInteger

Unsigned type of the same size.

Required Methods

fn to_bits(self) -> Self::Unsigned

fn from_bits(u: Self::Unsigned) -> Self

fn ln(self) -> Self

fn floor(self) -> Self

fn is_sign_positive(self) -> bool

fn is_sign_negative(self) -> bool

Provided Methods

fn is_denormal(self) -> bool

Returns true if the float is a denormal.

fn is_special(self) -> bool

Returns true if the float is a NaN or Infinite.

fn is_nan(self) -> bool

Returns true if the float is NaN.

fn is_inf(self) -> bool

Returns true if the float is infinite.

fn is_odd(self) -> bool

Returns true if the float’s least-significant mantissa bit is odd.

fn is_even(self) -> bool

Returns true if the float’s least-significant mantissa bit is even.

fn needs_negative_sign(self) -> bool

Returns true if the float needs a negative sign when serializing it.

This is true if it’s -0.0 or it’s below 0 and not NaN. But inf values need the sign.

fn exponent(self) -> i32

Get exponent component from the float.

fn mantissa(self) -> Self::Unsigned

Get mantissa (significand) component from float.

fn next(self) -> Self

Get next greater float.

fn next_positive(self) -> Self

Get next greater float for a positive float. Value must be >= 0.0 and < INFINITY.

fn prev(self) -> Self

Get previous greater float, such that self.prev().next() == self.

fn prev_positive(self) -> Self

Get previous greater float for a positive float. Value must be > 0.0.

fn round_positive_even(self) -> Self

Round a positive number to even.

fn max_finite(self, f: Self) -> Self

Get the max of two finite numbers.

fn min_finite(self, f: Self) -> Self

Get the min of two finite numbers.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl Float for f32

Available on crate feature floats only.

const ZERO: f32 = 0.0

const ONE: f32 = 1.0

const TWO: f32 = 2.0

const MAX: f32 = f32::MAX

const MIN: f32 = f32::MIN

const INFINITY: f32 = f32::INFINITY

const NEG_INFINITY: f32 = f32::NEG_INFINITY

const NAN: f32 = f32::NAN

const BITS: usize

const SIGN_MASK: Self::Unsigned = 0x80000000

const EXPONENT_MASK: Self::Unsigned = 0x7F800000

const HIDDEN_BIT_MASK: Self::Unsigned = 0x00800000

const MANTISSA_MASK: Self::Unsigned = 0x007FFFFF

const CARRY_MASK: Self::Unsigned

const INFINITY_BITS: Self::Unsigned = 0x7F800000

const NEGATIVE_INFINITY_BITS: Self::Unsigned

const EXPONENT_SIZE: i32 = 8

const MANTISSA_SIZE: i32 = 23

const EXPONENT_BIAS: i32

const DENORMAL_EXPONENT: i32

const MAX_EXPONENT: i32

type Unsigned = u32

fn to_bits(self) -> u32

fn from_bits(u: u32) -> f32

fn ln(self) -> f32

fn floor(self) -> f32

fn is_sign_positive(self) -> bool

fn is_sign_negative(self) -> bool

impl Float for f64

Available on crate feature floats only.

const ZERO: f64 = 0.0

const ONE: f64 = 1.0

const TWO: f64 = 2.0

const MAX: f64 = f64::MAX

const MIN: f64 = f64::MIN

const INFINITY: f64 = f64::INFINITY

const NEG_INFINITY: f64 = f64::NEG_INFINITY

const NAN: f64 = f64::NAN

const BITS: usize

const SIGN_MASK: Self::Unsigned = 0x8000000000000000

const EXPONENT_MASK: Self::Unsigned = 0x7FF0000000000000

const HIDDEN_BIT_MASK: Self::Unsigned = 0x0010000000000000

const MANTISSA_MASK: Self::Unsigned = 0x000FFFFFFFFFFFFF

const CARRY_MASK: Self::Unsigned

const INFINITY_BITS: Self::Unsigned = 0x7FF0000000000000

const NEGATIVE_INFINITY_BITS: Self::Unsigned

const EXPONENT_SIZE: i32 = 11

const MANTISSA_SIZE: i32 = 52

const EXPONENT_BIAS: i32

const DENORMAL_EXPONENT: i32

const MAX_EXPONENT: i32

type Unsigned = u64

fn to_bits(self) -> u64

fn from_bits(u: u64) -> f64

fn ln(self) -> f64

fn floor(self) -> f64

fn is_sign_positive(self) -> bool

fn is_sign_negative(self) -> bool

Implementors