First pass at wiring things up

Author: tgross35

crates/libm-test/examples/plot_domains.rs

@@ -46,7 +46,7 @@ fn plot_one<D: Domain<f32>>(out_dir: &Path, name: &str, j_args: &mut Vec<String>
         let f = fs::File::create(&text_file).unwrap();
         let mut w = BufWriter::new(f);
 
-        for input in domain::get_test_cases::<f32, D>() {
+        for input in domain::get_test_cases_for_domain::<f32, D>() {
             writeln!(w, "{:e}", input.0).unwrap();
         }
         w.flush().unwrap();

crates/libm-test/src/gen/domain.rs

@@ -15,8 +15,8 @@ use std::ops::Bound;
 
 use libm::support::{Float, MinInt};
 
-use crate::domain::Domain;
-use crate::{FloatExt, logspace};
+use crate::domain::{Domain, HasDomain};
+use crate::{FloatExt, MathOp, logspace};
 
 /// Number of values near an interesting point to check.
 const AROUND: usize = 100;
@@ -44,7 +44,16 @@ const NTESTS: usize = {
 const MAX_ASYMPTOTES: usize = 10;
 
 /// Create a test case iterator.
-pub fn get_test_cases<F: Float, D: Domain<F>>() -> impl Iterator<Item = (F,)>
+pub fn get_test_cases<Op>() -> impl Iterator<Item = (Op::FTy,)>
+where
+    Op: MathOp + HasDomain<Op::FTy>,
+    <Op::FTy as Float>::Int: TryFrom<usize>,
+{
+    get_test_cases_for_domain::<Op::FTy, Op::D>()
+}
+
+/// Create test cases given a domain.
+pub fn get_test_cases_for_domain<F: Float, D: Domain<F>>() -> impl Iterator<Item = (F,)>
 where
     F::Int: TryFrom<usize>,
 {

crates/libm-test/tests/multiprecision.rs

@@ -2,9 +2,10 @@
 
 #![cfg(feature = "test-multiprecision")]
 
-use libm_test::gen::{CachedInput, random};
+use libm_test::domain::HasDomain;
+use libm_test::gen::{CachedInput, domain, random};
 use libm_test::mpfloat::MpOp;
-use libm_test::{CheckBasis, CheckCtx, CheckOutput, GenerateInput, MathOp, TupleCall};
+use libm_test::{CheckBasis, CheckCtx, CheckOutput, Float, GenerateInput, MathOp, TupleCall};
 
 /// Implement a test against MPFR with random inputs.
 macro_rules! multiprec_rand_tests {
@@ -22,6 +23,7 @@ macro_rules! multiprec_rand_tests {
     };
 }
 
+/// Test a single routine with random inputs
 fn test_one_random<Op>()
 where
     Op: MathOp + MpOp,
@@ -39,37 +41,123 @@ where
     }
 }
 
-// TODO: wire up
-#[expect(unused)]
+libm_macros::for_each_function! {
+    callback: multiprec_rand_tests,
+    attributes: [
+        // Also an assertion failure on i686: at `MPFR_ASSERTN (! mpfr_erangeflag_p ())`
+        #[ignore = "large values are infeasible in MPFR"]
+        [jn, jnf],
+    ],
+    skip: [
+        // FIXME: MPFR tests needed
+        frexp,
+        frexpf,
+        ilogb,
+        ilogbf,
+        ldexp,
+        ldexpf,
+        modf,
+        modff,
+        remquo,
+        remquof,
+        scalbn,
+        scalbnf,
+
+        // FIXME: test needed, see
+        // https://github.com/rust-lang/libm/pull/311#discussion_r1818273392
+        nextafter,
+        nextafterf,
+    ],
+}
+
+/// Implement a test against MPFR with domain-aware inputs.
+macro_rules! multiprec_domain_tests {
+    (
+        fn_name: $fn_name:ident,
+        attrs: [$($meta:meta)*]
+    ) => {
+        paste::paste! {
+            #[test]
+            $(#[$meta])*
+            fn [< multiprec_domain_ $fn_name >]() {
+                test_one_domain::<libm_test::op::$fn_name::Routine>();
+            }
+        }
+    };
+}
+
+/// Test a single routine against domaine-aware inputs
 fn test_one_domain<Op>()
 where
-    Op: MathOp + MpOp,
-    CachedInput: GenerateInput<Op::RustArgs>,
+    // Complicated generics...
+    // The operation must take a single float argument (unary only)
+    Op: MathOp<RustArgs = (<Op as MathOp>::FTy,)>,
+    // It must also support multiprecision operations
+    Op: MpOp,
+    // And it must have a domain specified
+    Op: HasDomain<Op::FTy>,
+    // The single float argument tuple must be able to call the `RustFn` and return `RustRet`
+    (<Op as MathOp>::FTy,): TupleCall<<Op as MathOp>::RustFn, Output = <Op as MathOp>::RustRet>,
+    // And then we need to be able to cast integers (required by `Domain`).
+    <Op::FTy as Float>::Int: TryFrom<usize>,
 {
     let name = Op::NAME_STR;
 
     let ulp = multiprec_allowed_ulp(name);
     let mut mp_vals = Op::new_mp();
     let ctx = CheckCtx::new(ulp, name, CheckBasis::Mpfr);
-    // let cases = random::get_test_cases::<Op::RustArgs>(&ctx);
+    let cases = domain::get_test_cases::<Op>();
 
-    // for input in cases {
-    //     let mp_res = Op::run(&mut mp_vals, input);
-    //     let crate_res = input.call(Op::ROUTINE);
+    for input in cases {
+        let mp_res = Op::run(&mut mp_vals, input);
+        let crate_res = input.call(Op::ROUTINE);
 
-    //     crate_res.validate(mp_res, input, &ctx).unwrap();
-    // }
+        crate_res.validate(mp_res, input, &ctx).unwrap();
+    }
 }
 
 libm_macros::for_each_function! {
-    callback: multiprec_rand_tests,
-    attributes: [
-        // Also an assertion failure on i686: at `MPFR_ASSERTN (! mpfr_erangeflag_p ())`
-        #[ignore = "large values are infeasible in MPFR"]
-        [jn, jnf],
-    ],
+    callback: multiprec_domain_tests,
+    attributes: [],
     skip: [
-        // FIXME: MPFR tests needed
+        atan2f,
+        copysignf,
+        fdimf,
+        fmaxf,
+        fminf,
+        fmodf,
+        hypotf,
+        nextafterf,
+        powf,
+        remainderf,
+        atan2,
+        copysign,
+        fdim,
+        fmax,
+        fmin,
+        fmod,
+        hypot,
+        nextafter,
+        pow,
+        remainder,
+        fmaf,
+        fma,
+        ilogbf,
+        ilogb,
+        modf,
+        modff,
+        jnf,
+        jn,
+        remquo,
+        remquof,
+        tgamma,
+        tgammaf,
+        lgammaf_r,
+        lgamma_r,
+        lgamma,
+        lgammaf,
+        sincos,
+        sincosf,
         frexp,
         frexpf,
         ilogb,
@@ -82,9 +170,6 @@ libm_macros::for_each_function! {
         remquof,
         scalbn,
         scalbnf,
-
-        // FIXME: test needed, see
-        // https://github.com/rust-lang/libm/pull/311#discussion_r1818273392
         nextafter,
         nextafterf,
     ],