WIP

Author: tgross35

libm-test/tests/multiprecision.rs

@@ -3,7 +3,7 @@
 #![cfg(feature = "build-mpfr")]
 
 use libm_test::generate::{case_list, edge_cases, random, spaced};
-use libm_test::mpfloat::MpOp;
+use libm_test::mpfloat::{MpFloat, MpOp};
 use libm_test::{CheckBasis, CheckCtx, CheckOutput, GeneratorKind, MathOp, TupleCall};
 
 const BASIS: CheckBasis = CheckBasis::Mpfr;
@@ -77,3 +77,65 @@ libm_macros::for_each_function! {
         nextafterf,
     ],
 }
+
+// fn mp_runner_rem_pio2<F: Float, Args>(ctx: &CheckCtx, cases: impl Iterator<Item = Args>) {
+//     let x = MpFloat::new(prec)
+
+//     // let mut mp_vals = Op::new_mp();
+//     for input in cases {
+//         // let mp_res = Op::run(&mut mp_vals, input);
+//         let crate_res = input.call_intercept_panics(Op::ROUTINE);
+
+//         crate_res.validate(mp_res, input, ctx).unwrap();
+//     }
+// }
+
+// macro_rules! mp_tests_rem_pio2 {
+//     (
+//         fn_name: $fn_name:ident,
+//         attrs: [$($attr:meta),*],
+//     ) => {
+//         paste::paste! {
+//             #[test]
+//             $(#[$attr])*
+//             fn [< mp_case_list_ $fn_name >]() {
+//                 type Op = libm_test::op::sin::Routine;
+//                 let ctx = CheckCtx::new(Op::IDENTIFIER, BASIS, GeneratorKind::List);
+//                 let cases = case_list::get_test_cases_basis::<Op>(&ctx).0;
+//                 mp_runner_rem_pio2(&ctx, cases);
+//             }
+
+//             #[test]
+//             $(#[$attr])*
+//             fn [< mp_random_ $fn_name >]() {
+//                 type Op = libm_test::op::sin::Routine;
+//                 let ctx = CheckCtx::new(Op::IDENTIFIER, BASIS, GeneratorKind::Random);
+//                 let cases = random::get_test_cases::<<Op as MathOp>::RustArgs>(&ctx).0;
+//                 mp_runner_rem_pio2(&ctx, cases);
+//             }
+
+//             #[test]
+//             $(#[$attr])*
+//             fn [< mp_edge_case_ $fn_name >]() {
+//                 type Op = libm_test::op::sin::Routine;
+//                 let ctx = CheckCtx::new(Op::IDENTIFIER, BASIS, GeneratorKind::EdgeCases);
+//                 let cases = edge_cases::get_test_cases::<Op>(&ctx).0;
+//                 mp_runner_rem_pio2(&ctx, cases);
+//             }
+
+//             #[test]
+//             $(#[$attr])*
+//             fn [< mp_quickspace_ $fn_name >]() {
+//                 type Op = libm_test::op::sin::Routine;
+//                 let ctx = CheckCtx::new(Op::IDENTIFIER, BASIS, GeneratorKind::QuickSpaced);
+//                 let cases = spaced::get_test_cases::<Op>(&ctx).0;
+//                 mp_runner_rem_pio2(&ctx, cases);
+//             }
+//         }
+//     };
+// }
+
+// mp_tests_rem_pio2! {
+//     fn_name: rem_pio2,
+//     attrs: [],
+// }

libm/src/math/generic/rem_pio2.rs

@@ -42,6 +42,9 @@ where
     fn large(x: &[Self], y: &mut [Self], e0: i32, prec: usize) -> i32;
 }
 
+/// Return `x % pi/2` as `y[0] + y[1]`.
+///
+/// Caller must handle the case when reduction is not needed: `|x| ~<= pi/4`.
 pub(crate) fn rem_pio2<F>(x: F) -> (i32, F, F)
 where
     F: RemPio2Support,
@@ -56,14 +59,14 @@ where
     if ix <= F::FRAC_5PI_4_HI {
         /* |x| ~<= 5pi/4 */
         if (ix & F::SIG_MASK.hi()) == F::FRAC_PI_2_HI {
-            /* |x| ~= pi/2 or 2pi/2 */
-            return medium(x, ix); /* cancellation -- use medium case */
+            // |x| ~= pi/2 or 2pi/2
+            return medium(x, ix); // cancellation -- use medium case
         }
 
         if ix <= F::FRAC_3PI_4_HI {
-            /* |x| ~<= 3pi/4 */
+            // |x| ~<= 3pi/4
             if pos {
-                let z = x - F::PIO2_1; /* one round good to 85 bits */
+                let z = x - F::PIO2_1; // one round good to 85 bits for f64
                 let y0 = z - F::PIO2_1T;
                 let y1 = (z - y0) - F::PIO2_1T;
                 return (1, y0, y1);