wip

Author: tgross35

crates/libm-macros/tests/basic.rs

@@ -2,6 +2,8 @@
 #![feature(f16)]
 #![feature(f128)]
 #![cfg(not(all(target_arch = "x86", target_os = "windows", target_env = "gnu")))]
+#![feature(f128)]
+#![feature(f16)]
 
 macro_rules! basic {
     (

crates/libm-test/src/gen.rs

@@ -6,11 +6,25 @@ pub mod random;
 /// Helper type to turn any reusable input into a generator.
 #[derive(Clone, Debug, Default)]
 pub struct CachedInput {
+    pub inputs_f16: Vec<(f16, f16, f16)>,
     pub inputs_f32: Vec<(f32, f32, f32)>,
     pub inputs_f64: Vec<(f64, f64, f64)>,
+    pub inputs_f128: Vec<(f128, f128, f128)>,
     pub inputs_i32: Vec<(i32, i32, i32)>,
 }
 
+impl GenerateInput<(f16,)> for CachedInput {
+    fn get_cases(&self) -> impl Iterator<Item = (f16,)> {
+        self.inputs_f16.iter().map(|f| (f.0,))
+    }
+}
+
+impl GenerateInput<(f16, f16)> for CachedInput {
+    fn get_cases(&self) -> impl Iterator<Item = (f16, f16)> {
+        self.inputs_f16.iter().map(|f| (f.0, f.1))
+    }
+}
+
 impl GenerateInput<(f32,)> for CachedInput {
     fn get_cases(&self) -> impl Iterator<Item = (f32,)> {
         self.inputs_f32.iter().map(|f| (f.0,))
@@ -70,3 +84,15 @@ impl GenerateInput<(f64, f64, f64)> for CachedInput {
         self.inputs_f64.iter().copied()
     }
 }
+
+impl GenerateInput<(f128,)> for CachedInput {
+    fn get_cases(&self) -> impl Iterator<Item = (f128,)> {
+        self.inputs_f128.iter().map(|f| (f.0,))
+    }
+}
+
+impl GenerateInput<(f128, f128)> for CachedInput {
+    fn get_cases(&self) -> impl Iterator<Item = (f128, f128)> {
+        self.inputs_f128.iter().map(|f| (f.0, f.1))
+    }
+}

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

@@ -42,8 +42,10 @@ static TEST_CASES_JN: LazyLock<CachedInput> = LazyLock::new(|| {
     // These functions are extremely slow, limit them
     let ntests_jn = (NTESTS / 1000).max(80);
     cases.inputs_i32.truncate(ntests_jn);
+    cases.inputs_f16.truncate(ntests_jn);
     cases.inputs_f32.truncate(ntests_jn);
     cases.inputs_f64.truncate(ntests_jn);
+    cases.inputs_f128.truncate(ntests_jn);
 
     // It is easy to overflow the stack with these in debug mode
     let max_iterations = if cfg!(optimizations_enabled) && cfg!(target_pointer_width = "64") {
@@ -68,6 +70,16 @@ fn make_test_cases(ntests: usize) -> CachedInput {
 
     // make sure we include some basic cases
     let mut inputs_i32 = vec![(0, 0, 0), (1, 1, 1), (-1, -1, -1)];
+    let mut inputs_f16 = vec![
+        (0.0, 0.0, 0.0),
+        (f16::EPSILON, f16::EPSILON, f16::EPSILON),
+        (f16::INFINITY, f16::INFINITY, f16::INFINITY),
+        (f16::NEG_INFINITY, f16::NEG_INFINITY, f16::NEG_INFINITY),
+        (f16::MAX, f16::MAX, f16::MAX),
+        (f16::MIN, f16::MIN, f16::MIN),
+        (f16::MIN_POSITIVE, f16::MIN_POSITIVE, f16::MIN_POSITIVE),
+        (f16::NAN, f16::NAN, f16::NAN),
+    ];
     let mut inputs_f32 = vec![
         (0.0, 0.0, 0.0),
         (f32::EPSILON, f32::EPSILON, f32::EPSILON),
@@ -88,11 +100,25 @@ fn make_test_cases(ntests: usize) -> CachedInput {
         (f64::MIN_POSITIVE, f64::MIN_POSITIVE, f64::MIN_POSITIVE),
         (f64::NAN, f64::NAN, f64::NAN),
     ];
+    let mut inputs_f128 = vec![
+        (0.0, 0.0, 0.0),
+        (f128::EPSILON, f128::EPSILON, f128::EPSILON),
+        (f128::INFINITY, f128::INFINITY, f128::INFINITY),
+        (f128::NEG_INFINITY, f128::NEG_INFINITY, f128::NEG_INFINITY),
+        (f128::MAX, f128::MAX, f128::MAX),
+        (f128::MIN, f128::MIN, f128::MIN),
+        (f128::MIN_POSITIVE, f128::MIN_POSITIVE, f128::MIN_POSITIVE),
+        (f128::NAN, f128::NAN, f128::NAN),
+    ];
 
     inputs_i32.extend((0..(ntests - inputs_i32.len())).map(|_| rng.gen::<(i32, i32, i32)>()));
 
     // Generate integers to get a full range of bitpatterns, then convert back to
     // floats.
+    inputs_f16.extend((0..(ntests - inputs_f16.len())).map(|_| {
+        let ints = rng.gen::<(u16, u16, u16)>();
+        (f16::from_bits(ints.0), f16::from_bits(ints.1), f16::from_bits(ints.2))
+    }));
     inputs_f32.extend((0..(ntests - inputs_f32.len())).map(|_| {
         let ints = rng.gen::<(u32, u32, u32)>();
         (f32::from_bits(ints.0), f32::from_bits(ints.1), f32::from_bits(ints.2))
@@ -101,8 +127,12 @@ fn make_test_cases(ntests: usize) -> CachedInput {
         let ints = rng.gen::<(u64, u64, u64)>();
         (f64::from_bits(ints.0), f64::from_bits(ints.1), f64::from_bits(ints.2))
     }));
+    inputs_f128.extend((0..(ntests - inputs_f128.len())).map(|_| {
+        let ints = rng.gen::<(u128, u128, u128)>();
+        (f128::from_bits(ints.0), f128::from_bits(ints.1), f128::from_bits(ints.2))
+    }));
 
-    CachedInput { inputs_f32, inputs_f64, inputs_i32 }
+    CachedInput { inputs_f16, inputs_f32, inputs_f64, inputs_f128, inputs_i32 }
 }
 
 /// Create a test case iterator.

crates/libm-test/src/lib.rs

@@ -1,3 +1,6 @@
+#![cfg_attr(f128_enabled, feature(f128))]
+#![cfg_attr(f16_enabled, feature(f16))]
+
 pub mod gen;
 #[cfg(feature = "test-multiprecision")]
 pub mod mpfloat;