Struct F56

pub struct F56(pub [u8; 7]);

The F56 struct represents a 56-bit floating point number using 7 bytes. Most operations on F56 are done by converting to f64, performing the operation, and then converting back to F56

F56 uses 1 bit for the sign, 10 bits for the exponent, and 45 bits for the mantissa. Compared to f32, it has +2 exponent bits and +22 mantissa bits. Compared to f64, it has -1 exponent bit and -7 mantissa bits. Byte 0 Byte 1 Byte 2 Byte 3 Byte 4 Byte 5 Byte 6 [sEEEEEEE][EEEmmmmm][mmmmmmmm][mmmmmmmm][mmmmmmmm][mmmmmmmm][mmmmmmmm]]

Exponent bits range from 0 to 1023 they represent -511 to +512 but are stored biased by +511 the exponent of -511 is reserved for the number 0 and subnormal numbers the exponent of +512 is reserved for infinity and NaN so normal exponents range from -510 to +511

smallest positive subnormal value is 8.48e-168 (2^-555) smallest positive normal value is 2.98e-154 (2^-510) maximum finite value is 1.34e154

A f64 number like 1.00000000001 with 12 decimal digits will be 1.000000000001 A f64 number like 1.000000000001 with 13 decimal digits will be converted to 1.0

Tuple Fields

0: [u8; 7]

Implementations

impl F56

pub const MAX: F56

pub const MIN_POSITIVE: F56

pub const MIN_POSITIVE_SUBNORMAL: F56

pub const DIGITS: usize = 12usize

pub const EPSILON: f64 = 1.0E-10f64

pub const ROUNDUP_ENABLED: bool = false

pub fn round_f64_to_7_sig_figs(raw_f64: f64) -> f64

pub fn round_f64_to_f56_precision(raw_f64: f64) -> f64

pub fn roughly_equal_using_rounding_sig_figs(&self, other: &F56) -> bool

Returns true if the two F56s’s decimal forms are equal to 7 significant figures This is a lenient type of equality suitable for human use It preserves transitivity, reflexivity, and symmetry It meets the requirements of the Eq trait

pub fn roughly_equal_using_relative_difference(&self, other: &F56) -> bool

Returns true if the relative difference between the two F56s is less than F56::EPSILON This is a lenient type of equality suitable for human use It preserves reflexivity, and symmetry but not transitivity It does not meet the requirements of the Eq trait The relative difference is the absolute difference divided by the larger of the two numbers

pub fn strictest_equal(&self, other: &F56) -> bool

Returns true if the two F56s are bitwise identical

pub fn hash_for_strictest_equal(&self) -> u64

pub fn strictly_equal_except_nan_and_0(&self, other: &F56) -> bool

TODO PC #125 this ticket is outdated now but this may need to be used somewhere? Returns true if the two F56s are bitwise identical OR if they are both NaN or both 0

pub fn hash_for_strictly_equal_except_nan_and_0(&self) -> u64

TODO PC #125 this ticket is outdated now but this may need to be used somewhere?

pub fn is_nan(&self) -> bool

Returns true if the F56 is NaN. Note that there are many bit patterns that represent NaN

Trait Implementations

impl Clone for F56

fn clone(&self) -> F56

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for F56

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

Formats the value using the given formatter.

impl Display for F56

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

Formats the value using the given formatter.

impl From<F56> for LooseFloat

fn from(value: F56) -> Self

Converts to this type from the input type.

impl From<F56> for f32

fn from(f: F56) -> f32

Converts to this type from the input type.

impl From<F56> for f64

fn from(f: F56) -> f64

Converts to this type from the input type.

impl From<LooseFloat> for F56

fn from(value: LooseFloat) -> Self

Converts to this type from the input type.

impl From<f32> for F56

fn from(f: f32) -> F56

Converts to this type from the input type.

impl From<f64> for F56

fn from(f: f64) -> F56

Converts to this type from the input type.

impl FromStr for F56

type Err = ParseFloatError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Hash for F56

In order to use F56 as a key in a hash map, we need to ensure: If a == b then hash(a) == hash(b)

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for F56

appropriate for identical? comparison

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 Copy for F56

impl Eq for F56