add tests to check that the operations behave like the Ieee and C standard specify

Author: LorrensP-2158466

src/tools/miri/tests/pass/float.rs

@@ -38,8 +38,8 @@ macro_rules! assert_approx_eq {
     }};
 
     ($a:expr, $b: expr) => {
-        // accept up to 64ULP (16ULP for host floats and 16ULP for miri artificial error and 32 for any rounding errors)
-        assert_approx_eq!($a, $b, 64);
+        // accept up to 52ULP (16ULP for host floats, 4ULP for miri artificial error and 32 for any rounding errors)
+        assert_approx_eq!($a, $b, 52);
     };
 }
 
@@ -1006,17 +1006,52 @@ pub fn libm() {
     assert_approx_eq!(25f32.powf(-2f32), 0.0016f32);
     assert_approx_eq!(400f64.powf(0.5f64), 20f64);
 
+    // Some inputs to powf and powi result in fixed outputs
+    // and thus must be exactly equal to that value
+    // TODO: How to test NaN inputs? f*::NAN is not guaranteed
+    // to be any specific bit pattern (in std).
+    assert_eq!(1f32.powf(10.0), 1f32);
+    assert_eq!(1f64.powf(100.0), 1f64);
+    assert_eq!(1f32.powf(f32::INFINITY), 1f32);
+    assert_eq!(1f64.powf(f64::INFINITY), 1f64);
+
+    assert_eq!((-1f32).powf(f32::INFINITY), 1f32);
+    assert_eq!((-1f32).powf(f32::NEG_INFINITY), 1f32);
+    assert_eq!((-1f64).powf(f64::INFINITY), 1f64);
+    assert_eq!((-1f64).powf(f64::NEG_INFINITY), 1f64);
+
+    assert_eq!(42f32.powf(0.0), 1f32);
+    assert_eq!(42f32.powf(-0.0), 1f32);
+    assert_eq!(42f64.powf(0.0), 1f64);
+    assert_eq!(42f64.powf(-0.0), 1f64);
+
+    assert_eq!(0f32.powi(10), 0f32);
+    assert_eq!(0f64.powi(100), 0f64);
+    assert_eq!(0f32.powi(9), 0f32);
+    assert_eq!(0f64.powi(99), 0f64);
+
+    assert_eq!((-0f32).powi(10), 0f32);
+    assert_eq!((-0f64).powi(100), 0f64);
+    assert_eq!((-0f32).powi(9), -0f32);
+    assert_eq!((-0f64).powi(99), -0f64);
+
     assert_approx_eq!(1f32.exp(), f32::consts::E);
     assert_approx_eq!(1f64.exp(), f64::consts::E);
+    assert_eq!(0f32.exp(), 1f32);
+    assert_eq!(0f64.exp(), 1f64);
 
     assert_approx_eq!(1f32.exp_m1(), f32::consts::E - 1.0);
     assert_approx_eq!(1f64.exp_m1(), f64::consts::E - 1.0);
 
     assert_approx_eq!(10f32.exp2(), 1024f32);
     assert_approx_eq!(50f64.exp2(), 1125899906842624f64);
+    assert_eq!(0f32.exp2(), 1f32);
+    assert_eq!(0f64.exp2(), 1f64);
 
     assert_approx_eq!(f32::consts::E.ln(), 1f32);
-    assert_approx_eq!(1f64.ln(), 0f64);
+    assert_approx_eq!(f64::consts::E.ln(), 1f64);
+    assert_eq!(1f32.ln(), 0f32);
+    assert_eq!(1f64.ln(), 0f64);
 
     assert_approx_eq!(0f32.ln_1p(), 0f32);
     assert_approx_eq!(0f64.ln_1p(), 0f64);
@@ -1045,7 +1080,8 @@ pub fn libm() {
 
     // Trigonometric functions.
 
-    assert_approx_eq!(0f32.sin(), 0f32);
+    assert_eq!(0f32.sin(), 0f32);
+    assert_eq!(0f64.sin(), 0f64);
     assert_approx_eq!((f64::consts::PI / 2f64).sin(), 1f64);
     assert_approx_eq!(f32::consts::FRAC_PI_6.sin(), 0.5);
     assert_approx_eq!(f64::consts::FRAC_PI_6.sin(), 0.5);
@@ -1057,7 +1093,23 @@ pub fn libm() {
     assert_approx_eq!(2.0f32.asinh(), 1.443635475178810342493276740273105f32);
     assert_approx_eq!((-2.0f64).asinh(), -1.443635475178810342493276740273105f64);
 
-    assert_approx_eq!(0f32.cos(), 1f32);
+    // from #4207
+    // TODO: should this be the behaviour? I haven't found anything in the IEEE Standard
+    let halve_pi_single = std::f32::consts::FRAC_PI_2;
+    let halve_pi_double = std::f64::consts::FRAC_PI_2;
+    let pi_single = std::f32::consts::PI;
+    let pi_double = std::f64::consts::PI;
+    for _ in 0..64 {
+        // sin() should be clamped to [-1, 1] so asin() can never return NaN
+        assert!(!halve_pi_single.sin().asin().is_nan());
+        assert!(!halve_pi_double.sin().asin().is_nan());
+        // sin() should be clamped to [-1, 1] so acos() can never return NaN
+        assert!(!pi_single.cos().acos().is_nan());
+        assert!(!pi_double.cos().acos().is_nan());
+    }
+
+    assert_eq!(0f32.cos(), 1f32);
+    assert_eq!(0f64.cos(), 1f64);
     assert_approx_eq!((f64::consts::PI * 2f64).cos(), 1f64);
     assert_approx_eq!(f32::consts::FRAC_PI_3.cos(), 0.5);
     assert_approx_eq!(f64::consts::FRAC_PI_3.cos(), 0.5);
@@ -1281,7 +1333,6 @@ fn test_non_determinism() {
     /// Ensure that the operation is non-deterministic
     #[track_caller]
     fn ensure_nondet<T: PartialEq + std::fmt::Debug>(f: impl Fn() -> T) {
-
         let rounds = 16;
         let first = f();
         for _ in 1..rounds {
@@ -1328,7 +1379,7 @@ fn test_non_determinism() {
         ensure_nondet(|| 27.0f32.cbrt());
         ensure_nondet(|| 3.0f32.hypot(4.0f32));
         ensure_nondet(|| 1f32.sin());
-        ensure_nondet(|| 0f32.cos());
+        ensure_nondet(|| 3.1f32.cos());
         // On i686-pc-windows-msvc , these functions are implemented by calling the `f64` version,
         // which means the little rounding errors Miri introduces are discard by the cast down to `f32`.
         // Just skip the test for them.
@@ -1362,7 +1413,7 @@ fn test_non_determinism() {
         ensure_nondet(|| 27.0f64.cbrt());
         ensure_nondet(|| 3.0f64.hypot(4.0f64));
         ensure_nondet(|| 1f64.sin());
-        ensure_nondet(|| 0f64.cos());
+        ensure_nondet(|| 3.1f64.cos());
         ensure_nondet(|| 1.0f64.tan());
         ensure_nondet(|| 1.0f64.asin());
         ensure_nondet(|| 5.0f64.acos());