mpfr tests pass locally

Author: tgross35

crates/libm-test/Cargo.toml

@@ -8,7 +8,7 @@ publish = false
 default = ["unstable-float"]
 
 # Propagated from libm because this affects which functions we test.
-unstable-float = ["libm/unstable-float"]
+unstable-float = ["libm/unstable-float", "rug/nightly-float"]
 
 # Generate tests which are random inputs and the outputs are calculated with
 # musl libc.
@@ -21,6 +21,7 @@ build-musl = ["dep:musl-math-sys"]
 [dependencies]
 anyhow = "1.0.90"
 az = { version = "1.2.1", optional = true }
+cfg-if = "1.0.0"
 libm = { path = "../.." }
 libm-macros = { path = "../libm-macros" }
 musl-math-sys = { path = "../musl-math-sys", optional = true }

crates/libm-test/src/mpfloat.rs

@@ -166,6 +166,7 @@ libm_macros::for_each_function! {
         // Most of these need a manual implementation
         fabs, ceil, copysign, floor, rint, round, trunc,
         fabsf, ceilf, copysignf, floorf, rintf, roundf, truncf,
+        fabsf16, fabsf128, copysignf16, copysignf128,
         fmod, fmodf, frexp, frexpf, ilogb, ilogbf, jn, jnf, ldexp, ldexpf,
         lgamma_r, lgammaf_r, modf, modff, nextafter, nextafterf, pow,powf,
         remquo, remquof, scalbn, scalbnf, sincos, sincosf,
@@ -192,8 +193,10 @@ macro_rules! impl_no_round {
     ($($fn_name:ident, $rug_name:ident;)*) => {
         paste::paste! {
             // Implement for both f32 and f64
+            $( impl_no_round!{ @inner_unary [< $fn_name f16 >], (f16,), $rug_name } )*
             $( impl_no_round!{ @inner_unary [< $fn_name f >], (f32,), $rug_name } )*
             $( impl_no_round!{ @inner_unary $fn_name, (f64,), $rug_name } )*
+            $( impl_no_round!{ @inner_unary [< $fn_name f128 >], (f128,), $rug_name } )*
         }
     };
 
@@ -372,3 +375,45 @@ impl_op_for_ty!(f64, "");
 pub mod lgammaf_r {
     pub use super::lgamma_rf::*;
 }
+
+pub mod copysignf16 {
+    use super::*;
+    pub struct Operation(MpFloat, MpFloat);
+
+    impl MpOp for Operation {
+        type Input = (f16, f16);
+        type Output = f16;
+
+        fn new() -> Self {
+            Self(new_mpfloat::<f16>(), new_mpfloat::<f16>())
+        }
+
+        fn run(&mut self, input: Self::Input) -> Self::Output {
+            self.0.assign(input.0);
+            self.1.assign(input.1);
+            self.0.copysign_mut(&self.1);
+            prep_retval::<Self::Output>(&mut self.0, Ordering::Equal)
+        }
+    }
+}
+
+pub mod copysignf128 {
+    use super::*;
+    pub struct Operation(MpFloat, MpFloat);
+
+    impl MpOp for Operation {
+        type Input = (f128, f128);
+        type Output = f128;
+
+        fn new() -> Self {
+            Self(new_mpfloat::<f128>(), new_mpfloat::<f128>())
+        }
+
+        fn run(&mut self, input: Self::Input) -> Self::Output {
+            self.0.assign(input.0);
+            self.1.assign(input.1);
+            self.0.copysign_mut(&self.1);
+            prep_retval::<Self::Output>(&mut self.0, Ordering::Equal)
+        }
+    }
+}

crates/libm-test/src/num_traits.rs

@@ -3,7 +3,7 @@ use std::fmt;
 use crate::{MaybeOverride, SpecialCase, TestResult};
 
 /// Common types and methods for floating point numbers.
-pub trait Float: Copy + fmt::Display + fmt::Debug + PartialEq<Self> {
+pub trait Float: Copy + fmt::Debug + fmt::Debug + PartialEq<Self> {
     type Int: Int<OtherSign = Self::SignedInt, Unsigned = Self::Int>;
     type SignedInt: Int + Int<OtherSign = Self::Int, Unsigned = Self::Int>;
 
@@ -70,6 +70,12 @@ impl_float!(
     f64, u64, i64, 52;
 );
 
+#[cfg(f16_enabled)]
+impl_float!( f16, u16, i16, 10; );
+
+#[cfg(f128_enabled)]
+impl_float!( f128, u128, i128, 112; );
+
 /// Common types and methods for integers.
 pub trait Int: Copy + fmt::Display + fmt::Debug + PartialEq<Self> {
     type OtherSign: Int;
@@ -171,8 +177,10 @@ macro_rules! impl_int {
 }
 
 impl_int!(
+    u16, i16;
     u32, i32;
     u64, i64;
+    u128, i128;
 );
 
 /// A helper trait to print something as hex with the correct number of nibbles, e.g. a `u32`

crates/libm-test/src/precision.rs

@@ -102,6 +102,19 @@ pub trait MaybeOverride<Input> {
     }
 }
 
+#[cfg(f16_enabled)]
+impl MaybeOverride<(f16, f16)> for SpecialCase {
+    fn check_float<F: Float>(
+        input: (f16, f16),
+        _actual: F,
+        expected: F,
+        _ulp: &mut u32,
+        ctx: &CheckCtx,
+    ) -> Option<TestResult> {
+        maybe_skip_binop_nan(input, expected, ctx)
+    }
+}
+
 impl MaybeOverride<(f32,)> for SpecialCase {
     fn check_float<F: Float>(
         input: (f32,),
@@ -115,12 +128,6 @@ impl MaybeOverride<(f32,)> for SpecialCase {
                 // we return infinity but the number is representable
                 return XFAIL;
             }
-
-            if ctx.fname == "sinhf" && input.0.abs() > 80.0 && actual.is_nan() {
-                // we return some NaN that should be real values or infinite
-                // doesn't seem to happen on x86
-                return XFAIL;
-            }
         }
 
         if ctx.fname == "acoshf" && input.0 < -1.0 {
@@ -134,6 +141,12 @@ impl MaybeOverride<(f32,)> for SpecialCase {
             return XFAIL;
         }
 
+        if ctx.fname == "sinhf" && input.0.abs() > 80.0 && actual.is_nan() {
+            // we return some NaN that should be real values or infinite
+            // doesn't seem to happen on x86
+            return XFAIL;
+        }
+
         maybe_check_nan_bits(actual, expected, ctx)
     }
 
@@ -367,7 +380,25 @@ fn bessel_prec_dropoff<F: Float>(
     None
 }
 
+#[cfg(f128_enabled)]
+impl MaybeOverride<(f128, f128)> for SpecialCase {
+    fn check_float<F: Float>(
+        input: (f128, f128),
+        _actual: F,
+        expected: F,
+        _ulp: &mut u32,
+        ctx: &CheckCtx,
+    ) -> Option<TestResult> {
+        maybe_skip_binop_nan(input, expected, ctx)
+    }
+}
+
 impl MaybeOverride<(f32, f32, f32)> for SpecialCase {}
 impl MaybeOverride<(f64, f64, f64)> for SpecialCase {}
 impl MaybeOverride<(f32, i32)> for SpecialCase {}
 impl MaybeOverride<(f64, i32)> for SpecialCase {}
+
+#[cfg(f16_enabled)]
+impl MaybeOverride<(f16,)> for SpecialCase {}
+#[cfg(f128_enabled)]
+impl MaybeOverride<(f128,)> for SpecialCase {}

crates/libm-test/src/test_traits.rs

@@ -175,7 +175,7 @@ where
             // Make sure that the signs are the same before checing ULP to avoid wraparound
             let act_sig = self.signum();
             let exp_sig = expected.signum();
-            ensure!(act_sig == exp_sig, "mismatched signs {act_sig} {exp_sig}");
+            ensure!(act_sig == exp_sig, "mismatched signs {act_sig:?} {exp_sig:?}");
 
             if self.is_infinite() ^ expected.is_infinite() {
                 bail!("mismatched infinities");

crates/libm-test/tests/compare_built_musl.rs

@@ -44,7 +44,8 @@ macro_rules! musl_rand_tests {
 
 libm_macros::for_each_function! {
     callback: musl_rand_tests,
-    skip: [],
+    // Musl has no implementations
+    skip: [copysignf16, copysignf128, fabsf16, fabsf128],
     attributes: [
         #[cfg_attr(x86_no_sse, ignore)] // FIXME(correctness): wrong result on i586
         [exp10, exp10f, exp2, exp2f, rint]

crates/libm-test/tests/multiprecision.rs

@@ -1,6 +1,8 @@
 //! Test with "infinite precision"
 
 #![cfg(feature = "test-multiprecision")]
+#![cfg_attr(f128_enabled, feature(f128))]
+#![cfg_attr(f16_enabled, feature(f16))]
 
 use libm_test::gen::random;
 use libm_test::mpfloat::{self, MpOp};
@@ -16,7 +18,7 @@ macro_rules! multiprec_rand_tests {
         RustFn: $RustFn:ty,
         RustArgs: $RustArgs:ty,
         RustRet: $RustRet:ty,
-        attrs: [$($meta:meta),*]
+        attrs: [$($meta:meta),*],
     ) => {
         paste::paste! {
             #[test]