Check for rounding at the centerpoint

Author: tgross35

src/etc/test-float-parse/README.md

@@ -3,6 +3,10 @@
 These are tests designed to test decimal to float conversions (`dec2flt`) used
 by the standard library.
 
+It consistes of a collection of test generators that each generate a set of
+patterns intended to test a specific property. In addition, there are exhaustive
+tests (for <= `f32`) and fuzzers (for anything that can't be run exhaustively).
+
 The generators work as follows:
 
 - Each generator is a struct that lives somewhere in the `gen` module. Usually
@@ -15,13 +19,14 @@ The generators work as follows:
 
   The split between context generation and string construction is so that we can
   reuse string allocations.
-- Each generator gets registered once for each float type. All of these
-  generators then get iterated, and each test case checked against the float
-  type's parse implementation.
+- Each generator gets registered once for each float type. Each of these
+  generators then get their iterator called, and each test case checked against
+  the float type's parse implementation.
 
-Some tests produce decimal strings, others generate bit patterns that need to
-convert to the float type before printing to a string. For these, float to
-decimal (`flt2dec`) conversions get tested, if unintentionally.
+Some generators produce decimal strings, others create bit patterns that need to
+be bitcasted to the float type, which then uses its `Display` implementation to
+write to a string. For these, float to decimal (`flt2dec`) conversions also get
+tested, if unintentionally.
 
 For each test case, the following is done:
 
@@ -36,6 +41,7 @@ For each test case, the following is done:
 - For real nonzero numbers, the parsed float is converted into a rational using
   `significand * 2^exponent`. It is then checked against the actual rational
   value, and verified to be within half a bit's precision of the parsed value.
+  Also it is checked that ties round to even.
 
 This is all highly parallelized with `rayon`; test generators can run in
 parallel, and their tests get chunked and run in parallel.

src/etc/test-float-parse/src/lib.rs

@@ -39,7 +39,7 @@ pub const DEFAULT_FUZZ_COUNT: u64 = u32::MAX as u64;
 const HUGE_TEST_CUTOFF: u64 = 5_000_000;
 
 /// Seed for tests that use a deterministic RNG.
-pub const SEED: [u8; 32] = *b"3.141592653589793238462643383279";
+const SEED: [u8; 32] = *b"3.141592653589793238462643383279";
 
 /// Global configuration
 #[derive(Debug)]
@@ -236,9 +236,12 @@ impl Msg {
                 pb.set_message(format! {"{failures}"});
                 pb.set_position(executed);
             }
-            Update::Failure { fail, input } => {
-                mp.println(format!("Failure in '{}': {fail}. parsing '{input}'", test.name))
-                    .unwrap();
+            Update::Failure { fail, input, float_res } => {
+                mp.println(format!(
+                    "Failure in '{}': {fail}. parsing '{input}'. Parsed as: {float_res}",
+                    test.name
+                ))
+                .unwrap();
             }
             Update::Completed(c) => {
                 test.finalize_pb(&c);
@@ -265,11 +268,17 @@ impl Msg {
 enum Update {
     /// Starting a new test runner.
     Started,
-    /// Completed a out of b tests
+    /// Completed a out of b tests.
     Progress { executed: u64, failures: u64 },
-    /// Received a failed test
-    Failure { fail: CheckFailure, input: Box<str> },
-    /// Exited with an unexpected condition
+    /// Received a failed test.
+    Failure {
+        fail: CheckFailure,
+        /// String for which parsing was attempted.
+        input: Box<str>,
+        /// The parsed & decomposed `FloatRes`, aleady stringified so we don't need generics here.
+        float_res: Box<str>,
+    },
+    /// Exited with an unexpected condition.
     Completed(Completed),
 }
 
@@ -296,6 +305,9 @@ enum CheckFailure {
         error_float: Option<f64>,
         /// Error as a rational string (since it can't always be represented as a float).
         error_str: Box<str>,
+        /// True if the error was caused by not rounding to even at the midpoint between
+        /// two representable values.
+        incorrect_midpoint_rounding: bool,
     },
 }
 
@@ -315,8 +327,17 @@ impl fmt::Display for CheckFailure {
             CheckFailure::ExpectedNan => write!(f, "expected a NaN but did not get it"),
             CheckFailure::ExpectedInf => write!(f, "expected +inf but did not get it"),
             CheckFailure::ExpectedNegInf => write!(f, "expected -inf but did not get it"),
-            CheckFailure::InvalidReal { error_float, error_str } => {
-                write!(f, "real number did not parse correctly; error:{error_str}")?;
+            CheckFailure::InvalidReal { error_float, error_str, incorrect_midpoint_rounding } => {
+                if *incorrect_midpoint_rounding {
+                    write!(
+                        f,
+                        "midpoint between two representable values did not correctly \
+                        round to even; error: {error_str}"
+                    )?;
+                } else {
+                    write!(f, "real number did not parse correctly; error: {error_str}")?;
+                }
+
                 if let Some(float) = error_float {
                     write!(f, " ({float})")?;
                 }

src/etc/test-float-parse/src/validate.rs

@@ -106,7 +106,7 @@ pub fn validate<F: Float>(input: &str, allow_nan: bool) -> Result<(), Update> {
 
 /// The result of parsing a string to a float type.
 #[derive(Clone, Copy, Debug, PartialEq)]
-enum FloatRes<F: Float> {
+pub enum FloatRes<F: Float> {
     Inf,
     NegInf,
     Zero,
@@ -173,7 +173,11 @@ impl<F: Float> FloatRes<F> {
             (Rational::Finite(r), FloatRes::Real { sig, exp }) => Self::validate_real(r, sig, exp),
         };
 
-        res.map_err(|fail| Update::Failure { fail, input: input.into() })
+        res.map_err(|fail| Update::Failure {
+            fail,
+            input: input.into(),
+            float_res: format!("{self:?}").into(),
+        })
     }
 
     /// Check that `sig * 2^exp` is the same as `rational`, within the float's error margin.
@@ -188,20 +192,32 @@ impl<F: Float> FloatRes<F> {
 
         // Rational from the parsed value, `sig * 2^exp`
         let parsed_rational = two_exp * sig.to_bigint().unwrap();
-        let error = (parsed_rational - rational).abs();
+        let error = (parsed_rational - &rational).abs();
 
         // Determine acceptable error at this exponent, which is halfway between this value
         // (`sig * 2^exp`) and the next value up (`(sig+1) * 2^exp`).
         let half_ulp = consts.half_ulp.get(&exp).unwrap();
 
-        // Our real value is allowed to be exactly at the midpoint between two values, or closer
-        // to the real value.
-        // todo: this currently allows rounding either up or down at the midpoint.
-        // Is this correct?
-        if &error <= half_ulp {
+        // If we are within one error value (but not equal) then we rounded correctly.
+        if &error < half_ulp {
             return Ok(());
         }
 
+        // For values where we are exactly between two representable values, meaning that the error
+        // is exactly one half of the precision at that exponent, we need to round to an even
+        // binary value (i.e. mantissa ends in 0).
+        let incorrect_midpoint_rounding = if &error == half_ulp {
+            if sig & F::SInt::ONE == F::SInt::ZERO {
+                return Ok(());
+            }
+
+            // We rounded to odd rather than even; failing based on midpoint rounding.
+            true
+        } else {
+            // We are out of spec for some other reason.
+            false
+        };
+
         let one_ulp = consts.half_ulp.get(&(exp + 1)).unwrap();
         assert_eq!(one_ulp, &(half_ulp * &consts.two), "ULP values are incorrect");
 
@@ -210,6 +226,7 @@ impl<F: Float> FloatRes<F> {
         Err(CheckFailure::InvalidReal {
             error_float: relative_error.to_f64(),
             error_str: relative_error.to_string().into(),
+            incorrect_midpoint_rounding,
         })
     }