Struct F64 

pub struct F64(/* private fields */);

A bit-level representation of a 64-bit floating-point number.

The bits are laid out as follows:

• Sign bit: 1 bit
• Exponent width: 11 bits
• Significand precision: 53 bits (52 explicitly stored)

 MSB                           ...                           LSB
┌─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬╴╴╴┬─┐
└─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴╴╴╴┴─┘
 │ ├─────────────────┘ ├───────────────────────────────────╴╴╴─┘
 │ │                   └ Significand (53 bits)
 │ └ Exponent (11 bits)
 └ Sign (1 bit)

Trait Implementations

impl Clone for F64

fn clone(&self) -> F64

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for F64

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for F64

fn default() -> F64

Returns the “default value” for a type.

impl FpClassify for F64

fn classify(&self) -> FpCategory

fn is_zero(&self) -> bool

fn is_nan(&self) -> bool

fn is_infinite(&self) -> bool

fn is_subnormal(&self) -> bool

fn is_normal(&self) -> bool

impl FpExtend<F64> for F16

fn extend(self) -> F64

impl FpExtend<F64> for F24

fn extend(self) -> F64

impl FpExtend<F64> for F32

fn extend(self) -> F64

impl FpExtend<F64> for F40

fn extend(self) -> F64

impl FpExtend<F64> for F48

fn extend(self) -> F64

impl FpExtend<F64> for F56

fn extend(self) -> F64

impl FpExtend<F64> for F8

fn extend(self) -> F64

impl FpFromBeBytes for F64

type Bytes = [u8; 8]

fn from_be_bytes(be_bytes: Self::Bytes) -> Self

impl FpFromBits for F64

type Bits = u64

fn from_bits(bits: Self::Bits) -> Self

impl FpPack for F64

type Validator = PackedFloatValidator<f64>

fn pack_native(self, validator: &Self::Validator) -> PackedFloat

fn pack_optimal(self, validator: &Self::Validator) -> PackedFloat

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

impl FpToBeBytes for F64

type Bytes = [u8; 8]

fn to_be_bytes(self) -> Self::Bytes

impl FpToBits for F64

type Bits = u64

fn to_bits(self) -> Self::Bits

impl FpTruncate<F16> for F64

fn truncate(self) -> (F64, F16)

impl FpTruncate<F24> for F64

fn truncate(self) -> (F64, F24)

impl FpTruncate<F32> for F64

fn truncate(self) -> (F64, F32)

impl FpTruncate<F40> for F64

fn truncate(self) -> (F64, F40)

impl FpTruncate<F48> for F64

fn truncate(self) -> (F64, F48)

impl FpTruncate<F56> for F64

fn truncate(self) -> (F64, F56)

impl FpTruncate<F8> for F64

fn truncate(self) -> (F64, F8)

impl From<F64> for f64

fn from(value: F64) -> Self

Converts to this type from the input type.

impl From<f64> for F64

fn from(value: f64) -> Self

Converts to this type from the input type.

impl PartialEq for F64

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for F64

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Copy for F64