Add a test against MPFR using random inputs

Author: tgross35

crates/libm-test/src/lib.rs

@@ -10,15 +10,19 @@ pub use test_traits::{CheckBasis, CheckCtx, CheckOutput, GenerateInput, TupleCal
 // List of all files present in libm's source
 include!(concat!(env!("OUT_DIR"), "/all_files.rs"));
 
-/// ULP allowed to differ from musl (note that musl itself may not be accurate).
+/// Default ULP allowed to differ from musl (note that musl itself may not be accurate).
 const MUSL_DEFAULT_ULP: u32 = 2;
 
-/// Certain functions have different allowed ULP (consider these xfail).
+/// Default ULP allowed to differ from multiprecision (i.e. infinite) results.
+const MULTIPREC_DEFAULT_ULP: u32 = 1;
+
+/// ULP allowed to differ from muls results.
 ///
-/// Currently this includes:
+/// Current overrides includes:
 /// - gamma functions that have higher errors
 /// - 32-bit functions fall back to a less precise algorithm.
 pub fn musl_allowed_ulp(name: &str) -> u32 {
+    // Consider overrides xfail
     match name {
         #[cfg(x86_no_sse)]
         "asinh" | "asinhf" => 6,
@@ -33,6 +37,22 @@ pub fn musl_allowed_ulp(name: &str) -> u32 {
     }
 }
 
+/// ULP allowed to differ from multiprecision results.
+pub fn multiprec_allowed_ulp(name: &str) -> u32 {
+    // Consider overrides xfail
+    match name {
+        "asinh" | "asinhf" => 2,
+        "atanh" | "atanhf" => 2,
+        "exp10" | "exp10f" => 3,
+        "j0" | "j0f" => 2,
+        "lgamma" | "lgammaf" | "lgamma_r" | "lgammaf_r" => 2,
+        "sinh" | "sinhf" => 2,
+        "tanh" | "tanhf" => 2,
+        "tgamma" => 6,
+        _ => MULTIPREC_DEFAULT_ULP,
+    }
+}
+
 /// If only a few checks are incorrect, xfail them here rather than skipping the entire test.
 pub fn xfail<F: Float>(actual: F, expected: F, ctx: &CheckCtx) -> bool {
     match (&ctx.basis, ctx.fname) {

crates/libm-test/src/test_traits.rs

@@ -41,6 +41,8 @@ pub struct CheckCtx {
 pub enum CheckBasis {
     /// Check against Musl's math sources.
     Musl,
+    /// Check against infinite precision (MPFR).
+    MultiPrecision,
 }
 
 /// A trait to implement on any output type so we can verify it in a generic way.

crates/libm-test/tests/multiprecision.rs

@@ -0,0 +1,67 @@
+//! Test with "infinite precision"
+
+#![cfg(feature = "multiprecision-tests")]
+
+use libm_test::gen::random;
+use libm_test::mpfloat::{self, MpOp};
+use libm_test::multiprec_allowed_ulp;
+use libm_test::{CheckBasis, CheckCtx, CheckOutput, TupleCall};
+
+/// Implement a test against MPFR with random inputs.
+macro_rules! multiprec_rand_tests {
+    (
+        fn_name: $fn_name:ident,
+        CFn: $CFn:ty,
+        CArgs: $CArgs:ty,
+        CRet: $CRet:ty,
+        RustFn: $RustFn:ty,
+        RustArgs: $RustArgs:ty,
+        RustRet: $RustRet:ty,
+        attrs: [$($meta:meta)*]
+    ) => {
+        paste::paste! {
+            #[test]
+            $(#[$meta])*
+            fn [< multiprec_random_ $fn_name >]() {
+                type MpOpTy = mpfloat::$fn_name::Operation;
+
+                let fname = stringify!($fn_name);
+                let ulp = multiprec_allowed_ulp(fname);
+                let cases = random::get_test_cases::<$RustArgs>(fname);
+                let mut mp_vals = MpOpTy::new();
+                let ctx = CheckCtx {
+                    ulp,
+                    fname,
+                    basis: CheckBasis::MultiPrecision
+                };
+
+                for input in cases {
+                    let mp_res = mp_vals.run(input);
+                    let crate_res = input.call(libm::$fn_name as $RustFn);
+
+                    mp_res.validate(crate_res, input, &ctx).unwrap();
+                }
+            }
+        }
+    };
+}
+
+libm_macros::for_each_function! {
+    callback: multiprec_rand_tests,
+    attributes: [],
+    skip: [
+        // FIXME: MPFR tests needed
+        frexp,
+        frexpf,
+        ilogb,
+        ilogbf,
+        ldexp,
+        ldexpf,
+        modf,
+        modff,
+        remquo,
+        remquof,
+        scalbn,
+        scalbnf,
+    ],
+}