Trait Float

pub trait Float:
    Copy
    + PartialEq
    + PartialOrd
    + AsBits
where
    Self::Bits: Cast<Self::BiasedExponent> + Cast<Self::Significand>,
    Self::BiasedExponent: Cast<Self::Exponent>,
    Self::Exponent: Sub<Output = Self::Exponent>,
    Self::Significand: Add<Output = Self::Significand>,
{
    type BiasedExponent;
    type Exponent;
    type Significand;

    const EXP_BITS: u16;
    const SIGNIF_BITS: u16;
    const SIGN_MASK: Self::Bits;
    const EXP_MASK: Self::Bits;
    const SIGNIF_MASK: Self::Bits;
    const EXP_BIAS: Self::Exponent;
    const BITS: u16 = _;

    // Provided methods
    fn sign_bit(self) -> bool { ... }
    fn biased_exponent(self) -> Self::BiasedExponent { ... }
    fn exponent(self) -> Self::Exponent { ... }
    fn stored_significand(self) -> Self::Significand { ... }
    fn significand(self) -> Self::Significand { ... }
    fn fraction(self) -> Self::Significand { ... }
    fn raw_components(self) -> (bool, Self::BiasedExponent, Self::Significand) { ... }
    fn components(self) -> (bool, Self::Exponent, Self::Significand) { ... }
    fn explain(self)
       where Self: Debug,
             Self::BiasedExponent: Debug,
             Self::Exponent: Debug,
             Self::Significand: Debug { ... }
}

Types that represent a floating point number.

Required Associated Constants

const EXP_BITS: u16

The number of bits of the exponent.

const SIGNIF_BITS: u16

The number of bits of the stored significand (not counting the implicit bit).

const SIGN_MASK: Self::Bits

The mask for the sign bit.

const EXP_MASK: Self::Bits

The mask for the biased exponent bits.

const SIGNIF_MASK: Self::Bits

The mask for the stored significand bits (no implicit bit).

const EXP_BIAS: Self::Exponent

The exponent bias.

Provided Associated Constants

const BITS: u16 = _

The number of bits (defaults to <Self as AsBits>::Bits::BITS).

Required Associated Types

type BiasedExponent

Type for the the biased exponent.

type Exponent

Type for the true (unbiased) signed exponent.

type Significand

Type for the significand, both with and without implicit bit.

Provided Methods

fn sign_bit(self) -> bool

True if the sign bit is set, false otherwise.

fn biased_exponent(self) -> Self::BiasedExponent

The biased exponent, as it is stored in the bit representation.

fn exponent(self) -> Self::Exponent

The true (unbiased) signed exponent.

fn stored_significand(self) -> Self::Significand

The significand without the implicit bit, as it is stored in the bit representation.

Synonym of Float::fraction.

fn significand(self) -> Self::Significand

The true significand, with the implicit bit added.

fn fraction(self) -> Self::Significand

The significand without the implicit bit, as it is stored in the bit representation.

Synonym of Float::stored_significand.

fn raw_components(self) -> (bool, Self::BiasedExponent, Self::Significand)

The triple of stored components: sign bit, biased exponent, significand without implicit bit.

fn components(self) -> (bool, Self::Exponent, Self::Significand)

The triple of true components: sign bit, exponent, significand with implicit bit.

fn explain(self)

where Self: Debug, Self::BiasedExponent: Debug, Self::Exponent: Debug, Self::Significand: Debug,

Nicely prints the components of a floating point number.

0.032_f32.explain();

value = 0.032
bits: 00111101000000110001001001101111
      ±^^^^^^^^_______________________
sign: +
exponent = 122 - 127 = -5
significand = 2^23 + 201327 = 8589935

Examples found in repository

examples/simple.rs (line 5)

fn main() {
    println!("f32 example");
    0.032_f32.explain();

    println!();

    println!("f64 example");
    0.032_f64.explain();
}

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 EXP_BITS: u16 = 8u16

const SIGNIF_BITS: u16 = 23u16

const SIGN_MASK: Self::Bits = {transmute(0x80000000): <f32 as AsBits>::Bits}

const EXP_MASK: Self::Bits = {transmute(0x7f800000): <f32 as AsBits>::Bits}

const SIGNIF_MASK: Self::Bits = {transmute(0x007fffff): <f32 as AsBits>::Bits}

const EXP_BIAS: Self::Exponent = {transmute(0x007f): <f32 as Float>::Exponent}

type BiasedExponent = u8

type Exponent = i16

type Significand = u32

impl Float for f64

const EXP_BITS: u16 = 11u16

const SIGNIF_BITS: u16 = 52u16

const SIGN_MASK: Self::Bits = {transmute(0x8000000000000000): <f64 as AsBits>::Bits}

const EXP_MASK: Self::Bits = {transmute(0x7ff0000000000000): <f64 as AsBits>::Bits}

const SIGNIF_MASK: Self::Bits = {transmute(0x000fffffffffffff): <f64 as AsBits>::Bits}

const EXP_BIAS: Self::Exponent = {transmute(0x03ff): <f64 as Float>::Exponent}

type BiasedExponent = u16

type Exponent = i16

type Significand = u64

Implementors