Trait FpRepr 

pub trait FpRepr:
    Sized
    + Copy
    + PartialEq
    + PartialOrd {
    type Bits;

    const ZERO: Self;
    const ONE: Self;
    const MIN: Self;
    const MAX: Self;
    const MIN_POSITIVE: Self;
    const INFINITY: Self;
    const NEG_INFINITY: Self;
    const BITS: u32;
    const SIGN_BITS: u32;
    const EXPONENT_BITS: u32;
    const SIGNIFICAND_BITS: u32;
    const EXPONENT_MAX: Self::Bits;
    const EXPONENT_BIAS: Self::Bits;
    const SIGN_MASK: Self::Bits;
    const EXPONENT_MASK: Self::Bits;
    const SIGNIFICAND_MASK: Self::Bits;
    const IMPLICIT_BIT: Self::Bits;
}

Required Associated Constants

const ZERO: Self

const ONE: Self

const MIN: Self

const MAX: Self

const MIN_POSITIVE: Self

const INFINITY: Self

const NEG_INFINITY: Self

const BITS: u32

const SIGN_BITS: u32

const EXPONENT_BITS: u32

const SIGNIFICAND_BITS: u32

const EXPONENT_MAX: Self::Bits

const EXPONENT_BIAS: Self::Bits

const SIGN_MASK: Self::Bits

const EXPONENT_MASK: Self::Bits

const SIGNIFICAND_MASK: Self::Bits

const IMPLICIT_BIT: Self::Bits

Required Associated Types

type Bits

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.

Implementors

impl FpRepr for F8

const ZERO: Self

const ONE: Self

const MIN: Self

const MAX: Self

const MIN_POSITIVE: Self

const INFINITY: Self

const NEG_INFINITY: Self

const BITS: u32 = 8u32

const SIGN_BITS: u32 = 1u32

const EXPONENT_BITS: u32 = 4u32

const SIGNIFICAND_BITS: u32 = 3u32

const EXPONENT_MAX: Self::Bits = {transmute(0x0f): <floats::F8 as repr::FpRepr>::Bits}

const EXPONENT_BIAS: Self::Bits = {transmute(0x07): <floats::F8 as repr::FpRepr>::Bits}

const SIGN_MASK: Self::Bits = {transmute(0x80): <floats::F8 as repr::FpRepr>::Bits}

const EXPONENT_MASK: Self::Bits = {transmute(0x78): <floats::F8 as repr::FpRepr>::Bits}

const SIGNIFICAND_MASK: Self::Bits = {transmute(0x07): <floats::F8 as repr::FpRepr>::Bits}

const IMPLICIT_BIT: Self::Bits = {transmute(0x08): <floats::F8 as repr::FpRepr>::Bits}

type Bits = u8

impl FpRepr for F16

const ZERO: Self

const ONE: Self

const MIN: Self

const MAX: Self

const MIN_POSITIVE: Self

const INFINITY: Self

const NEG_INFINITY: Self

const BITS: u32 = 16u32

const SIGN_BITS: u32 = 1u32

const EXPONENT_BITS: u32 = 5u32

const SIGNIFICAND_BITS: u32 = 10u32

const EXPONENT_MAX: Self::Bits = {transmute(0x001f): <floats::F16 as repr::FpRepr>::Bits}

const EXPONENT_BIAS: Self::Bits = {transmute(0x000f): <floats::F16 as repr::FpRepr>::Bits}

const SIGN_MASK: Self::Bits = {transmute(0x8000): <floats::F16 as repr::FpRepr>::Bits}

const EXPONENT_MASK: Self::Bits = {transmute(0x7c00): <floats::F16 as repr::FpRepr>::Bits}

const SIGNIFICAND_MASK: Self::Bits = {transmute(0x03ff): <floats::F16 as repr::FpRepr>::Bits}

