floats 0.2.0

f16 and f128 floating point types for compatibility with future Rust versions
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
142

use core::ops::Neg;

mod aarch64;
mod sw;
mod x86_64;

/// 16-bit floating point type (IEEE 754 half-precision).
///
/// This provides a minimal implementation with construction methods and
/// conversions through f32.
#[derive(Debug, Clone, Copy, Default)]
#[allow(non_camel_case_types)]
#[repr(transparent)]
pub struct f16(pub(crate) u16);

impl Neg for f16 {
    type Output = Self;

    #[inline]
    fn neg(self) -> Self::Output {
        Self(self.0 ^ (1 << 15))
    }
}

impl PartialEq for f16 {
    #[inline]
    fn eq(&self, other: &Self) -> bool {
        // IEEE 754 compliance:
        // 1. NaN != NaN (including all NaN bit patterns)
        // 2. +0.0 == -0.0

        // Check for NaN using proper IEEE 754 detection:
        // exponent = 0x1F (all 1s) AND mantissa != 0
        let self_exp = (self.0 >> 10) & 0x1F;
        let self_mantissa = self.0 & 0x3FF;
        let other_exp = (other.0 >> 10) & 0x1F;
        let other_mantissa = other.0 & 0x3FF;

        let self_is_nan = self_exp == 0x1F && self_mantissa != 0;
        let other_is_nan = other_exp == 0x1F && other_mantissa != 0;

        if self_is_nan || other_is_nan {
            return false;
        }

        // Handle +0.0 == -0.0: both have exponent=0 and mantissa=0
        let self_is_zero = (self.0 & 0x7FFF) == 0;
        let other_is_zero = (other.0 & 0x7FFF) == 0;

        if self_is_zero && other_is_zero {
            return true;
        }

        // Normal comparison
        self.0 == other.0
    }
}

impl f16 {
    pub const NAN: Self = Self(u16::MAX);

    pub const MIN: Self = Self(0xfbff);
    pub const MAX: Self = Self(0x7bff);

    pub const INFINITY: Self = Self(u16::MAX - 1);
    pub const NEG_INFINITY: Self = Self(u16::MAX - 2);

    pub const MANTISSA_DIGITS: u32 = 11;

    #[inline]
    pub const fn is_nan(self) -> bool {
        self.0 == Self::NAN.0
    }

    #[inline]
    pub const fn is_infinite(self) -> bool {
        self.0 == Self::INFINITY.0 || self.0 == Self::NEG_INFINITY.0
    }

    #[inline]
    pub const fn is_finite(self) -> bool {
        !self.is_nan() && !self.is_infinite()
    }

    #[inline]
    pub const fn is_sign_positive(self) -> bool {
        (self.0 & (1 << 15)) == 0
    }

    #[inline]
    pub const fn is_sign_negative(self) -> bool {
        (self.0 & (1 << 15)) != 0
    }

    /// Creates an `f16` from its representation as a `u16`.
    #[inline]
    pub const fn from_bits(bits: u16) -> Self {
        Self(bits)
    }

    /// Creates an `f16` from its representation as a byte array in big endian.
    #[inline]
    pub const fn from_be_bytes(bytes: [u8; 2]) -> Self {
        Self(u16::from_be_bytes(bytes))
    }

    /// Creates an `f16` from its representation as a byte array in little endian.
    #[inline]
    pub const fn from_le_bytes(bytes: [u8; 2]) -> Self {
        Self(u16::from_le_bytes(bytes))
    }

    /// Creates an `f16` from its representation as a byte array in native endian.
    #[inline]
    pub const fn from_ne_bytes(bytes: [u8; 2]) -> Self {
        Self(u16::from_ne_bytes(bytes))
    }

    /// Returns the raw representation of this `f16` as a `u16`.
    #[inline]
    pub const fn to_bits(self) -> u16 {
        self.0
    }

    /// Returns the memory representation of this `f16` as a byte array in big endian.
    #[inline]
    pub const fn to_be_bytes(self) -> [u8; 2] {
        self.0.to_be_bytes()
    }

    /// Returns the memory representation of this `f16` as a byte array in little endian.
    #[inline]
    pub const fn to_le_bytes(self) -> [u8; 2] {
        self.0.to_le_bytes()
    }

    /// Returns the memory representation of this `f16` as a byte array in native endian.
    #[inline]
    pub const fn to_ne_bytes(self) -> [u8; 2] {
        self.0.to_ne_bytes()
    }
}