hexfloat2 0.2.0

Parse and format IEEE754 floating point hexadecimal syntax
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141

//! traits that abstract across f32 / f64.

use core::fmt::LowerHex;
use core::num::FpCategory;
use core::ops::{Shl, Shr};

#[doc(hidden)]
pub trait MantissaOps:
    Shl<u32, Output = Self> + Shr<u32, Output = Self> + LowerHex + TryFrom<u64>
{
    #[allow(dead_code, reason = "used only when 'alloc' feature is enabled")]
    fn trailing_zeroes(self) -> u32;
}

#[doc(hidden)]
pub trait ExponentOps: Into<i32> + TryFrom<i32> {}

impl MantissaOps for u32 {
    fn trailing_zeroes(self) -> u32 {
        u32::trailing_zeros(self)
    }
}
impl ExponentOps for u8 {}
impl MantissaOps for u64 {
    fn trailing_zeroes(self) -> u32 {
        u64::trailing_zeros(self)
    }
}
impl ExponentOps for u16 {}

#[doc(hidden)]
pub trait FloatBits {
    const BITS: u32;
    const EXPONENT_BITS: u8;
    const MANTISSA_BITS: u8;
    const EXPONENT_BIAS: u16;
    const INFINITY: Self;
    const NEG_INFINITY: Self;
    const NAN: Self;

    type IntegerBits;
    type ExponentType: ExponentOps;
    type MantissaType: MantissaOps + Copy;

    fn zero(sign: bool) -> Self;
    fn from_parts(sign: bool, exponent: Self::ExponentType, mantissa: Self::MantissaType) -> Self;
    fn to_parts(&self) -> (bool, Self::ExponentType, Self::MantissaType);
    fn category(&self) -> FpCategory;
}

impl FloatBits for f32 {
    const BITS: u32 = 32;
    const EXPONENT_BITS: u8 = 8;
    const MANTISSA_BITS: u8 = 23;
    const EXPONENT_BIAS: u16 = 127;
    const INFINITY: Self = f32::INFINITY;
    const NEG_INFINITY: Self = f32::NEG_INFINITY;
    const NAN: Self = f32::NAN;
    type IntegerBits = u32;
    type ExponentType = u8;
    type MantissaType = u32;

    /// Return a zero.
    ///
    /// If sign is `true`, return a negative zero.
    fn zero(sign: bool) -> Self {
        if sign {
            -0.0
        } else {
            0.0
        }
    }

    /// Create the f32 bit layout.
    ///
    /// Inputs should be right-aligned (i.e. LSB is the 0 bit).
    /// The caller must verify that the inputs are within the proper bounds.
    ///
    fn from_parts(sign: bool, exponent: u8, mantissa: u32) -> Self {
        let bits: u32 = (u32::from(sign) << 31) + (u32::from(exponent) << 23) + mantissa;
        f32::from_bits(bits)
    }

    fn to_parts(&self) -> (bool, u8, u32) {
        let bits = self.to_bits();
        let sign: bool = (bits >> 31) == 1;
        let exponent = u8::try_from((bits >> 23) & 0xFF).unwrap();
        let mantissa = bits & 0x7F_FFFF;
        (sign, exponent, mantissa)
    }

    fn category(&self) -> FpCategory {
        self.classify()
    }
}

impl FloatBits for f64 {
    const BITS: u32 = 64;
    const EXPONENT_BITS: u8 = 11;
    const MANTISSA_BITS: u8 = 52;
    const EXPONENT_BIAS: u16 = 1023;
    const INFINITY: Self = f64::INFINITY;
    const NEG_INFINITY: Self = f64::NEG_INFINITY;
    const NAN: Self = f64::NAN;
    type IntegerBits = u64;
    type ExponentType = u16;
    type MantissaType = u64;

    /// Return a zero.
    ///
    /// If sign is `true`, return a negative zero.
    fn zero(sign: bool) -> Self {
        if sign {
            -0.0
        } else {
            0.0
        }
    }

    /// Create the f64 bit layout.
    ///
    /// Inputs should be right-aligned (i.e. LSB is the 0 bit).
    /// The caller must verify that the inputs are within the proper bounds.
    ///
    fn from_parts(sign: bool, exponent: u16, mantissa: u64) -> Self {
        let bits: u64 = (u64::from(sign) << 63) + (u64::from(exponent) << 52) + mantissa;
        f64::from_bits(bits)
    }

    fn to_parts(&self) -> (bool, u16, u64) {
        let bits = self.to_bits();
        let sign: bool = (bits >> 63) == 1;
        let exponent = ((bits >> 52) & 0x7FF) as u16;
        let mantissa = bits & 0x000F_FFFF_FFFF_FFFF;
        (sign, exponent, mantissa)
    }

    fn category(&self) -> FpCategory {
        self.classify()
    }
}