Document and refactor libm-test a bit

Author: gnzlbg

crates/libm-test/src/lib.rs

@@ -0,0 +1,51 @@
+//! Testing utilities required by most tests.
+
+pub trait WithinUlps {
+    /// Returns true if two numbers are closer than `ulp_tol` to each other.
+    fn within_ulps(self, other: Self, ulp_tol: usize) -> bool;
+}
+
+// TODO: this should be moved to the libm-test/src/lib.rs library. And we
+// should make ulps configurable.
+
+// Stamp the impls for floats:
+macro_rules! impl_within_ulps_f {
+    ($f_ty:ty, $i_ty:ty) => {
+        impl WithinUlps for $f_ty {
+            fn within_ulps(self, y: $f_ty, ulp_tol: usize) -> bool {
+                let x = self;
+                if x.is_nan() != y.is_nan() {
+                    // one is nan but the other is not
+                    return false;
+                }
+                if x.is_nan() && y.is_nan() {
+                    return true;
+                }
+                if x.is_infinite() != y.is_infinite() {
+                    // one is inf but the other is not
+                    return false;
+                }
+
+                let xi: $i_ty = unsafe { core::intrinsics::transmute(x) };
+                let yi: $i_ty = unsafe { core::intrinsics::transmute(y) };
+                if (xi < 0) != (yi < 0) {
+                    // different sign, e.g., -0.0 != +0.0:
+                    return false;
+                }
+                let ulps = (xi - yi).abs();
+                ulps <= ulp_tol as _
+            }
+        }
+    };
+}
+
+impl_within_ulps_f!(f32, i32);
+impl_within_ulps_f!(f64, i64);
+
+impl WithinUlps for i32 {
+    fn within_ulps(self, y: i32, ulp_tol: usize) -> bool {
+        let x = self;
+        let ulps = (x - y).abs();
+        ulps <= ulp_tol as _
+    }
+}

crates/libm-test/tests/system_libm.rs

@@ -1,15 +1,19 @@
 //! Compare the results of the `libm` implementation against the system's libm.
 #![cfg(test)]
 #![cfg(feature = "system_libm")]
+
+use libm_test::WithinUlps;
+
 // Number of tests to generate for each function
 const NTESTS: usize = 500;
 
