Assert exact equality in non-MIRI configs

Author: calder

Diff for: library/std/tests/floats/f128.rs

@@ -989,11 +989,18 @@ fn test_algebraic() {
     let a: f128 = 123.0;
     let b: f128 = 456.0;
 
-    assert_approx_eq!(a.algebraic_add(b), a + b);
-    assert_approx_eq!(a.algebraic_sub(b), a - b);
-    assert_approx_eq!(a.algebraic_mul(b), a * b);
-    assert_approx_eq!(a.algebraic_div(b), a / b);
-    assert_approx_eq!(a.algebraic_rem(b), a % b);
+    // Check that individual operations match their primitive counterparts.
+    //
+    // This is a check of current implementations and does NOT imply any form of
+    // guarantee about future behavior. The compiler reserves the right to make
+    // these operations inexact matches in the future.
+    let eps = if cfg!(miri) { 1e-6 } else { 0.0 };
+
+    assert_approx_eq!(a.algebraic_add(b), a + b, eps);
+    assert_approx_eq!(a.algebraic_sub(b), a - b, eps);
+    assert_approx_eq!(a.algebraic_mul(b), a * b, eps);
+    assert_approx_eq!(a.algebraic_div(b), a / b, eps);
+    assert_approx_eq!(a.algebraic_rem(b), a % b, eps);
 }
 
 #[test]

Diff for: library/std/tests/floats/f16.rs

@@ -959,11 +959,20 @@ fn test_algebraic() {
     let a: f16 = 123.0;
     let b: f16 = 456.0;
 
-    assert_approx_eq!(a.algebraic_add(b), a + b, 1e1);
-    assert_approx_eq!(a.algebraic_sub(b), a - b, 1e1);
-    assert_approx_eq!(a.algebraic_mul(b), a * b, 1e3);
-    assert_approx_eq!(a.algebraic_div(b), a / b, 1e0);
-    assert_approx_eq!(a.algebraic_rem(b), a % b, 1e0);
+    // Check that individual operations match their primitive counterparts.
+    //
+    // This is a check of current implementations and does NOT imply any form of
+    // guarantee about future behavior. The compiler reserves the right to make
+    // these operations inexact matches in the future.
+    let eps_add = if cfg!(miri) { 1e1 } else { 0.0 };
+    let eps_mul = if cfg!(miri) { 1e3 } else { 0.0 };
+    let eps_div = if cfg!(miri) { 1e0 } else { 0.0 };
+
+    assert_approx_eq!(a.algebraic_add(b), a + b, eps_add);
+    assert_approx_eq!(a.algebraic_sub(b), a - b, eps_add);
+    assert_approx_eq!(a.algebraic_mul(b), a * b, eps_mul);
+    assert_approx_eq!(a.algebraic_div(b), a / b, eps_div);
+    assert_approx_eq!(a.algebraic_rem(b), a % b, eps_div);
 }
 
 #[test]

Diff for: library/std/tests/floats/f32.rs

@@ -921,9 +921,18 @@ fn test_algebraic() {
     let a: f32 = 123.0;
     let b: f32 = 456.0;
 
-    assert_approx_eq!(a.algebraic_add(b), a + b, 1e-3);
-    assert_approx_eq!(a.algebraic_sub(b), a - b, 1e-3);
-    assert_approx_eq!(a.algebraic_mul(b), a * b, 1e-1);
-    assert_approx_eq!(a.algebraic_div(b), a / b, 1e-4);
-    assert_approx_eq!(a.algebraic_rem(b), a % b, 1e-4);
+    // Check that individual operations match their primitive counterparts.
+    //
+    // This is a check of current implementations and does NOT imply any form of
+    // guarantee about future behavior. The compiler reserves the right to make
+    // these operations inexact matches in the future.
+    let eps_add = if cfg!(miri) { 1e-3 } else { 0.0 };
+    let eps_mul = if cfg!(miri) { 1e-1 } else { 0.0 };
+    let eps_div = if cfg!(miri) { 1e-4 } else { 0.0 };
+
+    assert_approx_eq!(a.algebraic_add(b), a + b, eps_add);
+    assert_approx_eq!(a.algebraic_sub(b), a - b, eps_add);
+    assert_approx_eq!(a.algebraic_mul(b), a * b, eps_mul);
+    assert_approx_eq!(a.algebraic_div(b), a / b, eps_div);
+    assert_approx_eq!(a.algebraic_rem(b), a % b, eps_div);
 }

Diff for: library/std/tests/floats/f64.rs

@@ -900,9 +900,16 @@ fn test_algebraic() {
     let a: f64 = 123.0;
     let b: f64 = 456.0;
 
-    assert_approx_eq!(a.algebraic_add(b), a + b);
-    assert_approx_eq!(a.algebraic_sub(b), a - b);
-    assert_approx_eq!(a.algebraic_mul(b), a * b);
-    assert_approx_eq!(a.algebraic_div(b), a / b);
-    assert_approx_eq!(a.algebraic_rem(b), a % b);
+    // Check that individual operations match their primitive counterparts.
+    //
+    // This is a check of current implementations and does NOT imply any form of
+    // guarantee about future behavior. The compiler reserves the right to make
+    // these operations inexact matches in the future.
+    let eps = if cfg!(miri) { 1e-6 } else { 0.0 };
+
+    assert_approx_eq!(a.algebraic_add(b), a + b, eps);
+    assert_approx_eq!(a.algebraic_sub(b), a - b, eps);
+    assert_approx_eq!(a.algebraic_mul(b), a * b, eps);
+    assert_approx_eq!(a.algebraic_div(b), a / b, eps);
+    assert_approx_eq!(a.algebraic_rem(b), a % b, eps);
 }

Diff for: library/std/tests/floats/lib.rs

@@ -10,7 +10,7 @@ macro_rules! assert_approx_eq {
         let (a, b) = (&$a, &$b);
         let diff = (*a - *b).abs();
         assert!(
-            diff < $lim,
+            diff <= $lim,
             "{a:?} is not approximately equal to {b:?} (threshold {lim:?}, difference {diff:?})",
             lim = $lim
         );