const IMPLICIT_BIT: Self::Bits = {transmute(0x0400): <floats::F16 as repr::FpRepr>::Bits}

type Bits = u16

impl FpRepr for F24

const ZERO: Self

const ONE: Self

const MIN: Self

const MAX: Self

const MIN_POSITIVE: Self

const INFINITY: Self

const NEG_INFINITY: Self

const BITS: u32 = 24u32

const SIGN_BITS: u32 = 1u32

const EXPONENT_BITS: u32 = 7u32

const SIGNIFICAND_BITS: u32 = 16u32

const EXPONENT_MAX: Self::Bits = {transmute(0x0000007f): <floats::F24 as repr::FpRepr>::Bits}

const EXPONENT_BIAS: Self::Bits = {transmute(0x0000003f): <floats::F24 as repr::FpRepr>::Bits}

const SIGN_MASK: Self::Bits = {transmute(0x00800000): <floats::F24 as repr::FpRepr>::Bits}

const EXPONENT_MASK: Self::Bits = {transmute(0x007f0000): <floats::F24 as repr::FpRepr>::Bits}

const SIGNIFICAND_MASK: Self::Bits = {transmute(0x0000ffff): <floats::F24 as repr::FpRepr>::Bits}

const IMPLICIT_BIT: Self::Bits = {transmute(0x00010000): <floats::F24 as repr::FpRepr>::Bits}

type Bits = u32

impl FpRepr for F32

const ZERO: Self

const ONE: Self

const MIN: Self

const MAX: Self

const MIN_POSITIVE: Self

const INFINITY: Self

const NEG_INFINITY: Self

const BITS: u32 = 32u32

const SIGN_BITS: u32 = 1u32

const EXPONENT_BITS: u32 = 8u32

const SIGNIFICAND_BITS: u32 = 23u32

const EXPONENT_MAX: Self::Bits = {transmute(0x000000ff): <floats::F32 as repr::FpRepr>::Bits}

const EXPONENT_BIAS: Self::Bits = {transmute(0x0000007f): <floats::F32 as repr::FpRepr>::Bits}

const SIGN_MASK: Self::Bits = {transmute(0x80000000): <floats::F32 as repr::FpRepr>::Bits}

const EXPONENT_MASK: Self::Bits = {transmute(0x7f800000): <floats::F32 as repr::FpRepr>::Bits}

const SIGNIFICAND_MASK: Self::Bits = {transmute(0x007fffff): <floats::F32 as repr::FpRepr>::Bits}

const IMPLICIT_BIT: Self::Bits = {transmute(0x00800000): <floats::F32 as repr::FpRepr>::Bits}

type Bits = u32

impl FpRepr for F40

const ZERO: Self

const ONE: Self

const MIN: Self

const MAX: Self

const MIN_POSITIVE: Self

const INFINITY: Self

const NEG_INFINITY: Self

const BITS: u32 = 40u32

const SIGN_BITS: u32 = 1u32

const EXPONENT_BITS: u32 = 8u32

const SIGNIFICAND_BITS: u32 = 31u32

const EXPONENT_MAX: Self::Bits = {transmute(0x00000000000000ff): <floats::F40 as repr::FpRepr>::Bits}

const EXPONENT_BIAS: Self::Bits = {transmute(0x000000000000007f): <floats::F40 as repr::FpRepr>::Bits}

const SIGN_MASK: Self::Bits = {transmute(0x0000008000000000): <floats::F40 as repr::FpRepr>::Bits}

const EXPONENT_MASK: Self::Bits = {transmute(0x0000007f80000000): <floats::F40 as repr::FpRepr>::Bits}

const SIGNIFICAND_MASK: Self::Bits = {transmute(0x000000007fffffff): <floats::F40 as repr::FpRepr>::Bits}

const IMPLICIT_BIT: Self::Bits = {transmute(0x0000000080000000): <floats::F40 as repr::FpRepr>::Bits}

type Bits = u64

