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

const ZERO: f32 = 0f32

const ONE: f32 = 1f32

const TWO: f32 = 2f32

const MAX: f32 = 3.40282347E+38f32

const MIN: f32 = -3.40282347E+38f32

const INFINITY: f32 = +Inf_f32

const NEG_INFINITY: f32 = -Inf_f32

const NAN: f32 = NaN_f32

const BITS: usize = 32usize

const SIGN_MASK: Self::Unsigned = {transmute(0x80000000): <f32 as num::Float>::Unsigned}

const EXPONENT_MASK: Self::Unsigned = {transmute(0x7f800000): <f32 as num::Float>::Unsigned}

const HIDDEN_BIT_MASK: Self::Unsigned = {transmute(0x00800000): <f32 as num::Float>::Unsigned}

const MANTISSA_MASK: Self::Unsigned = {transmute(0x007fffff): <f32 as num::Float>::Unsigned}

const CARRY_MASK: Self::Unsigned = {transmute(0x01000000): <f32 as num::Float>::Unsigned}

const INFINITY_BITS: Self::Unsigned = {transmute(0x7f800000): <f32 as num::Float>::Unsigned}

const NEGATIVE_INFINITY_BITS: Self::Unsigned = {transmute(0xff800000): <f32 as num::Float>::Unsigned}

const EXPONENT_SIZE: i32 = 8i32

const MANTISSA_SIZE: i32 = 23i32

const EXPONENT_BIAS: i32 = 150i32

const DENORMAL_EXPONENT: i32 = -149i32

const MAX_EXPONENT: i32 = 105i32

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

const ZERO: f64 = 0f64

const ONE: f64 = 1f64

const TWO: f64 = 2f64

const MAX: f64 = 1.7976931348623157E+308f64

const MIN: f64 = -1.7976931348623157E+308f64

const INFINITY: f64 = +Inf_f64

const NEG_INFINITY: f64 = -Inf_f64

const NAN: f64 = NaN_f64

const BITS: usize = 64usize

const SIGN_MASK: Self::Unsigned = {transmute(0x8000000000000000): <f64 as num::Float>::Unsigned}

const EXPONENT_MASK: Self::Unsigned = {transmute(0x7ff0000000000000): <f64 as num::Float>::Unsigned}

const HIDDEN_BIT_MASK: Self::Unsigned = {transmute(0x0010000000000000): <f64 as num::Float>::Unsigned}

const MANTISSA_MASK: Self::Unsigned = {transmute(0x000fffffffffffff): <f64 as num::Float>::Unsigned}

const CARRY_MASK: Self::Unsigned = {transmute(0x0020000000000000): <f64 as num::Float>::Unsigned}

const INFINITY_BITS: Self::Unsigned = {transmute(0x7ff0000000000000): <f64 as num::Float>::Unsigned}

const NEGATIVE_INFINITY_BITS: Self::Unsigned = {transmute(0xfff0000000000000): <f64 as num::Float>::Unsigned}

const EXPONENT_SIZE: i32 = 11i32

const MANTISSA_SIZE: i32 = 52i32

const EXPONENT_BIAS: i32 = 1_075i32

const DENORMAL_EXPONENT: i32 = -1_074i32

const MAX_EXPONENT: i32 = 972i32

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