| //! An IEEE-compliant 8-bit float type for testing purposes. |
| |
| use std::cmp::{self, Ordering}; |
| use std::{fmt, ops}; |
| |
| use crate::Float; |
| |
| /// Sometimes verifying float logic is easiest when all values can quickly be checked exhaustively |
| /// or by hand. |
| /// |
| /// IEEE-754 compliant type that includes a 1 bit sign, 4 bit exponent, and 3 bit significand. |
| /// Bias is -7. |
| /// |
| /// Based on <https://en.wikipedia.org/wiki/Minifloat#Example_8-bit_float_(1.4.3)>. |
| #[derive(Clone, Copy)] |
| #[repr(transparent)] |
| #[allow(non_camel_case_types)] |
| pub struct f8(u8); |
| |
| impl Float for f8 { |
| type Int = u8; |
| type SignedInt = i8; |
| |
| const ZERO: Self = Self(0b0_0000_000); |
| const NEG_ZERO: Self = Self(0b1_0000_000); |
| const ONE: Self = Self(0b0_0111_000); |
| const NEG_ONE: Self = Self(0b1_0111_000); |
| const MAX: Self = Self(0b0_1110_111); |
| const MIN: Self = Self(0b1_1110_111); |
| const INFINITY: Self = Self(0b0_1111_000); |
| const NEG_INFINITY: Self = Self(0b1_1111_000); |
| const NAN: Self = Self(0b0_1111_100); |
| const NEG_NAN: Self = Self(0b1_1111_100); |
| const MIN_POSITIVE_NORMAL: Self = Self(1 << Self::SIG_BITS); |
| // FIXME: incorrect values |
| const EPSILON: Self = Self::ZERO; |
| const PI: Self = Self::ZERO; |
| const NEG_PI: Self = Self::ZERO; |
| const FRAC_PI_2: Self = Self::ZERO; |
| |
| const BITS: u32 = 8; |
| const SIG_BITS: u32 = 3; |
| const SIGN_MASK: Self::Int = 0b1_0000_000; |
| const SIG_MASK: Self::Int = 0b0_0000_111; |
| const EXP_MASK: Self::Int = 0b0_1111_000; |
| const IMPLICIT_BIT: Self::Int = 0b0_0001_000; |
| |
| fn to_bits(self) -> Self::Int { |
| self.0 |
| } |
| |
| fn to_bits_signed(self) -> Self::SignedInt { |
| self.0 as i8 |
| } |
| |
| fn is_nan(self) -> bool { |
| self.0 & Self::EXP_MASK == Self::EXP_MASK && self.0 & Self::SIG_MASK != 0 |
| } |
| |
| fn is_infinite(self) -> bool { |
| self.0 & Self::EXP_MASK == Self::EXP_MASK && self.0 & Self::SIG_MASK == 0 |
| } |
| |
| fn is_sign_negative(self) -> bool { |
| self.0 & Self::SIGN_MASK != 0 |
| } |
| |
| fn from_bits(a: Self::Int) -> Self { |
| Self(a) |
| } |
| |
| fn abs(self) -> Self { |
| libm::generic::fabs(self) |
| } |
| |
| fn copysign(self, other: Self) -> Self { |
| libm::generic::copysign(self, other) |
| } |
| |
| fn fma(self, _y: Self, _z: Self) -> Self { |
| unimplemented!() |
| } |
| |
| fn normalize(_significand: Self::Int) -> (i32, Self::Int) { |
| unimplemented!() |
| } |
| } |
| |
| impl f8 { |
| pub const ALL_LEN: usize = 240; |
| |
| /// All non-infinite non-NaN values of `f8` |
| pub const ALL: [Self; Self::ALL_LEN] = [ |
| // -m*2^7 |
| Self(0b1_1110_111), // -240 |
| Self(0b1_1110_110), |
| Self(0b1_1110_101), |
| Self(0b1_1110_100), |
| Self(0b1_1110_011), |
| Self(0b1_1110_010), |
| Self(0b1_1110_001), |
| Self(0b1_1110_000), // -128 |
| // -m*2^6 |
| Self(0b1_1101_111), // -120 |
| Self(0b1_1101_110), |
| Self(0b1_1101_101), |
| Self(0b1_1101_100), |
| Self(0b1_1101_011), |
| Self(0b1_1101_010), |
| Self(0b1_1101_001), |
| Self(0b1_1101_000), // -64 |
| // -m*2^5 |
| Self(0b1_1100_111), // -60 |
| Self(0b1_1100_110), |
| Self(0b1_1100_101), |
| Self(0b1_1100_100), |
| Self(0b1_1100_011), |
| Self(0b1_1100_010), |
| Self(0b1_1100_001), |
| Self(0b1_1100_000), // -32 |
| // -m*2^4 |
| Self(0b1_1011_111), // -30 |
| Self(0b1_1011_110), |
| Self(0b1_1011_101), |
| Self(0b1_1011_100), |
| Self(0b1_1011_011), |
| Self(0b1_1011_010), |
| Self(0b1_1011_001), |
| Self(0b1_1011_000), // -16 |
| // -m*2^3 |
| Self(0b1_1010_111), // -15 |
| Self(0b1_1010_110), |
| Self(0b1_1010_101), |
| Self(0b1_1010_100), |
| Self(0b1_1010_011), |
| Self(0b1_1010_010), |
| Self(0b1_1010_001), |
| Self(0b1_1010_000), // -8 |
| // -m*2^2 |
| Self(0b1_1001_111), // -7.5 |
| Self(0b1_1001_110), |
| Self(0b1_1001_101), |
| Self(0b1_1001_100), |
| Self(0b1_1001_011), |
| Self(0b1_1001_010), |
| Self(0b1_1001_001), |
| Self(0b1_1001_000), // -4 |
| // -m*2^1 |
| Self(0b1_1000_111), // -3.75 |
| Self(0b1_1000_110), |
| Self(0b1_1000_101), |
| Self(0b1_1000_100), |
| Self(0b1_1000_011), |
| Self(0b1_1000_010), |
| Self(0b1_1000_001), |
| Self(0b1_1000_000), // -2 |
| // -m*2^0 |
| Self(0b1_0111_111), // -1.875 |
| Self(0b1_0111_110), |
| Self(0b1_0111_101), |
| Self(0b1_0111_100), |
| Self(0b1_0111_011), |
| Self(0b1_0111_010), |
| Self(0b1_0111_001), |
| Self(0b1_0111_000), // -1 |
| // -m*2^-1 |
| Self(0b1_0110_111), // −0.9375 |
| Self(0b1_0110_110), |
| Self(0b1_0110_101), |
| Self(0b1_0110_100), |
| Self(0b1_0110_011), |
| Self(0b1_0110_010), |
| Self(0b1_0110_001), |
| Self(0b1_0110_000), // -0.5 |
| // -m*2^-2 |
| Self(0b1_0101_111), // −0.46875 |
| Self(0b1_0101_110), |
| Self(0b1_0101_101), |
| Self(0b1_0101_100), |
| Self(0b1_0101_011), |
| Self(0b1_0101_010), |
| Self(0b1_0101_001), |
| Self(0b1_0101_000), // -0.25 |
| // -m*2^-3 |
| Self(0b1_0100_111), // −0.234375 |
| Self(0b1_0100_110), |
| Self(0b1_0100_101), |
| Self(0b1_0100_100), |
| Self(0b1_0100_011), |
| Self(0b1_0100_010), |
| Self(0b1_0100_001), |
| Self(0b1_0100_000), // -0.125 |
| // -m*2^-4 |
| Self(0b1_0011_111), // −0.1171875 |
| Self(0b1_0011_110), |
| Self(0b1_0011_101), |
| Self(0b1_0011_100), |
| Self(0b1_0011_011), |
| Self(0b1_0011_010), |
| Self(0b1_0011_001), |
| Self(0b1_0011_000), // −0.0625 |
| // -m*2^-5 |
| Self(0b1_0010_111), // −0.05859375 |
| Self(0b1_0010_110), |
| Self(0b1_0010_101), |
| Self(0b1_0010_100), |
| Self(0b1_0010_011), |
| Self(0b1_0010_010), |
| Self(0b1_0010_001), |
| Self(0b1_0010_000), // −0.03125 |
| // -m*2^-6 |
| Self(0b1_0001_111), // −0.029296875 |
| Self(0b1_0001_110), |
| Self(0b1_0001_101), |
| Self(0b1_0001_100), |
| Self(0b1_0001_011), |
| Self(0b1_0001_010), |
| Self(0b1_0001_001), |
| Self(0b1_0001_000), // −0.015625 |
| // -m*2^-7 subnormal numbers |
| Self(0b1_0000_111), // −0.013671875 |
| Self(0b1_0000_110), |
| Self(0b1_0000_101), |
| Self(0b1_0000_100), |
| Self(0b1_0000_011), |
| Self(0b1_0000_010), |
| Self(0b1_0000_001), // −0.001953125 |
| // Zeroes |
| Self(0b1_0000_000), // -0.0 |
| Self(0b0_0000_000), // 0.0 |
| // m*2^-7 // subnormal numbers |
| Self(0b0_0000_001), |
| Self(0b0_0000_010), |
| Self(0b0_0000_011), |
| Self(0b0_0000_100), |
| Self(0b0_0000_101), |
| Self(0b0_0000_110), |
| Self(0b0_0000_111), // 0.013671875 |
| // m*2^-6 |
| Self(0b0_0001_000), // 0.015625 |
| Self(0b0_0001_001), |
| Self(0b0_0001_010), |
| Self(0b0_0001_011), |
| Self(0b0_0001_100), |
| Self(0b0_0001_101), |
| Self(0b0_0001_110), |
| Self(0b0_0001_111), // 0.029296875 |
| // m*2^-5 |
| Self(0b0_0010_000), // 0.03125 |
| Self(0b0_0010_001), |
| Self(0b0_0010_010), |
| Self(0b0_0010_011), |
| Self(0b0_0010_100), |
| Self(0b0_0010_101), |
| Self(0b0_0010_110), |
| Self(0b0_0010_111), // 0.05859375 |
| // m*2^-4 |
| Self(0b0_0011_000), // 0.0625 |
| Self(0b0_0011_001), |
| Self(0b0_0011_010), |
| Self(0b0_0011_011), |
| Self(0b0_0011_100), |
| Self(0b0_0011_101), |
| Self(0b0_0011_110), |
| Self(0b0_0011_111), // 0.1171875 |
| // m*2^-3 |
| Self(0b0_0100_000), // 0.125 |
| Self(0b0_0100_001), |
| Self(0b0_0100_010), |
| Self(0b0_0100_011), |
| Self(0b0_0100_100), |
| Self(0b0_0100_101), |
| Self(0b0_0100_110), |
| Self(0b0_0100_111), // 0.234375 |
| // m*2^-2 |
| Self(0b0_0101_000), // 0.25 |
| Self(0b0_0101_001), |
| Self(0b0_0101_010), |
| Self(0b0_0101_011), |
| Self(0b0_0101_100), |
| Self(0b0_0101_101), |
| Self(0b0_0101_110), |
| Self(0b0_0101_111), // 0.46875 |
| // m*2^-1 |
| Self(0b0_0110_000), // 0.5 |
| Self(0b0_0110_001), |
| Self(0b0_0110_010), |
| Self(0b0_0110_011), |
| Self(0b0_0110_100), |
| Self(0b0_0110_101), |
| Self(0b0_0110_110), |
| Self(0b0_0110_111), // 0.9375 |
| // m*2^0 |
| Self(0b0_0111_000), // 1 |
| Self(0b0_0111_001), |
| Self(0b0_0111_010), |
| Self(0b0_0111_011), |
| Self(0b0_0111_100), |
| Self(0b0_0111_101), |
| Self(0b0_0111_110), |
| Self(0b0_0111_111), // 1.875 |
| // m*2^1 |
| Self(0b0_1000_000), // 2 |
| Self(0b0_1000_001), |
| Self(0b0_1000_010), |
| Self(0b0_1000_011), |
| Self(0b0_1000_100), |
| Self(0b0_1000_101), |
| Self(0b0_1000_110), |
| Self(0b0_1000_111), // 3.75 |
| // m*2^2 |
| Self(0b0_1001_000), // 4 |
| Self(0b0_1001_001), |
| Self(0b0_1001_010), |
| Self(0b0_1001_011), |
| Self(0b0_1001_100), |
| Self(0b0_1001_101), |
| Self(0b0_1001_110), |
| Self(0b0_1001_111), // 7.5 |
| // m*2^3 |
| Self(0b0_1010_000), // 8 |
| Self(0b0_1010_001), |
| Self(0b0_1010_010), |
| Self(0b0_1010_011), |
| Self(0b0_1010_100), |
| Self(0b0_1010_101), |
| Self(0b0_1010_110), |
| Self(0b0_1010_111), // 15 |
| // m*2^4 |
| Self(0b0_1011_000), // 16 |
| Self(0b0_1011_001), |
| Self(0b0_1011_010), |
| Self(0b0_1011_011), |
| Self(0b0_1011_100), |
| Self(0b0_1011_101), |
| Self(0b0_1011_110), |
| Self(0b0_1011_111), // 30 |
| // m*2^5 |
| Self(0b0_1100_000), // 32 |
| Self(0b0_1100_001), |
| Self(0b0_1100_010), |
| Self(0b0_1100_011), |
| Self(0b0_1100_100), |
| Self(0b0_1100_101), |
| Self(0b0_1100_110), |
| Self(0b0_1100_111), // 60 |
| // m*2^6 |
| Self(0b0_1101_000), // 64 |
| Self(0b0_1101_001), |
| Self(0b0_1101_010), |
| Self(0b0_1101_011), |
| Self(0b0_1101_100), |
| Self(0b0_1101_101), |
| Self(0b0_1101_110), |
| Self(0b0_1101_111), // 120 |
| // m*2^7 |
| Self(0b0_1110_000), // 128 |
| Self(0b0_1110_001), |
| Self(0b0_1110_010), |
| Self(0b0_1110_011), |
| Self(0b0_1110_100), |
| Self(0b0_1110_101), |
| Self(0b0_1110_110), |
| Self(0b0_1110_111), // 240 |
| ]; |
| } |
| |
| impl ops::Add for f8 { |
| type Output = Self; |
| fn add(self, _rhs: Self) -> Self::Output { |
| unimplemented!() |
| } |
| } |
| |
| impl ops::Sub for f8 { |
| type Output = Self; |
| fn sub(self, _rhs: Self) -> Self::Output { |
| unimplemented!() |
| } |
| } |
| impl ops::Mul for f8 { |
| type Output = Self; |
| fn mul(self, _rhs: Self) -> Self::Output { |
| unimplemented!() |
| } |
| } |
| impl ops::Div for f8 { |
| type Output = Self; |
| fn div(self, _rhs: Self) -> Self::Output { |
| unimplemented!() |
| } |
| } |
| |
| impl ops::Neg for f8 { |
| type Output = Self; |
| fn neg(self) -> Self::Output { |
| Self(self.0 ^ Self::SIGN_MASK) |
| } |
| } |
| |
| impl ops::Rem for f8 { |
| type Output = Self; |
| fn rem(self, _rhs: Self) -> Self::Output { |
| unimplemented!() |
| } |
| } |
| |
| impl ops::AddAssign for f8 { |
| fn add_assign(&mut self, _rhs: Self) { |
| unimplemented!() |
| } |
| } |
| |
| impl ops::SubAssign for f8 { |
| fn sub_assign(&mut self, _rhs: Self) { |
| unimplemented!() |
| } |
| } |
| |
| impl ops::MulAssign for f8 { |
| fn mul_assign(&mut self, _rhs: Self) { |
| unimplemented!() |
| } |
| } |
| |
| impl cmp::PartialEq for f8 { |
| fn eq(&self, other: &Self) -> bool { |
| if self.is_nan() || other.is_nan() { |
| false |
| } else if self.abs().to_bits() | other.abs().to_bits() == 0 { |
| true |
| } else { |
| self.0 == other.0 |
| } |
| } |
| } |
| impl cmp::PartialOrd for f8 { |
| fn partial_cmp(&self, other: &Self) -> Option<Ordering> { |
| let inf_rep = f8::EXP_MASK; |
| |
| let a_abs = self.abs().to_bits(); |
| let b_abs = other.abs().to_bits(); |
| |
| // If either a or b is NaN, they are unordered. |
| if a_abs > inf_rep || b_abs > inf_rep { |
| return None; |
| } |
| |
| // If a and b are both zeros, they are equal. |
| if a_abs | b_abs == 0 { |
| return Some(Ordering::Equal); |
| } |
| |
| let a_srep = self.to_bits_signed(); |
| let b_srep = other.to_bits_signed(); |
| let res = a_srep.cmp(&b_srep); |
| |
| if a_srep & b_srep >= 0 { |
| // If at least one of a and b is positive, we get the same result comparing |
| // a and b as signed integers as we would with a fp_ting-point compare. |
| Some(res) |
| } else { |
| // Otherwise, both are negative, so we need to flip the sense of the |
| // comparison to get the correct result. |
| Some(res.reverse()) |
| } |
| } |
| } |
| impl fmt::Display for f8 { |
| fn fmt(&self, _f: &mut fmt::Formatter<'_>) -> fmt::Result { |
| unimplemented!() |
| } |
| } |
| |
| impl fmt::Debug for f8 { |
| fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { |
| fmt::Binary::fmt(self, f) |
| } |
| } |
| |
| impl fmt::Binary for f8 { |
| fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { |
| let v = self.0; |
| write!( |
| f, |
| "0b{:b}_{:04b}_{:03b}", |
| v >> 7, |
| (v & Self::EXP_MASK) >> Self::SIG_BITS, |
| v & Self::SIG_MASK |
| ) |
| } |
| } |
| |
| impl fmt::LowerHex for f8 { |
| fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { |
| self.0.fmt(f) |
| } |
| } |
| |
| pub const fn hf8(s: &str) -> f8 { |
| let Ok(bits) = libm::support::hex_float::parse_hex_exact(s, 8, 3) else { |
| panic!() |
| }; |
| f8(bits as u8) |
| } |
