float: Add tests for f16 conversions to and from decimal

Extend the existing tests for `f32` and `f64` with versions that include
`f16`'s new printing and parsing implementations.
Co-authored-by: Speedy_Lex <alex.ciocildau@gmail.com>

Author: tgross35

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

@@ -7,6 +7,20 @@ const FPATHS_F32: &[FPath<f32>] =
 constFPATHS_F64:&[FPath<f64>] =
 &[((0,0,false,false),Some(0.0)),((0,0,false,false),Some(0.0))];
 
+// FIXME(f16_f128): enable on all targets once possible.
+#[test]
+#[cfg(target_has_reliable_f16)]
+fncheck_fast_path_f16(){
+constFPATHS_F16:&[FPath<f16>] =
+&[((0,0,false,false),Some(0.0)),((0,0,false,false),Some(0.0))];
+for((exponent, mantissa, negative, many_digits), expected)inFPATHS_F16.iter().copied(){
+let dec = Decimal{ exponent, mantissa, negative, many_digits };
+let actual = dec.try_fast_path::<f16>();
+
+assert_eq!(actual, expected);
+}
+}
+
 #[test]
 fncheck_fast_path_f32(){
 for((exponent, mantissa, negative, many_digits), expected)inFPATHS_F32.iter().copied(){

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

@@ -1,5 +1,24 @@
 use core::num::dec2flt::float::RawFloat;
 
+// FIXME(f16_f128): enable on all targets once possible.
+#[test]
+#[cfg(target_has_reliable_f16)]
+fntest_f16_integer_decode(){
+assert_eq!(3.14159265359f16.integer_decode(),(1608, -9,1));
+assert_eq!((-8573.5918555f16).integer_decode(),(1072,3, -1));
+#[cfg(not(miri))]// miri doesn't have powf16
+assert_eq!(2f16.powf(14.0).integer_decode(),(1 << 10,4,1));
+assert_eq!(0f16.integer_decode(),(0, -25,1));
+assert_eq!((-0f16).integer_decode(),(0, -25, -1));
+assert_eq!(f16::INFINITY.integer_decode(),(1 << 10,6,1));
+assert_eq!(f16::NEG_INFINITY.integer_decode(),(1 << 10,6, -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),(1536,6));
+}
+
 #[test]
 fntest_f32_integer_decode(){
 assert_eq!(3.14159265359f32.integer_decode(),(13176795, -22,1));
@@ -34,6 +53,27 @@ fn test_f64_integer_decode() {
 
 /* Sanity checks of computed magic numbers */
 
+// FIXME(f16_f128): enable on all targets once possible.
+#[test]
+#[cfg(target_has_reliable_f16)]
+fntest_f16_consts(){
+assert_eq!(<f16 asRawFloat>::INFINITY, f16::INFINITY);
+assert_eq!(<f16 asRawFloat>::NEG_INFINITY, -f16::INFINITY);
+assert_eq!(<f16 asRawFloat>::NAN.to_bits(), f16::NAN.to_bits());
+assert_eq!(<f16 asRawFloat>::NEG_NAN.to_bits(),(-f16::NAN).to_bits());
+assert_eq!(<f16 asRawFloat>::SIG_BITS,10);
+assert_eq!(<f16 asRawFloat>::MIN_EXPONENT_ROUND_TO_EVEN, -22);
+assert_eq!(<f16 asRawFloat>::MAX_EXPONENT_ROUND_TO_EVEN,5);
+assert_eq!(<f16 asRawFloat>::MIN_EXPONENT_FAST_PATH, -4);
+assert_eq!(<f16 asRawFloat>::MAX_EXPONENT_FAST_PATH,4);
+assert_eq!(<f16 asRawFloat>::MAX_EXPONENT_DISGUISED_FAST_PATH,7);
+assert_eq!(<f16 asRawFloat>::EXP_MIN, -14);
+assert_eq!(<f16 asRawFloat>::EXP_SAT,0x1f);
+assert_eq!(<f16 asRawFloat>::SMALLEST_POWER_OF_TEN, -27);
+assert_eq!(<f16 asRawFloat>::LARGEST_POWER_OF_TEN,4);
+assert_eq!(<f16 asRawFloat>::MAX_MANTISSA_FAST_PATH,2048);
+}
+
 #[test]
 fntest_f32_consts(){
 assert_eq!(<f32asRawFloat>::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(target_has_reliable_f16)]
+fncompute_float16(q:i64,w:u64) -> (i32,u64){
+let fp = compute_float::<f16>(q, w);
+(fp.p_biased, fp.m)
+}
+
 fncompute_float32(q:i64,w:u64) -> (i32,u64){
 let fp = compute_float::<f32>(q, w);
 (fp.p_biased, fp.m)
@@ -11,23 +17,73 @@ 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(target_has_reliable_f16)]
+fncompute_float_f16_rounding(){
+// The maximum integer that cna be converted to a `f16` without lost precision.
+let val = 1 << 11;
+let scale = 10_u64.pow(10);
+
+// These test near-halfway cases for half-precision floats.
+assert_eq!(compute_float16(0, val),(26,0));
+assert_eq!(compute_float16(0, val + 1),(26,0));
+assert_eq!(compute_float16(0, val + 2),(26,1));
+assert_eq!(compute_float16(0, val + 3),(26,2));
+assert_eq!(compute_float16(0, val + 4),(26,2));
+
+// For the next power up, the two nearest representable numbers are twice as far apart.
+let val2 = 1 << 12;
+assert_eq!(compute_float16(0, val2),(27,0));
+assert_eq!(compute_float16(0, val2 + 2),(27,0));
+assert_eq!(compute_float16(0, val2 + 4),(27,1));
+assert_eq!(compute_float16(0, val2 + 6),(27,2));
+assert_eq!(compute_float16(0, val2 + 8),(27,2));
+
+// These are examples of the above tests, with digits from the exponent shifted
+// to the mantissa.
+assert_eq!(compute_float16(-10, val * scale),(26,0));
+assert_eq!(compute_float16(-10,(val + 1)* scale),(26,0));
+assert_eq!(compute_float16(-10,(val + 2)* scale),(26,1));
+// Let's check the lines to see if anything is different in table...
+assert_eq!(compute_float16(-10,(val + 3)* scale),(26,2));
+assert_eq!(compute_float16(-10,(val + 4)* scale),(26,2));
+
+// Check the rounding point between infinity and the next representable number down
+assert_eq!(compute_float16(4,6),(f16::INFINITE_POWER - 1,851));
+assert_eq!(compute_float16(4,7),(f16::INFINITE_POWER,0));// infinity
+assert_eq!(compute_float16(2,655),(f16::INFINITE_POWER - 1,1023));
+}
+
 #[test]
 fncompute_float_f32_rounding(){
+// the maximum integer that cna be converted to a `f32` without lost precision.
+let val = 1 << 24;
+let scale = 10_u64.pow(10);
+
 // These test near-halfway cases for single-precision floats.
-assert_eq!(compute_float32(0,16777216),(151,0));
-assert_eq!(compute_float32(0,16777217),(151,0));
-assert_eq!(compute_float32(0,16777218),(151,1));
-assert_eq!(compute_float32(0,16777219),(151,2));
-assert_eq!(compute_float32(0,16777220),(151,2));
-
-// These are examples of the above tests, with
-// digits from the exponent shifted to the mantissa.
-assert_eq!(compute_float32(-10,167772160000000000),(151,0));
-assert_eq!(compute_float32(-10,167772170000000000),(151,0));
-assert_eq!(compute_float32(-10,167772180000000000),(151,1));
+assert_eq!(compute_float32(0, val),(151,0));
+assert_eq!(compute_float32(0, val + 1),(151,0));
+assert_eq!(compute_float32(0, val + 2),(151,1));
+assert_eq!(compute_float32(0, val + 3),(151,2));
+assert_eq!(compute_float32(0, val + 4),(151,2));
+
+// For the next power up, the two nearest representable numbers are twice as far apart.
+let val2 = 1 << 25;
+assert_eq!(compute_float32(0, val2),(152,0));
+assert_eq!(compute_float32(0, val2 + 2),(152,0));
+assert_eq!(compute_float32(0, val2 + 4),(152,1));
+assert_eq!(compute_float32(0, val2 + 6),(152,2));
+assert_eq!(compute_float32(0, val2 + 8),(152,2));
+
+// These are examples of the above tests, with digits from the exponent shifted
+// to the mantissa.
+assert_eq!(compute_float32(-10, val * scale),(151,0));
+assert_eq!(compute_float32(-10,(val + 1)* scale),(151,0));
+assert_eq!(compute_float32(-10,(val + 2)* scale),(151,1));
 // Let's check the lines to see if anything is different in table...
-assert_eq!(compute_float32(-10,167772190000000000),(151,2));
-assert_eq!(compute_float32(-10,167772200000000000),(151,2));
+assert_eq!(compute_float32(-10,(val + 3)* scale),(151,2));
+assert_eq!(compute_float32(-10,(val + 4)* scale),(151,2));
 
 // Check the rounding point between infinity and the next representable number down
 assert_eq!(compute_float32(38,3),(f32::INFINITE_POWER - 1,6402534));
@@ -37,23 +93,38 @@ fn compute_float_f32_rounding() {
 
 #[test]
 fncompute_float_f64_rounding(){
+// The maximum integer that cna be converted to a `f64` without lost precision.
+let val = 1 << 53;
+let scale = 1000;
+
 // These test near-halfway cases for double-precision floats.
-assert_eq!(compute_float64(0,9007199254740992),(1076,0));
-assert_eq!(compute_float64(0,9007199254740993),(1076,0));
-assert_eq!(compute_float64(0,9007199254740994),(1076,1));
-assert_eq!(compute_float64(0,9007199254740995),(1076,2));
-assert_eq!(compute_float64(0,9007199254740996),(1076,2));
-assert_eq!(compute_float64(0,18014398509481984),(1077,0));
-assert_eq!(compute_float64(0,18014398509481986),(1077,0));
-assert_eq!(compute_float64(0,18014398509481988),(1077,1));
-assert_eq!(compute_float64(0,18014398509481990),(1077,2));
-assert_eq!(compute_float64(0,18014398509481992),(1077,2));
-
-// These are examples of the above tests, with
-// digits from the exponent shifted to the mantissa.
-assert_eq!(compute_float64(-3,9007199254740992000),(1076,0));
-assert_eq!(compute_float64(-3,9007199254740993000),(1076,0));
-assert_eq!(compute_float64(-3,9007199254740994000),(1076,1));
-assert_eq!(compute_float64(-3,9007199254740995000),(1076,2));
-assert_eq!(compute_float64(-3,9007199254740996000),(1076,2));
+assert_eq!(compute_float64(0, val),(1076,0));
+assert_eq!(compute_float64(0, val + 1),(1076,0));
+assert_eq!(compute_float64(0, val + 2),(1076,1));
+assert_eq!(compute_float64(0, val + 3),(1076,2));
+assert_eq!(compute_float64(0, val + 4),(1076,2));
+
+// For the next power up, the two nearest representable numbers are twice as far apart.
+let val2 = 1 << 54;
+assert_eq!(compute_float64(0, val2),(1077,0));
+assert_eq!(compute_float64(0, val2 + 2),(1077,0));
+assert_eq!(compute_float64(0, val2 + 4),(1077,1));
+assert_eq!(compute_float64(0, val2 + 6),(1077,2));
+assert_eq!(compute_float64(0, val2 + 8),(1077,2));
+
+// These are examples of the above tests, with digits from the exponent shifted
+// to the mantissa.
+assert_eq!(compute_float64(-3, val * scale),(1076,0));
+assert_eq!(compute_float64(-3,(val + 1)* scale),(1076,0));
+assert_eq!(compute_float64(-3,(val + 2)* scale),(1076,1));
+assert_eq!(compute_float64(-3,(val + 3)* scale),(1076,2));
+assert_eq!(compute_float64(-3,(val + 4)* scale),(1076,2));
+
+// Check the rounding point between infinity and the next representable number down
+assert_eq!(compute_float64(308,1),(f64::INFINITE_POWER - 1,506821272651936));
+assert_eq!(compute_float64(308,2),(f64::INFINITE_POWER,0));// infinity
+assert_eq!(
+ compute_float64(292,17976931348623157),
+(f64::INFINITE_POWER - 1,4503599627370495)
+);
 }

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

@@ -11,15 +11,23 @@ mod parse;
 // Requires a *polymorphic literal*, i.e., one that can serve as f64 as well as f32.
 macro_rules! test_literal {
 ($x: expr) => {{
+ #[cfg(target_has_reliable_f16)]
+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}");
+ #[cfg(target_has_reliable_f16)]
+ 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}");
+ #[cfg(target_has_reliable_f16)]
+ assert_eq!(neg_input.parse(),Ok(-x16),"failed f16 {neg_input}");
 }
 }};
 }
@@ -84,48 +92,87 @@ fn fast_path_correct() {
 test_literal!(1.448997445238699);
 }
 
+// FIXME(f16_f128): remove gates once tests work on all targets
+
 #[test]
 fnlonely_dot(){
+#[cfg(target_has_reliable_f16)]
+assert!(".".parse::<f16>().is_err());
 assert!(".".parse::<f32>().is_err());
 assert!(".".parse::<f64>().is_err());
 }
 
 #[test]
 fnexponentiated_dot(){
+#[cfg(target_has_reliable_f16)]
+assert!(".e0".parse::<f16>().is_err());
 assert!(".e0".parse::<f32>().is_err());
 assert!(".e0".parse::<f64>().is_err());
 }
 
 #[test]
 fnlonely_sign(){
-assert!("+".parse::<f32>().is_err());
-assert!("-".parse::<f64>().is_err());
+#[cfg(target_has_reliable_f16)]
+assert!("+".parse::<f16>().is_err());
+assert!("-".parse::<f32>().is_err());
+assert!("+".parse::<f64>().is_err());
 }
 
 #[test]
 fnwhitespace(){
+#[cfg(target_has_reliable_f16)]
+assert!("1.0 ".parse::<f16>().is_err());
 assert!(" 1.0".parse::<f32>().is_err());
 assert!("1.0 ".parse::<f64>().is_err());
 }
 
 #[test]
 fnnan(){
+#[cfg(target_has_reliable_f16)]
+{
+assert!("NaN".parse::<f16>().unwrap().is_nan());
+assert!("-NaN".parse::<f16>().unwrap().is_nan());
+}
+
 assert!("NaN".parse::<f32>().unwrap().is_nan());
+assert!("-NaN".parse::<f32>().unwrap().is_nan());
+
 assert!("NaN".parse::<f64>().unwrap().is_nan());
+assert!("-NaN".parse::<f64>().unwrap().is_nan());
 }
 
 #[test]
 fninf(){
-assert_eq!("inf".parse(),Ok(f64::INFINITY));
-assert_eq!("-inf".parse(),Ok(f64::NEG_INFINITY));
+#[cfg(target_has_reliable_f16)]
+{
+assert_eq!("inf".parse(),Ok(f16::INFINITY));
+assert_eq!("-inf".parse(),Ok(f16::NEG_INFINITY));
+}
+
 assert_eq!("inf".parse(),Ok(f32::INFINITY));
 assert_eq!("-inf".parse(),Ok(f32::NEG_INFINITY));
+
+assert_eq!("inf".parse(),Ok(f64::INFINITY));
+assert_eq!("-inf".parse(),Ok(f64::NEG_INFINITY));
 }
 
 #[test]
 fnmassive_exponent(){
+#[cfg(target_has_reliable_f16)]
+{
+let max = i16::MAX;
+assert_eq!(format!("1e{max}000").parse(),Ok(f16::INFINITY));
+assert_eq!(format!("1e-{max}000").parse(),Ok(0.0f16));
+assert_eq!(format!("1e{max}000").parse(),Ok(f16::INFINITY));
+}
+
+let max = i32::MAX;
+assert_eq!(format!("1e{max}000").parse(),Ok(f32::INFINITY));
+assert_eq!(format!("1e-{max}000").parse(),Ok(0.0f32));
+assert_eq!(format!("1e{max}000").parse(),Ok(f32::INFINITY));
+
 let max = i64::MAX;
 assert_eq!(format!("1e{max}000").parse(),Ok(f64::INFINITY));
-assert_eq!(format!("1e-{max}000").parse(),Ok(0.0));
+assert_eq!(format!("1e-{max}000").parse(),Ok(0.0f64));
 assert_eq!(format!("1e{max}000").parse(),Ok(f64::INFINITY));
 }

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

@@ -10,22 +10,41 @@ fn new_dec(e: i64, m: u64) -> Decimal {
 fnmissing_pieces(){
 let permutations = &[".e","1e","e4","e",".12e","321.e","32.12e+","12.32e-"];
 for&s in permutations {
+#[cfg(target_has_reliable_f16)]
+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]
 fninvalid_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 in0..s.len(){
 letmut input = String::new();
  input.push_str(s);
  input.insert(i, c);
-assert!(dec2flt::<f64>(&input) == error,"did not reject invalid {:?}", input);
+
+#[cfg(target_has_reliable_f16)]
+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:?}",
+);
 }
 }
 }