float: Add f16 parsing and printing

Author: tgross35

library/core/src/fmt/float.rs

@@ -20,6 +20,7 @@ macro_rules! impl_general_format {
     }
 }
 
+impl_general_format! { f16 }
 impl_general_format! { f32 f64 }
 
 // Don't inline this so callers don't use the stack space this function
@@ -229,15 +230,7 @@ macro_rules! floating {
     };
 }
 
-floating! { f32 f64 }
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl Debug for f16 {
-    #[inline]
-    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
-        write!(f, "{:#06x}", self.to_bits())
-    }
-}
+floating! { f16 f32 f64 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
 impl Debug for f128 {

library/core/src/num/dec2flt/float.rs

@@ -45,7 +45,7 @@ macro_rules! int {
     }
 }
 
-int!(u32, u64);
+int!(u16, u32, u64);
 
 /// A helper trait to avoid duplicating basically all the conversion code for IEEE floats.
 ///
@@ -213,6 +213,49 @@ const fn pow2_to_pow10(a: i64) -> i64 {
     res as i64
 }
 
+impl RawFloat for f16 {
+    type Int = u16;
+
+    const INFINITY: Self = Self::INFINITY;
+    const NEG_INFINITY: Self = Self::NEG_INFINITY;
+    const NAN: Self = Self::NAN;
+    const NEG_NAN: Self = -Self::NAN;
+
+    const BITS: u32 = 16;
+    const SIG_TOTAL_BITS: u32 = Self::MANTISSA_DIGITS;
+    const EXP_MASK: Self::Int = Self::EXP_MASK;
+    const SIG_MASK: Self::Int = Self::MAN_MASK;
+
+    const MIN_EXPONENT_ROUND_TO_EVEN: i32 = -22;
+    const MAX_EXPONENT_ROUND_TO_EVEN: i32 = 5;
+    const SMALLEST_POWER_OF_TEN: i32 = -27;
+
+    #[inline]
+    fn from_u64(v: u64) -> Self {
+        debug_assert!(v <= Self::MAX_MANTISSA_FAST_PATH);
+        v as _
+    }
+
+    #[inline]
+    fn from_u64_bits(v: u64) -> Self {
+        Self::from_bits((v & 0xFFFF) as u16)
+    }
+
+    fn pow10_fast_path(exponent: usize) -> Self {
+        #[allow(clippy::use_self)]
+        const TABLE: [f16; 8] = [1e0, 1e1, 1e2, 1e3, 1e4, 0.0, 0.0, 0.];
+        TABLE[exponent & 7]
+    }
+
+    fn to_bits(self) -> Self::Int {
+        self.to_bits()
+    }
+
+    fn classify(self) -> FpCategory {
+        self.classify()
+    }
+}
+
 impl RawFloat for f32 {
     type Int = u32;
 

library/core/src/num/dec2flt/mod.rs

@@ -171,6 +171,8 @@ macro_rules! from_str_float_impl {
         }
     };
 }
+
+from_str_float_impl!(f16);
 from_str_float_impl!(f32);
 from_str_float_impl!(f64);
 

library/core/src/num/flt2dec/decoder.rs

@@ -45,6 +45,12 @@ pub trait DecodableFloat: RawFloat + Copy {
     fn min_pos_norm_value() -> Self;
 }
 
