Trait Float 

pub trait Float:
    Sized
    + Copy
    + PartialEq
    + PartialOrd
    + Send
    + Sync
    + Add<Output = Self>
    + AddAssign
    + Div<Output = Self>
    + DivAssign
    + Mul<Output = Self>
    + MulAssign
    + Rem<Output = Self>
    + RemAssign
    + Sub<Output = Self>
    + SubAssign
    + Neg<Output = Self> {
    const MAX_DIGITS: usize;
    const SIGN_MASK: u64;
    const EXPONENT_MASK: u64;
    const HIDDEN_BIT_MASK: u64;
    const MANTISSA_MASK: u64;
    const MANTISSA_SIZE: i32;
    const EXPONENT_BIAS: i32;
    const DENORMAL_EXPONENT: i32;
    const MAX_EXPONENT: i32;
    const CARRY_MASK: u64;
    const MIN_EXPONENT_ROUND_TO_EVEN: i32;
    const MAX_EXPONENT_ROUND_TO_EVEN: i32;
    const MINIMUM_EXPONENT: i32;
    const SMALLEST_POWER_OF_TEN: i32;
    const LARGEST_POWER_OF_TEN: i32;
    const MIN_EXPONENT_FAST_PATH: i32;
    const MAX_EXPONENT_FAST_PATH: i32;
    const MAX_EXPONENT_DISGUISED_FAST_PATH: i32;
    const INVALID_FP: i32 = -0x8000;
    const MAX_MANTISSA_FAST_PATH: u64 = _;
    const INFINITE_POWER: i32 = _;

    // Required methods
    fn from_u64(u: u64) -> Self;
    fn from_bits(u: u64) -> Self;
    fn to_bits(self) -> u64;
    unsafe fn pow_fast_path(exponent: usize) -> Self;

    // Provided methods
    unsafe fn int_pow_fast_path(exponent: usize, radix: u32) -> u64 { ... }
    fn is_denormal(self) -> bool { ... }
    fn exponent(self) -> i32 { ... }
    fn mantissa(self) -> u64 { ... }
}

Generic floating-point type, to be used in generic code for parsing.

Although the trait is part of the public API, the trait provides methods and constants that are effectively non-public: they may be removed at any time without any breaking changes.

Required Associated Constants

const MAX_DIGITS: usize

Maximum number of digits that can contribute in the mantissa.

We can exactly represent a float in radix b from radix 2 if b is divisible by 2. This function calculates the exact number of digits required to exactly represent that float.

According to the “Handbook of Floating Point Arithmetic”, for IEEE754, with emin being the min exponent, p2 being the precision, and b being the radix, the number of digits follows as:

−emin + p2 + ⌊(emin + 1) log(2, b) − log(1 − 2^(−p2), b)⌋

For f32, this follows as: emin = -126 p2 = 24

For f64, this follows as: emin = -1022 p2 = 53

In Python: -emin + p2 + math.floor((emin+1)*math.log(2, b) - math.log(1-2**(-p2), b))

This was used to calculate the maximum number of digits for [2, 36].

const SIGN_MASK: u64

Bitmask for the sign bit.

const EXPONENT_MASK: u64

Bitmask for the exponent, including the hidden bit.

const HIDDEN_BIT_MASK: u64

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

const MANTISSA_MASK: u64

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

const MANTISSA_SIZE: i32

Size of the significand (mantissa) without hidden bit.

const EXPONENT_BIAS: i32

Bias of the exponet

const DENORMAL_EXPONENT: i32

Exponent portion of a denormal float.

const MAX_EXPONENT: i32

Maximum exponent value in float.

const CARRY_MASK: u64

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

const MIN_EXPONENT_ROUND_TO_EVEN: i32

const MAX_EXPONENT_ROUND_TO_EVEN: i32

const MINIMUM_EXPONENT: i32

Minimum normal exponent value -(1 << (EXPONENT_SIZE - 1)) + 1.

const SMALLEST_POWER_OF_TEN: i32

Smallest decimal exponent for a non-zero value.

const LARGEST_POWER_OF_TEN: i32

Largest decimal exponent for a non-infinite value.

const MIN_EXPONENT_FAST_PATH: i32