-// FIXME: should be 1
 const ULP_TOL: usize = 4;
 
 macro_rules! system_libm {
     // Skip those parts of the API that are not
     // exposed by the system libm library:
+    //
+    // FIXME: maybe we can skip them as part of libm-analyze?
     (
         id: j0f;
         arg_tys: $($arg_tys:ty),*;
@@ -72,33 +76,34 @@ macro_rules! system_libm {
             use crate::Call;
             let mut rng = rand::thread_rng();
             for _ in 0..NTESTS {
-                let mut args: ( $($arg_tys),+ ) = ( $(<$arg_tys as Rand>::gen(&mut rng)),+ );
-
-                match stringify!($id) {
-                    "j1" | "jn" => {
-                        // First argument to this function appears to be a number of
-                        // iterations, so passing in massive random numbers causes it to
-                        // take forever to execute, so make sure we're not running random
-                        // math code until the heat death of the universe.
-                        let p = &mut args as *mut _ as *mut i32;
-                        unsafe { p.write(p.read() & 0xffff) }
-                    },
-                    _ => (),
-                }
-
-                unsafe extern "C" fn libm_fn($($arg_ids: $arg_tys),*) -> $ret_ty {
+                // Type of the system libm fn:
+                type FnTy = unsafe extern "C" fn ($($arg_ids: $arg_tys),*) -> $ret_ty;
+                // FIXME: extern "C" wrapper over our libm functions
+                // Shouldn't be needed once they are all extern "C"
+                extern "C" fn libm_fn($($arg_ids: $arg_tys),*) -> $ret_ty {
                     libm::$id($($arg_ids),*)
                 }
-                let result = <($($arg_tys),*) as Call<
-                      unsafe extern "C" fn($($arg_tys),*) -> $ret_ty
-                    >>::call(args, libm_fn);
                 extern "C" {
+                    // The system's libm function:
                     fn $id($($arg_ids: $arg_tys),*) -> $ret_ty;
                 }
-                let expected = <($($arg_tys),*) as Call<
-                    unsafe extern "C" fn($($arg_tys),*) -> $ret_ty
-                    >>::call(args, $id);
-                if !result.eq(expected) {
+
+                // Generate a tuple of arguments containing random values:
+                let mut args: ( $($arg_tys),+ ) = ( $(<$arg_tys as Rand>::gen(&mut rng)),+ );
+
+                // HACK
+                if let "j1" | "jn" = stringify!($id) {
+                    // First argument to these functions are a number of
+                    // iterations and passing large random numbers takes forever
+                    // to execute, so check if their higher bits are set and
+                    // zero them:
+                    let p = &mut args as *mut _ as *mut i32;
+                    unsafe { p.write(p.read() & 0xffff) }
+                }
+
+                let result = args.call(libm_fn as FnTy);
+                let expected = args.call($id as FnTy);
+                if !result.within_ulps(expected, ULP_TOL) {
                     eprintln!("result = {:?} != {:?} (expected)", result, expected);
                     panic!();
                 }
@@ -109,13 +114,20 @@ macro_rules! system_libm {
 
 libm_analyze::for_each_api!(system_libm);
 
+// This implements function dispatch for tuples of arguments used in the tests
+// above, so that we can: (f32, 32).call(fn(f32, f32) -> f32) generically.
+//
+// We need the input parameter F to support dispatching, e.g., (f32,f32) with
+// functions that return both f32 or i32. Those are two different types, so we
+// need to be parametric over them.
 trait Call<F> {
     type Ret;
     fn call(self, f: F) -> Self::Ret;
 }
 
 macro_rules! impl_call {
     (($($arg_tys:ty),*) -> $ret_ty:ty: $self_:ident: $($xs:expr),*)  => {
+        // We only care about unsafe extern "C" functions here, safe functions coerce to them:
         impl Call<unsafe extern"C" fn($($arg_tys),*) -> $ret_ty> for ($($arg_tys),+) {
             type Ret = $ret_ty;
             fn call(self, f: unsafe extern "C" fn($($arg_tys),*) -> $ret_ty) -> Self::Ret {
@@ -130,17 +142,18 @@ impl_call!((f32) -> f32: x: x);
 impl_call!((f64) -> f64: x: x);
 impl_call!((f64) -> i32: x: x);
 impl_call!((f32) -> i32: x: x);
-
-impl_call!((f32,f32) -> f32: x: x.0, x.1);
-impl_call!((f64,f64) -> f64: x: x.0, x.1);
+impl_call!((f32, f32) -> f32: x: x.0, x.1);
+impl_call!((f64, f64) -> f64: x: x.0, x.1);
 impl_call!((f64, i32) -> f64: x: x.0, x.1);
 impl_call!((f32, i32) -> f32: x: x.0, x.1);
 impl_call!((i32, f64) -> f64: x: x.0, x.1);
 impl_call!((i32, f32) -> f32: x: x.0, x.1);
+impl_call!((f32, f32, f32) -> f32: x: x.0, x.1, x.2);
+impl_call!((f64, f64, f64) -> f64: x: x.0, x.1, x.2);
 
-impl_call!((f32,f32,f32) -> f32: x: x.0, x.1, x.2);
-impl_call!((f64,f64,f64) -> f64: x: x.0, x.1, x.2);
-
+// We need to be able to generate random numbers for the types involved.
+//
+// Rand does this well, but we want to also test some other specific values.
 trait Rand {
     fn gen(rng: &mut rand::rngs::ThreadRng) -> Self;
 }
@@ -149,64 +162,19 @@ macro_rules! impl_rand {
     ($id:ident: [$($e:expr),*]) => {
         impl Rand for $id {
             fn gen(r: &mut rand::rngs::ThreadRng) -> Self {
-                use rand::Rng;
-                use rand::seq::SliceRandom;
-                let r = if r.gen_range(0, 20) < 1 {
+                use rand::{Rng, seq::SliceRandom};
+                // 1/20 probability of picking a non-random value
+                if r.gen_range(0, 20) < 1 {
                     *[$($e),*].choose(r).unwrap()
                 } else {
                     r.gen::<$id>()
-                };
-                unsafe { std::mem::transmute(r) }
+                }
             }
         }
     }
 }
 
+// Some interesting random values
 impl_rand!(f32: [std::f32::NAN, std::f32::INFINITY, std::f32::NEG_INFINITY]);
 impl_rand!(f64: [std::f64::NAN, std::f64::INFINITY, std::f64::NEG_INFINITY]);
 impl_rand!(i32: [i32::max_value(), 0_i32, i32::min_value()]);
-
-trait Equal {
-    fn eq(self, other: Self) -> bool;
-}
-
-macro_rules! impl_eq_f {
-    ($f_ty:ty, $i_ty:ty) => {
-        impl Equal for $f_ty {
-            fn eq(self, y: $f_ty) -> bool {
-                let x = self;
-                if x.is_nan() != y.is_nan() {
-                    // one is nan but the other is not
-                    return false;
-                }
-                if x.is_nan() && y.is_nan() {
-                    return true;
-                }
-                if x.is_infinite() != y.is_infinite() {
-                    // one is inf but the other is not
-                    return false;
-                }
-
-                let xi: $i_ty = unsafe { core::intrinsics::transmute(x) };
-                let yi: $i_ty = unsafe { core::intrinsics::transmute(y) };
-                if (xi < 0) != (yi < 0) {
-                    // different sign
-                    return false;
-                }
-                let ulps = (xi - yi).abs();
-                ulps <= ULP_TOL as _
-            }
-        }
-    };
-}
-
-impl_eq_f!(f32, i32);
-impl_eq_f!(f64, i64);
-
-impl Equal for i32 {
-    fn eq(self, y: i32) -> bool {
-        let x = self;
-        let ulps = (x - y).abs();
-        ulps <= 1
-    }
-}