PR feedback

Author: rocurley

library/coretests/tests/floats/mod.rs

@@ -1,52 +1,40 @@
 use std::num::FpCategory as Fp;
 use std::ops::{Add, Div, Mul, Rem, Sub};
 
-/// Set the default tolerance for float comparison based on the type.
-trait Approx {
-    const LIM: Self;
-}
-
-impl Approx for f16 {
-    const LIM: Self = 1e-3;
-}
-impl Approx for f32 {
-    const LIM: Self = 1e-6;
-}
-impl Approx for f64 {
-    const LIM: Self = 1e-6;
-}
-impl Approx for f128 {
-    const LIM: Self = 1e-9;
-}
-
 trait TestableFloat {
-    const SMALL_NORMAL: Self;
-    const SUBNORMAL: Self;
+    /// Set the default tolerance for float comparison based on the type.
+    const APPROX: Self;
+    const MIN_POSITIVE_NORMAL: Self;
+    const MAX_SUBNORMAL: Self;
 }
 
 impl TestableFloat for f16 {
-    const SMALL_NORMAL: Self = 1e-4;
-    const SUBNORMAL: Self = 1e-5;
+    const APPROX: Self = 1e-3;
+    const MIN_POSITIVE_NORMAL: Self = Self::MIN_POSITIVE;
+    const MAX_SUBNORMAL: Self = Self::MIN_POSITIVE.next_down();
 }
 
 impl TestableFloat for f32 {
-    const SMALL_NORMAL: Self = 1e-37;
-    const SUBNORMAL: Self = 1e-38;
+    const APPROX: Self = 1e-6;
+    const MIN_POSITIVE_NORMAL: Self = Self::MIN_POSITIVE;
+    const MAX_SUBNORMAL: Self = Self::MIN_POSITIVE.next_down();
 }
 
 impl TestableFloat for f64 {
-    const SMALL_NORMAL: Self = 1e-307;
-    const SUBNORMAL: Self = 1e-308;
+    const APPROX: Self = 1e-6;
+    const MIN_POSITIVE_NORMAL: Self = Self::MIN_POSITIVE;
+    const MAX_SUBNORMAL: Self = Self::MIN_POSITIVE.next_down();
 }
 
 impl TestableFloat for f128 {
-    const SMALL_NORMAL: Self = 1e-4931;
-    const SUBNORMAL: Self = 1e-4932;
+    const APPROX: Self = 1e-9;
+    const MIN_POSITIVE_NORMAL: Self = Self::MIN_POSITIVE;
+    const MAX_SUBNORMAL: Self = Self::MIN_POSITIVE.next_down();
 }
 
 /// Determine the tolerance for values of the argument type.
-const fn lim_for_ty<T: Approx + Copy>(_x: T) -> T {
-    T::LIM
+const fn lim_for_ty<T: TestableFloat + Copy>(_x: T) -> T {
+    T::APPROX
 }
 
 // We have runtime ("rt") and const versions of these macros.
@@ -211,7 +199,7 @@ macro_rules! float_test {
             $( $( #[$const_meta] )+ )?
             mod const_ {
                 #[allow(unused)]
-                use super::{Approx, TestableFloat};
+                use super::TestableFloat;
                 #[allow(unused)]
                 use std::num::FpCategory as Fp;
                 #[allow(unused)]
@@ -373,16 +361,16 @@ float_test! {
         f128: #[cfg(any(miri, target_has_reliable_f128))],
     },
     test<Float> {
-    let neg_zero: Float = -0.0;
-    assert!(0.0 == neg_zero);
-    assert_biteq!(-0.0, neg_zero);
-    assert!(!neg_zero.is_infinite());
-    assert!(neg_zero.is_finite());
-    assert!(!neg_zero.is_sign_positive());
-    assert!(neg_zero.is_sign_negative());
-    assert!(!neg_zero.is_nan());
-    assert!(!neg_zero.is_normal());
-    assert!(matches!(neg_zero.classify(), Fp::Zero));
+        let neg_zero: Float = -0.0;
+        assert!(0.0 == neg_zero);
+        assert_biteq!(-0.0, neg_zero);
+        assert!(!neg_zero.is_infinite());
+        assert!(neg_zero.is_finite());
+        assert!(!neg_zero.is_sign_positive());
+        assert!(neg_zero.is_sign_negative());
+        assert!(!neg_zero.is_nan());
+        assert!(!neg_zero.is_normal());
+        assert!(matches!(neg_zero.classify(), Fp::Zero));
     }
 }
 
@@ -487,8 +475,8 @@ float_test! {
         assert!(!zero.is_normal());
         assert!(!neg_zero.is_normal());
         assert!(one.is_normal());
-        assert!(Float::SMALL_NORMAL.is_normal());
-        assert!(!Float::SUBNORMAL.is_normal());
+        assert!(Float::MIN_POSITIVE_NORMAL.is_normal());
+        assert!(!Float::MAX_SUBNORMAL.is_normal());
     }
 }
 
@@ -509,8 +497,8 @@ float_test! {
         assert!(matches!(zero.classify(), Fp::Zero));
         assert!(matches!(neg_zero.classify(), Fp::Zero));
         assert!(matches!(1f32.classify(), Fp::Normal));
-        assert!(matches!(Float::SMALL_NORMAL.classify(), Fp::Normal));
-        assert!(matches!(Float::SUBNORMAL.classify(), Fp::Subnormal));
+        assert!(matches!(Float::MIN_POSITIVE_NORMAL.classify(), Fp::Normal));
+        assert!(matches!(Float::MAX_SUBNORMAL.classify(), Fp::Subnormal));
     }
 }