Minimum exponent that for a fast path case, or -⌊(MANTISSA_SIZE+1)/log2(10)⌋

const MAX_EXPONENT_FAST_PATH: i32

Maximum exponent that for a fast path case, or ⌊(MANTISSA_SIZE+1)/log2(5)⌋

const MAX_EXPONENT_DISGUISED_FAST_PATH: i32

Maximum exponent that can be represented for a disguised-fast path case. This is MAX_EXPONENT_FAST_PATH + ⌊(MANTISSA_SIZE+1)/log2(10)⌋

Provided Associated Constants

const INVALID_FP: i32 = -0x8000

Bias for marking an invalid extended float.

const MAX_MANTISSA_FAST_PATH: u64 = _

const INFINITE_POWER: i32 = _

Required Methods

fn from_u64(u: u64) -> Self

Convert 64-bit integer to float.

fn from_bits(u: u64) -> Self

fn to_bits(self) -> u64

unsafe fn pow_fast_path(exponent: usize) -> Self

Get a small power-of-radix for fast-path multiplication.

Safety

Safe as long as the exponent is smaller than the table size.

Provided Methods

unsafe fn int_pow_fast_path(exponent: usize, radix: u32) -> u64

Get a small, integral power-of-radix for fast-path multiplication.

Safety

Safe as long as the exponent is smaller than the table size.

fn is_denormal(self) -> bool

Returns true if the float is a denormal.

fn exponent(self) -> i32

Get exponent component from the float.

fn mantissa(self) -> u64

Get mantissa (significand) component from float.

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 MAX_DIGITS: usize = 114

const SIGN_MASK: u64 = 0x80000000

const EXPONENT_MASK: u64 = 0x7F800000

const HIDDEN_BIT_MASK: u64 = 0x00800000

const MANTISSA_MASK: u64 = 0x007FFFFF

const MANTISSA_SIZE: i32 = 23

const EXPONENT_BIAS: i32

const DENORMAL_EXPONENT: i32

const MAX_EXPONENT: i32

const CARRY_MASK: u64 = 0x1000000

const MIN_EXPONENT_ROUND_TO_EVEN: i32 = -17

const MAX_EXPONENT_ROUND_TO_EVEN: i32 = 10

const MINIMUM_EXPONENT: i32 = -127

const SMALLEST_POWER_OF_TEN: i32 = -65

const LARGEST_POWER_OF_TEN: i32 = 38

const MIN_EXPONENT_FAST_PATH: i32 = -10

const MAX_EXPONENT_FAST_PATH: i32 = 10

const MAX_EXPONENT_DISGUISED_FAST_PATH: i32 = 17

unsafe fn pow_fast_path(exponent: usize) -> Self

fn from_u64(u: u64) -> f32

fn from_bits(u: u64) -> f32

fn to_bits(self) -> u64

impl Float for f64

const MAX_DIGITS: usize = 769

const SIGN_MASK: u64 = 0x8000000000000000

const EXPONENT_MASK: u64 = 0x7FF0000000000000

const HIDDEN_BIT_MASK: u64 = 0x0010000000000000

const MANTISSA_MASK: u64 = 0x000FFFFFFFFFFFFF

const MANTISSA_SIZE: i32 = 52

const EXPONENT_BIAS: i32

const DENORMAL_EXPONENT: i32

const MAX_EXPONENT: i32

const CARRY_MASK: u64 = 0x20000000000000

const MIN_EXPONENT_ROUND_TO_EVEN: i32 = -4

const MAX_EXPONENT_ROUND_TO_EVEN: i32 = 23

const MINIMUM_EXPONENT: i32 = -1023

const SMALLEST_POWER_OF_TEN: i32 = -342

const LARGEST_POWER_OF_TEN: i32 = 308

const MIN_EXPONENT_FAST_PATH: i32 = -22

const MAX_EXPONENT_FAST_PATH: i32 = 22

const MAX_EXPONENT_DISGUISED_FAST_PATH: i32 = 37

unsafe fn pow_fast_path(exponent: usize) -> Self

fn from_u64(u: u64) -> f64

fn from_bits(u: u64) -> f64

fn to_bits(self) -> u64

Implementors