impl FpRepr for F48

const ZERO: Self

const ONE: Self

const MIN: Self

const MAX: Self

const MIN_POSITIVE: Self

const INFINITY: Self

const NEG_INFINITY: Self

const BITS: u32 = 48u32

const SIGN_BITS: u32 = 1u32

const EXPONENT_BITS: u32 = 9u32

const SIGNIFICAND_BITS: u32 = 38u32

const EXPONENT_MAX: Self::Bits = {transmute(0x00000000000001ff): <floats::F48 as repr::FpRepr>::Bits}

const EXPONENT_BIAS: Self::Bits = {transmute(0x00000000000000ff): <floats::F48 as repr::FpRepr>::Bits}

const SIGN_MASK: Self::Bits = {transmute(0x0000800000000000): <floats::F48 as repr::FpRepr>::Bits}

const EXPONENT_MASK: Self::Bits = {transmute(0x00007fc000000000): <floats::F48 as repr::FpRepr>::Bits}

const SIGNIFICAND_MASK: Self::Bits = {transmute(0x0000003fffffffff): <floats::F48 as repr::FpRepr>::Bits}

const IMPLICIT_BIT: Self::Bits = {transmute(0x0000004000000000): <floats::F48 as repr::FpRepr>::Bits}

type Bits = u64

impl FpRepr for F56

const ZERO: Self

const ONE: Self

const MIN: Self

const MAX: Self

const MIN_POSITIVE: Self

const INFINITY: Self

const NEG_INFINITY: Self

const BITS: u32 = 56u32

const SIGN_BITS: u32 = 1u32

const EXPONENT_BITS: u32 = 10u32

const SIGNIFICAND_BITS: u32 = 45u32

const EXPONENT_MAX: Self::Bits = {transmute(0x00000000000003ff): <floats::F56 as repr::FpRepr>::Bits}

const EXPONENT_BIAS: Self::Bits = {transmute(0x00000000000001ff): <floats::F56 as repr::FpRepr>::Bits}

const SIGN_MASK: Self::Bits = {transmute(0x0080000000000000): <floats::F56 as repr::FpRepr>::Bits}

const EXPONENT_MASK: Self::Bits = {transmute(0x007fe00000000000): <floats::F56 as repr::FpRepr>::Bits}

const SIGNIFICAND_MASK: Self::Bits = {transmute(0x00001fffffffffff): <floats::F56 as repr::FpRepr>::Bits}

const IMPLICIT_BIT: Self::Bits = {transmute(0x0000200000000000): <floats::F56 as repr::FpRepr>::Bits}

type Bits = u64

impl FpRepr for F64

const ZERO: Self

const ONE: Self

const MIN: Self

const MAX: Self

const MIN_POSITIVE: Self

const INFINITY: Self

const NEG_INFINITY: Self

const BITS: u32 = 64u32

const SIGN_BITS: u32 = 1u32

const EXPONENT_BITS: u32 = 11u32

const SIGNIFICAND_BITS: u32 = 52u32

const EXPONENT_MAX: Self::Bits = {transmute(0x00000000000007ff): <floats::F64 as repr::FpRepr>::Bits}

const EXPONENT_BIAS: Self::Bits = {transmute(0x00000000000003ff): <floats::F64 as repr::FpRepr>::Bits}

const SIGN_MASK: Self::Bits = {transmute(0x8000000000000000): <floats::F64 as repr::FpRepr>::Bits}

const EXPONENT_MASK: Self::Bits = {transmute(0x7ff0000000000000): <floats::F64 as repr::FpRepr>::Bits}

const SIGNIFICAND_MASK: Self::Bits = {transmute(0x000fffffffffffff): <floats::F64 as repr::FpRepr>::Bits}

const IMPLICIT_BIT: Self::Bits = {transmute(0x0010000000000000): <floats::F64 as repr::FpRepr>::Bits}

type Bits = u64