make the default float comparison tolerance type-dependent

Author: RalfJung

library/coretests/tests/floats/mod.rs

@@ -1,9 +1,32 @@
 use std::fmt;
 use std::ops::{Add, Div, Mul, Rem, Sub};
 
-/// Verify that floats are within a tolerance of each other, 1.0e-6 by default.
+/// 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;
+}
+
+/// Determine the tolerance for values of the argument type.
+const fn lim_for_ty<T: Approx + Copy>(_x: T) -> T {
+    T::LIM
+}
+
+/// Verify that floats are within a tolerance of each other.
 macro_rules! assert_approx_eq_ {
-    ($a:expr, $b:expr) => {{ assert_approx_eq!($a, $b, 1.0e-6) }};
+    ($a:expr, $b:expr) => {{ assert_approx_eq!($a, $b, $crate::floats::lim_for_ty($a)) }};
     ($a:expr, $b:expr, $lim:expr) => {{
         let (a, b) = (&$a, &$b);
         let diff = (*a - *b).abs();
@@ -94,7 +117,7 @@ mod const_asserts {
     pub(crate) use assert_biteq;
 
     macro_rules! assert_approx_eq {
-        ($a:expr, $b:expr) => {{ assert_approx_eq!($a, $b, 1.0e-6) }};
+        ($a:expr, $b:expr) => {{ assert_approx_eq!($a, $b, $crate::floats::lim_for_ty($a)) }};
         ($a:expr, $b:expr, $lim:expr) => {{
             let (a, b) = (&$a, &$b);
             let diff = (*a - *b).abs();
@@ -170,6 +193,8 @@ macro_rules! float_test {
 
             $( $( #[$const_meta] )+ )?
             mod const_ {
+                #[allow(unused)]
+                use super::Approx;
                 #[allow(unused)]
                 use $crate::floats::const_asserts::{assert_eq, assert_biteq, assert_approx_eq};
 
@@ -650,15 +675,15 @@ float_test! {
     },
     test<Float> {
         assert_biteq!((1.0 as Float).fract(), 0.0);
-        assert_approx_eq!((1.3 as Float).fract(), 0.3, 1e-3); // rounding differs between float types
+        assert_approx_eq!((1.3 as Float).fract(), 0.3); // rounding differs between float types
         assert_biteq!((1.5 as Float).fract(), 0.5);
         assert_approx_eq!((1.7 as Float).fract(), 0.7);
         assert_biteq!((0.5 as Float).fract(), 0.5);
         assert_biteq!((0.0 as Float).fract(), 0.0);
         assert_biteq!((-0.0 as Float).fract(), 0.0);
         assert_biteq!((-0.5 as Float).fract(), -0.5);
         assert_biteq!((-1.0 as Float).fract(), 0.0);
-        assert_approx_eq!((-1.3 as Float).fract(), -0.3, 1e-3); // rounding differs between float types
+        assert_approx_eq!((-1.3 as Float).fract(), -0.3); // rounding differs between float types
         assert_biteq!((-1.5 as Float).fract(), -0.5);
         assert_approx_eq!((-1.7 as Float).fract(), -0.7);
         assert_eq!(Float::MAX.fract(), 0.0);