Add f16 and f128 copysign and fabs

Use the generic algorithm to make these two functions available whenever
`f16_enabled` or `f128_enabled` are true. These require the `unstable`
feature.

Author: tgross35

crates/libm-macros/src/lib.rs

@@ -12,6 +12,13 @@ use syn::visit_mut::VisitMut;
 use syn::{Ident, ItemEnum};
 
 const ALL_FUNCTIONS: &[(Ty, Signature, Option<Signature>, &[&str])] = &[
+    (
+        // `fn(f16) -> f16`
+        Ty::F16,
+        Signature { args: &[Ty::F16], returns: &[Ty::F16] },
+        None,
+        &["fabsf16"],
+    ),
     (
         // `fn(f32) -> f32`
         Ty::F32,
@@ -36,6 +43,20 @@ const ALL_FUNCTIONS: &[(Ty, Signature, Option<Signature>, &[&str])] = &[
             "tgamma", "trunc",
         ],
     ),
+    (
+        // `fn(f128) -> f128`
+        Ty::F128,
+        Signature { args: &[Ty::F128], returns: &[Ty::F128] },
+        None,
+        &["fabsf128"],
+    ),
+    (
+        // `(f16, f16) -> f16`
+        Ty::F16,
+        Signature { args: &[Ty::F16, Ty::F16], returns: &[Ty::F16] },
+        None,
+        &["copysignf16"],
+    ),
     (
         // `(f32, f32) -> f32`
         Ty::F32,
@@ -72,6 +93,13 @@ const ALL_FUNCTIONS: &[(Ty, Signature, Option<Signature>, &[&str])] = &[
             "remainder",
         ],
     ),
+    (
+        // `(f128, f128) -> f128`
+        Ty::F128,
+        Signature { args: &[Ty::F128, Ty::F128], returns: &[Ty::F128] },
+        None,
+        &["copysignf128"],
+    ),
     (
         // `(f32, f32, f32) -> f32`
         Ty::F32,

src/libm_helper.rs

@@ -30,7 +30,7 @@ macro_rules! libm_helper {
         }
     };
 
-    ({$($func:tt);*}) => {
+    ({$($func:tt;)*}) => {
         $(
             libm_helper! { $func }
         )*
@@ -103,7 +103,7 @@ libm_helper! {
         (fn trunc(x: f32) -> (f32);                 => truncf);
         (fn y0(x: f32) -> (f32);                    => y0f);
         (fn y1(x: f32) -> (f32);                    => y1f);
-        (fn yn(n: i32, x: f32) -> (f32);            => ynf)
+        (fn yn(n: i32, x: f32) -> (f32);            => ynf);
     }
 }
 
@@ -166,6 +166,24 @@ libm_helper! {
         (fn trunc(x: f64) -> (f64);                 => trunc);
         (fn y0(x: f64) -> (f64);                    => y0);
         (fn y1(x: f64) -> (f64);                    => y1);
-        (fn yn(n: i32, x: f64) -> (f64);            => yn)
+        (fn yn(n: i32, x: f64) -> (f64);            => yn);
+    }
+}
+
+#[cfg(f16_enabled)]
+libm_helper! {
+    f16,
+    funcs: {
+        (fn abs(x: f16) -> (f16);                   => fabsf16);
+        (fn copysign(x: f16, y: f16) -> (f16);      => copysignf16);
+    }
+}
+
+#[cfg(f128_enabled)]
+libm_helper! {
+    f128,
+    funcs: {
+        (fn abs(x: f128) -> (f128);                 => fabsf128);
+        (fn copysign(x: f128, y: f128) -> (f128);   => copysignf128);
     }
 }

src/math/copysignf128.rs

@@ -0,0 +1,8 @@
+/// Sign of Y, magnitude of X (f32)
+///
+/// Constructs a number with the magnitude (absolute value) of its
+/// first argument, `x`, and the sign of its second argument, `y`.
+#[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
+pub fn copysignf128(x: f128, y: f128) -> f128 {
+    super::generic::copysign::copysign(x, y)
+}

src/math/copysignf16.rs

@@ -0,0 +1,8 @@
+/// Sign of Y, magnitude of X (f32)
+///
+/// Constructs a number with the magnitude (absolute value) of its
+/// first argument, `x`, and the sign of its second argument, `y`.
+#[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
+pub fn copysignf16(x: f16, y: f16) -> f16 {
+    super::generic::copysign::copysign(x, y)
+}

src/math/fabsf128.rs

@@ -0,0 +1,5 @@
+/// Absolute value (magnitude) of a `f128` value.
+#[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
+pub fn fabsf128(x: f128) -> f128 {
+    super::generic::abs::abs(x)
+}

src/math/fabsf16.rs

@@ -0,0 +1,5 @@
+/// Absolute value (magnitude) of a `f16` value.
+#[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
+pub fn fabsf16(x: f16) -> f16 {
+    super::generic::abs::abs(x)
+}

src/math/mod.rs

@@ -332,6 +332,26 @@ pub use self::tgammaf::tgammaf;
 pub use self::trunc::trunc;
 pub use self::truncf::truncf;
 
+cfg_if! {
+    if #[cfg(f16_enabled)] {
+        mod copysignf16;
+        mod fabsf16;
+
+        pub use self::fabsf16::fabsf16;
+        pub use self::copysignf16::copysignf16;
+    }
+}
+
+cfg_if! {
+    if #[cfg(f128_enabled)] {
+        mod copysignf128;
+        mod fabsf128;
+
+        pub use self::fabsf128::fabsf128;
+        pub use self::copysignf128::copysignf128;
+    }
+}
+
 #[inline]
 fn get_high_word(x: f64) -> u32 {
     (x.to_bits() >> 32) as u32