Refactor random tests into lib; be more exhaustive at boundaries.

Author: gnzlbg

crates/libm-bench/benches/bench.rs

@@ -1,7 +1,7 @@
 #![feature(test)]
 extern crate test;
 
-use libm_test::{adjust_input, Call};
+use libm_test::{get_api_kind, ApiKind, Call};
 use rand::Rng;
 use test::Bencher;
 
@@ -29,7 +29,10 @@ macro_rules! bench_fn {
             let mut rng = rand::thread_rng();
             let mut x: ( $($arg_tys,)+ ) = ( $(rng.gen::<$arg_tys>(),)+ );
 
-            adjust_input!(fn: $id, input: x);
+            if let ApiKind::Jx = get_api_kind!(fn: $id) {
+                let ptr = &mut x as *mut _ as *mut i32;
+                unsafe { ptr.write(ptr.read() & 0xffff) };
+            }
 
             bh.iter(|| test::black_box(x).call(libm::$id as FnTy))
         }

crates/libm-test/Cargo.toml

@@ -4,14 +4,16 @@ version = "0.1.0"
 authors = ["Gonzalo Brito Gadeschi <[email protected]>"]
 edition = "2018"
 
-[dev-dependencies]
+[dependencies]
+rand = "0.7"
 libm = { path = "../libm", default-features = false }
+
+[dev-dependencies]
 libm-analyze = { path = "../libm-analyze", default-features = true }
-rand = "0.7"
 
 [features]
 default = []
 checked = ["libm/checked"]
 stable = ["libm/stable"]
 system_libm = []
-exhaustive = []
+exhaustive = []

crates/libm-test/src/lib.rs

@@ -77,6 +77,7 @@ impl_call!((f64) -> f64: x: x.0);
 impl_call!((f64) -> i32: x: x.0);
 impl_call!((f32) -> i32: x: x.0);
 impl_call!((f32, f32) -> f32: x: x.0, x.1);
+impl_call!((f32, f64) -> 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);
@@ -85,23 +86,53 @@ 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);
 
-// Adjust the input of a function.
+pub trait TupleVec {
+    type Output;
+    fn get(&self, i: usize) -> Self::Output;
+}
+
+macro_rules! impl_tuple_vec {
+    (($($arg_tys:ty),*): $self_:ident: $($xs:expr),*)  => {
+        impl TupleVec for ($(Vec<$arg_tys>,)+) {
+            type Output = ($($arg_tys,)+);
+            fn get(&self, i: usize) -> Self::Output {
+                let $self_ = self;
+                ($($xs[i],)*)
+            }
+        }
+    };
+}
+
+impl_tuple_vec!((f32): x: x.0);
+impl_tuple_vec!((f64): x: x.0);
+impl_tuple_vec!((f32, f32): x: x.0, x.1);
+impl_tuple_vec!((f32, f64): x: x.0, x.1);
+impl_tuple_vec!((f64, f64): x: x.0, x.1);
+impl_tuple_vec!((f64, i32): x: x.0, x.1);
+impl_tuple_vec!((f32, i32): x: x.0, x.1);
+impl_tuple_vec!((i32, f64): x: x.0, x.1);
+impl_tuple_vec!((i32, f32): x: x.0, x.1);
+impl_tuple_vec!((f32, f32, f32): x: x.0, x.1, x.2);
+impl_tuple_vec!((f64, f64, f64): x: x.0, x.1, x.2);
+
+/// Kind of LibmApi - used to handle generating tests
+/// for some functions slightly differently.
+#[derive(Copy, Clone, Debug, PartialEq)]
+pub enum ApiKind {
+    Jx,
+    Other,
+}
+
 #[macro_export]