+impl DecodableFloat for f16 {
+    fn min_pos_norm_value() -> Self {
+        f16::MIN_POSITIVE
+    }
+}
+
 impl DecodableFloat for f32 {
     fn min_pos_norm_value() -> Self {
         f32::MIN_POSITIVE

library/coretests/tests/lib.rs

@@ -30,6 +30,7 @@
 #![feature(exact_size_is_empty)]
 #![feature(extend_one)]
 #![feature(extern_types)]
+#![feature(f16)]
 #![feature(float_minimum_maximum)]
 #![feature(flt2dec)]
 #![feature(fmt_internals)]

library/coretests/tests/num/dec2flt/float.rs

@@ -1,5 +1,23 @@
 use core::num::dec2flt::float::RawFloat;
 
+// FIXME(f16_f128): enable on all targets once possible.
+// #[test]
+// #[cfg(any(target_arch = "x86", all(target_arch = "aarch64", target_feature = "neon")))]
+// fn test_f32_integer_decode() {
+//     assert_eq!(3.14159265359f16.integer_decode(), (13176795, -22, 1));
+//     assert_eq!((-8573.5918555f16).integer_decode(), (8779358, -10, -1));
+//     assert_eq!(2f16.powf(100.0).integer_decode(), (8388608, 77, 1));
+//     assert_eq!(0f16.integer_decode(), (0, -150, 1));
+//     assert_eq!((-0f16).integer_decode(), (0, -150, -1));
+//     assert_eq!(f16::INFINITY.integer_decode(), (8388608, 105, 1));
+//     assert_eq!(f16::NEG_INFINITY.integer_decode(), (8388608, 105, -1));
+
+//     // Ignore the "sign" (quiet / signalling flag) of NAN.
+//     // It can vary between runtime operations and LLVM folding.
+//     let (nan_m, nan_p, _nan_s) = f16::NAN.integer_decode();
+//     assert_eq!((nan_m, nan_p), (12582912, 105));
+// }
+
 #[test]
 fn test_f32_integer_decode() {
     assert_eq!(3.14159265359f32.integer_decode(), (13176795, -22, 1));
@@ -34,6 +52,27 @@ fn test_f64_integer_decode() {
 
 /* Sanity checks of computed magic numbers */
 
+// FIXME(f16_f128): enable on all targets once possible.
+#[test]
+#[cfg(any(target_arch = "x86", all(target_arch = "aarch64", target_feature = "neon")))]
+fn test_f16_consts() {
+    assert_eq!(<f16 as RawFloat>::INFINITY, f16::INFINITY);
+    assert_eq!(<f16 as RawFloat>::NEG_INFINITY, -f16::INFINITY);
+    assert_eq!(<f16 as RawFloat>::NAN.to_bits(), f16::NAN.to_bits());
+    assert_eq!(<f16 as RawFloat>::NEG_NAN.to_bits(), (-f16::NAN).to_bits());
+    assert_eq!(<f16 as RawFloat>::SIG_BITS, 10);
+    assert_eq!(<f16 as RawFloat>::MIN_EXPONENT_ROUND_TO_EVEN, -22);
+    assert_eq!(<f16 as RawFloat>::MAX_EXPONENT_ROUND_TO_EVEN, 5);
+    assert_eq!(<f16 as RawFloat>::MIN_EXPONENT_FAST_PATH, -4);
+    assert_eq!(<f16 as RawFloat>::MAX_EXPONENT_FAST_PATH, 4);
+    assert_eq!(<f16 as RawFloat>::MAX_EXPONENT_DISGUISED_FAST_PATH, 7);
+    assert_eq!(<f16 as RawFloat>::EXP_MIN, -14);
+    assert_eq!(<f16 as RawFloat>::EXP_SAT, 0x1f);
+    assert_eq!(<f16 as RawFloat>::SMALLEST_POWER_OF_TEN, -27);
+    assert_eq!(<f16 as RawFloat>::LARGEST_POWER_OF_TEN, 4);
+    assert_eq!(<f16 as RawFloat>::MAX_MANTISSA_FAST_PATH, 2048);
+}
+
 #[test]
 fn test_f32_consts() {
     assert_eq!(<f32 as RawFloat>::INFINITY, f32::INFINITY);

library/coretests/tests/num/dec2flt/lemire.rs

@@ -1,6 +1,12 @@
 use core::num::dec2flt::float::RawFloat;
 use core::num::dec2flt::lemire::compute_float;
 
+#[cfg(any(target_arch = "x86", all(target_arch = "aarch64", target_feature = "neon")))]
+fn compute_float16(q: i64, w: u64) -> (i32, u64) {
+    let fp = compute_float::<f16>(q, w);
+    (fp.p_biased, fp.m)
+}
+
 fn compute_float32(q: i64, w: u64) -> (i32, u64) {
     let fp = compute_float::<f32>(q, w);
     (fp.p_biased, fp.m)
@@ -11,6 +17,27 @@ fn compute_float64(q: i64, w: u64) -> (i32, u64) {
     (fp.p_biased, fp.m)
 }
 
+// FIXME(f16_f128): enable on all targets once possible.
+#[test]
+#[cfg(any(target_arch = "x86", all(target_arch = "aarch64", target_feature = "neon")))]
+fn compute_float_f16_rounding() {
+    // These test near-halfway cases for single-precision floats.
+    assert_eq!(compute_float16(0, 16777216), (151, 0));
+    assert_eq!(compute_float16(0, 16777217), (151, 0));
+    assert_eq!(compute_float16(0, 16777218), (151, 1));
+    assert_eq!(compute_float16(0, 16777219), (151, 2));
+    assert_eq!(compute_float16(0, 16777220), (151, 2));
+
+    // These are examples of the above tests, with
+    // digits from the exponent shifted to the mantissa.
+    assert_eq!(compute_float16(-10, 167772160000000000), (151, 0));
+    assert_eq!(compute_float16(-10, 167772170000000000), (151, 0));
+    assert_eq!(compute_float16(-10, 167772180000000000), (151, 1));
+    // Let's check the lines to see if anything is different in table...
+    assert_eq!(compute_float16(-10, 167772190000000000), (151, 2));
+    assert_eq!(compute_float16(-10, 167772200000000000), (151, 2));
+}
+
 #[test]
 fn compute_float_f32_rounding() {
     // These test near-halfway cases for single-precision floats.

library/coretests/tests/num/dec2flt/mod.rs

@@ -11,19 +11,92 @@ mod parse;
 // Requires a *polymorphic literal*, i.e., one that can serve as f64 as well as f32.
 macro_rules! test_literal {
     ($x: expr) => {{
+        let x16: f16 = $x;
         let x32: f32 = $x;
         let x64: f64 = $x;
         let inputs = &[stringify!($x).into(), format!("{:?}", x64), format!("{:e}", x64)];
+
         for input in inputs {
-            assert_eq!(input.parse(), Ok(x64));
-            assert_eq!(input.parse(), Ok(x32));
+            assert_eq!(input.parse(), Ok(x64), "failed f64 {input}");
+            assert_eq!(input.parse(), Ok(x32), "failed f32 {input}");
+            assert_eq!(input.parse(), Ok(x16), "failed f16 {input}");
+
             let neg_input = format!("-{input}");
-            assert_eq!(neg_input.parse(), Ok(-x64));
-            assert_eq!(neg_input.parse(), Ok(-x32));
+            assert_eq!(neg_input.parse(), Ok(-x64), "failed f64 {neg_input}");
+            assert_eq!(neg_input.parse(), Ok(-x32), "failed f32 {neg_input}");
+            assert_eq!(neg_input.parse(), Ok(-x16), "failed f16 {neg_input}");
         }
     }};
 }
 
+// #[test]
+// fn foo() {
+//     use core::num::dec2flt::float::RawFloat;
+//     use core::num::dec2flt::parse::parse_number;
+
+//     fn x<F: RawFloat + std::fmt::Display>(r: &str) {
+//         let mut s = r.as_bytes();
+//         let c = s[0];
+//         let negative = c == b'-';
+//         if c == b'-' || c == b'+' {
+//             s = &s[1..];
+//         }
+//         let mut num = parse_number(s).unwrap();
+//         num.negative = negative;
+//         if let Some(value) = num.try_fast_path::<F>() {
+//             // return Ok(value);
+//             println!("fast path {value}");
+//             return;
+//         }
+
+//         let q = num.exponent;
+//         let w = num.mantissa;
+
+//         println!(
+//             "float {r} {q} {w} {q:#066b} {w:#066b} sm10 {} lg10 {} ty {} chk {}",
+//             F::SMALLEST_POWER_OF_TEN,
+//             F::LARGEST_POWER_OF_TEN,
+//             std::any::type_name::<F>(),
+//             if w == 0 || q < F::SMALLEST_POWER_OF_TEN as i64 {
+//                 "lt small 10"
+//             } else if q > F::LARGEST_POWER_OF_TEN as i64 {
+//                 "gt big 10"
+//             } else {
+//                 ""
+//             }
+//         );
+//     }
+
+//     // test_literal2!(1e-20);
+//     // test_literal2!(1e-30);
+//     // test_literal2!(1e-40);
+//     // test_literal2!(1e-50);
+//     // test_literal2!(1e-60);
+//     // test_literal2!(1e-63);
+//     // test_literal2!(1e-64);
+//     // test_literal2!(1e-65);
+//     // test_literal2!(1e-66);
+//     // test_literal2!(1e-70);
+//     // test_literal2!(1e-70);
+//     // test_literal2!(1e-70);
+//     // test_literal2!(1e-70);
+//     // test_literal2!(2.225073858507201136057409796709131975934819546351645648023426109724822222021076945516529523908135087914149158913039621106870086438694594645527657207407820621743379988141063267329253552286881372149012981122451451889849057222307285255133155755015914397476397983411801999323962548289017107081850690630666655994938275772572015763062690663332647565300009245888316433037779791869612049497390377829704905051080609940730262937128958950003583799967207254304360284078895771796150945516748243471030702609144621572289880258182545180325707018860872113128079512233426288368622321503775666622503982534335974568884423900265498198385487948292206894721689831099698365846814022854243330660339850886445804001034933970427567186443383770486037861622771738545623065874679014086723327636718749999999999999999999999999999999999999e-308);
+//     // test_literal2!(1.175494140627517859246175898662808184331245864732796240031385942718174675986064769972472277004271745681762695312500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-38);
+//     // panic!();
+// }
+
+// #[test]
+// fn foobar() {
+//     use core::num::dec2flt::float::RawFloat;
+//     panic!(
+//         "{} {} {} {}",
+//         <f32 as RawFloat>::LARGEST_POWER_OF_TEN,
+//         <f32 as RawFloat>::SMALLEST_POWER_OF_TEN,
+//         <f64 as RawFloat>::LARGEST_POWER_OF_TEN,
+//         <f64 as RawFloat>::SMALLEST_POWER_OF_TEN,
+//     )
+// }
+
 #[test]
 fn ordinary() {
     test_literal!(1.0);

library/coretests/tests/num/dec2flt/parse.rs

@@ -10,22 +10,39 @@ fn new_dec(e: i64, m: u64) -> Decimal {
 fn missing_pieces() {
     let permutations = &[".e", "1e", "e4", "e", ".12e", "321.e", "32.12e+", "12.32e-"];
     for &s in permutations {
+        assert_eq!(dec2flt::<f16>(s), Err(pfe_invalid()));
+        assert_eq!(dec2flt::<f32>(s), Err(pfe_invalid()));
         assert_eq!(dec2flt::<f64>(s), Err(pfe_invalid()));
     }
 }
 
 #[test]
 fn invalid_chars() {
     let invalid = "r,?<j";
-    let error = Err(pfe_invalid());
     let valid_strings = &["123", "666.", ".1", "5e1", "7e-3", "0.0e+1"];
+
     for c in invalid.chars() {
         for s in valid_strings {
             for i in 0..s.len() {
                 let mut input = String::new();
                 input.push_str(s);
                 input.insert(i, c);
-                assert!(dec2flt::<f64>(&input) == error, "did not reject invalid {:?}", input);
+
+                assert_eq!(
+                    dec2flt::<f16>(&input),
+                    Err(pfe_invalid()),
+                    "f16 did not reject invalid {input:?}",
+                );
+                assert_eq!(
+                    dec2flt::<f32>(&input),
+                    Err(pfe_invalid()),
+                    "f32 did not reject invalid {input:?}",
+                );
+                assert_eq!(
+                    dec2flt::<f64>(&input),
+                    Err(pfe_invalid()),
+                    "f64 did not reject invalid {input:?}",
+                );
             }
         }
     }

library/coretests/tests/num/dec2flt/slow.rs

@@ -0,0 +1 @@
+