make test generic over f32/f64

Author: RustyYato

library/core/src/num/f32.rs

@@ -1026,6 +1026,7 @@ impl f32 {
                 // whitelist the faster implementation to targets that have known good 64-bit float
                 // implementations. Falling back to the branchy code on targets that don't have
                 // 64-bit hardware floats or buggy implementations.
+                // see: https://github.com/rust-lang/rust/pull/121062#issuecomment-2123408114
                 ((f64::from(self) + f64::from(other)) / 2.0) as f32
             } else {
                 const LO: f32 = f32::MIN_POSITIVE * 2.;

library/core/tests/num/mod.rs

@@ -719,7 +719,7 @@ assume_usize_width! {
 }
 
 macro_rules! test_float {
-    ($modname: ident, $fty: ty, $inf: expr, $neginf: expr, $nan: expr, $min: expr, $max: expr, $min_pos: expr) => {
+    ($modname: ident, $fty: ty, $inf: expr, $neginf: expr, $nan: expr, $min: expr, $max: expr, $min_pos: expr, $max_exp:expr) => {
         mod $modname {
             #[test]
             fn min() {
@@ -874,11 +874,21 @@ macro_rules! test_float {
                 // test if large differences in magnitude are still correctly computed.
                 // NOTE: that because of how small x and y are, x + y can never overflow
                 // so (x + y) / 2.0 is always correct
-                for i in 64..128 {
+                // in particular, `2.pow(i)` will  never be at the max exponent, so it could
+                // be safely doubled, while j is significantly smaller.
+                for i in $max_exp.saturating_sub(64)..$max_exp {
                     for j in 0..64u8 {
-                        let x = (2.0f32.powi(i) + f32::from(j)) / 2.0;
-                        let y = 2.0f32.powi(i).midpoint(f32::from(j));
-                        assert_eq!(x, y);
+                        let large = <$fty>::from(2.0f32).powi(i);
+                        // a much smaller number, such that there is no chance of overflow to test
+                        // potential double rounding in midpoint's implementation.
+                        let small = <$fty>::from(2.0f32).powi($max_exp - 1)
+                            * <$fty>::EPSILON
+                            * <$fty>::from(j);
+
+                        let naive = (large + small) / 2.0;
+                        let midpoint = large.midpoint(small);
+
+                        assert_eq!(naive, midpoint);
                     }
                 }
             }
@@ -913,7 +923,8 @@ test_float!(
     f32::NAN,
     f32::MIN,
     f32::MAX,
-    f32::MIN_POSITIVE
+    f32::MIN_POSITIVE,
+    f32::MAX_EXP
 );
 test_float!(
     f64,
@@ -923,5 +934,6 @@ test_float!(
     f64::NAN,
     f64::MIN,
     f64::MAX,
-    f64::MIN_POSITIVE
+    f64::MIN_POSITIVE,
+    f64::MAX_EXP
 );