-macro_rules! adjust_input {
-    (fn: j1, input: $arg:ident) => {
-        adjust_input!(adjust: $arg)
+macro_rules! get_api_kind {
+    (fn: j1) => {
+        $crate::ApiKind::Jx
     };
-    (fn: jn, input: $arg:ident) => {
-        adjust_input!(adjust: $arg)
+    (fn: jn) => {
+        $crate::ApiKind::Jx
     };
-    (fn: $id:ident, input: $args:ident) => {};
-    (adjust: $arg:ident) => {
-        // 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 $arg as *mut _ as *mut i32;
-        unsafe { p.write(p.read() & 0xffff) }
+    (fn: $id:ident) => {
+        $crate::ApiKind::Other
     };
 }
 
@@ -121,3 +152,100 @@ macro_rules! assert_approx_eq {
         }
     };
 }
+
+pub trait Toward: Sized {
+    fn toward(self, other: Self, len: usize) -> Vec<Self>;
+}
+
+macro_rules! impl_toward_f {
+    ($float_ty:ident, $toward_fn:path) => {
+        impl Toward for $float_ty {
+            fn toward(self, other: Self, len: usize) -> Vec<Self> {
+                let mut vec = Vec::with_capacity(len);
+                let mut current = self;
+                vec.push(self);
+                for _ in 0..=len {
+                    current = $toward_fn(current, other as _);
+                    vec.push(self);
+                    if current.to_bits() == other.to_bits() {
+                        break;
+                    }
+                }
+                vec
+            }
+        }
+    };
+}
+impl_toward_f!(f32, libm::nextafterf);
+impl_toward_f!(f64, libm::nextafter);
+
+pub trait RandSeq: Sized {
+    fn rand_seq<R: rand::Rng>(rng: &mut R, api_kind: ApiKind, len: usize) -> Vec<Self>;
+}
+
+macro_rules! impl_rand_seq_f {
+    ($float_ty:ident) => {
+        impl RandSeq for $float_ty {
+            fn rand_seq<R: rand::Rng>(rng: &mut R, _api_kind: ApiKind, len: usize) -> Vec<Self> {
+                use std::$float_ty::*;
+                let mut vec = Vec::with_capacity(len);
+
+                // These inputs are always tested
+                const BOUNDS: [$float_ty; 9] = [
+                    NAN,
+                    INFINITY,
+                    NEG_INFINITY,
+                    EPSILON,
+                    -EPSILON,
+                    MAX,
+                    MIN,
+                    MIN_POSITIVE,
+                    -MIN_POSITIVE,
+                ];
+                vec.extend(&BOUNDS);
+                // A range around the inputs is also always tested:
+                const NSTEPS: usize = 1_000;
+                vec.extend(INFINITY.toward(0., NSTEPS));
+                vec.extend(NEG_INFINITY.toward(0., NSTEPS));
+                vec.extend((0. as $float_ty).toward(MIN_POSITIVE, NSTEPS));
+                vec.extend((0. as $float_ty).toward(-MIN_POSITIVE, NSTEPS));
+
+                for i in 0..=NSTEPS {
+                    let dx = 2. / NSTEPS as $float_ty;
+                    let next = (-1. as $float_ty) + (i as $float_ty) * dx;
+                    vec.push(next);
+                }
+
+                // ~NSTEPS * 4
+                assert!(len > 2 * 4 * NSTEPS, "len {} !> {}", len, 2 * 4 * NSTEPS);
+                let current_len = vec.len();
+                let remaining_len = len.checked_sub(current_len).unwrap();
+
+                for _ in 0..remaining_len {
+                    let n = rng.gen::<$float_ty>();
+                    vec.push(n);
+                }
+                assert_eq!(vec.len(), len);
+                vec
+            }
+        }
+    };
+}
+
+impl_rand_seq_f!(f32);
+impl_rand_seq_f!(f64);
+
+impl RandSeq for i32 {
+    fn rand_seq<R: rand::Rng>(rng: &mut R, api_kind: ApiKind, len: usize) -> Vec<Self> {
+        let mut v = Vec::with_capacity(len);
+        for _ in 0..len {
+            let mut r = rng.gen::<i32>();
+            if let ApiKind::Jx = api_kind {
+                r &= 0xffff;
+            }
+            v.push(r);
+        }
+        assert_eq!(v.len(), len);
+        v
+    }
+}

crates/libm-test/tests/system_libm.rs

@@ -2,10 +2,10 @@
 #![cfg(test)]
 #![cfg(feature = "system_libm")]
 
-use libm_test::{adjust_input, assert_approx_eq, Call};
+use libm_test::{assert_approx_eq, get_api_kind, Call, RandSeq, TupleVec};
 
 // Number of tests to generate for each function
-const NTESTS: usize = 500;
+const NTESTS: usize = 10_000;
 
 const ULP_TOL: usize = 4;
 
@@ -74,25 +74,26 @@ macro_rules! system_libm {
         #[allow(unused)]
         fn $id() {
             use crate::Call;
-            let mut rng = rand::thread_rng();
-            for _ in 0..NTESTS {
-                // Type of the system libm fn:
-                type FnTy
-                    = unsafe extern "C" 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;
+            extern "C" {
+                // The system's libm function:
+                fn $id($($arg_ids: $arg_tys),*) -> $ret_ty;
+            }
 
-               extern "C" {
-                    // The system's libm function:
-                    fn $id($($arg_ids: $arg_tys),*) -> $ret_ty;
-                }
+            let mut rng = rand::thread_rng();
 
-                // Generate a tuple of arguments containing random values:
-                let mut args: ( $($arg_tys,)+ )
-                    = ( $(<$arg_tys as Rand>::gen(&mut rng),)+ );
+            // Depending on the type of API, different ranges of values might be
+            // allowed or interesting to test:
+            let api_kind = get_api_kind!(fn: $id);
 
-                // Some APIs need their inputs to be "adjusted" (see macro):
-                // correct_input!(fn: $id, input: args);
-                adjust_input!(fn: $id, input: args);
+            // Generate a tuple of arguments containing random values:
+            let mut args: ( $(Vec<$arg_tys>,)+ )
+                = ( $(<$arg_tys as RandSeq>::rand_seq(&mut rng, api_kind, NTESTS),)+ );
 
+            for i in 0..NTESTS {
+                let args: ( $($arg_tys,)+ ) = args.get(i);
                 let result = args.call(libm::$id as FnTy);
                 let expected = args.call($id as FnTy);
                 assert_approx_eq!(
@@ -105,31 +106,3 @@ macro_rules! system_libm {
 }
 
 libm_analyze::for_each_api!(system_libm);
-
-// 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;
-}
-
-macro_rules! impl_rand {
-    ($id:ident: [$($e:expr),*]) => {
-        impl Rand for $id {
-            fn gen(r: &mut rand::rngs::ThreadRng) -> Self {
-                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>()
-                }
-            }
-        }
-    }
-}
-
-// 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()]);

crates/libm/src/lib.rs

@@ -1,6 +1,6 @@
 //! libm in pure Rust
 #![deny(warnings)]
-#![no_std]
+//#![no_std]
 #![cfg_attr(
     all(target_arch = "wasm32", not(feature = "stable")),
     feature(core_intrinsics)