Add scalbnf16 and scalbnf128

The `scalbn` functions are similar enough that they can easily be made
generic. Do so and `f16` and `f128` versions.

Author: tgross35

crates/libm-macros/src/shared.rs

@@ -134,6 +134,13 @@ const ALL_OPERATIONS_NESTED: &[(FloatTy, Signature, Option<Signature>, &[&str])]
         None,
         &["jn", "yn"],
     ),
+    (
+        // `(f16, i32) -> f16`
+        FloatTy::F16,
+        Signature { args: &[Ty::F16, Ty::I32], returns: &[Ty::F16] },
+        None,
+        &["scalbnf16"],
+    ),
     (
         // `(f32, i32) -> f32`
         FloatTy::F32,
@@ -148,6 +155,13 @@ const ALL_OPERATIONS_NESTED: &[(FloatTy, Signature, Option<Signature>, &[&str])]
         None,
         &["scalbn", "ldexp"],
     ),
+    (
+        // `(f128, i32) -> f128`
+        FloatTy::F128,
+        Signature { args: &[Ty::F128, Ty::I32], returns: &[Ty::F128] },
+        None,
+        &["scalbnf128"],
+    ),
     (
         // `(f32, &mut f32) -> f32` as `(f32) -> (f32, f32)`
         FloatTy::F32,

crates/libm-test/src/mpfloat.rs

@@ -137,7 +137,7 @@ libm_macros::for_each_function! {
         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, yn, ynf,
-        copysignf16, copysignf128, fabsf16, fabsf128,
+        copysignf16, copysignf128, fabsf16, fabsf128, scalbnf16, scalbnf128,
     ],
     fn_extra: match MACRO_FN_NAME {
         // Remap function names that are different between mpfr and libm

crates/libm-test/src/precision.rs

@@ -403,5 +403,9 @@ fn bessel_prec_dropoff<F: Float>(
 
 impl MaybeOverride<(f32, f32, f32)> for SpecialCase {}
 impl MaybeOverride<(f64, f64, f64)> for SpecialCase {}
+#[cfg(f16_enabled)]
+impl MaybeOverride<(f16, i32)> for SpecialCase {}
 impl MaybeOverride<(f32, i32)> for SpecialCase {}
 impl MaybeOverride<(f64, i32)> for SpecialCase {}
+#[cfg(f128_enabled)]
+impl MaybeOverride<(f128, i32)> for SpecialCase {}

crates/libm-test/tests/compare_built_musl.rs

@@ -47,7 +47,7 @@ where
 libm_macros::for_each_function! {
     callback: musl_rand_tests,
     // Musl does not support `f16` and `f128` on all platforms.
-    skip: [copysignf16, copysignf128, fabsf16, fabsf128],
+    skip: [copysignf16, copysignf128, fabsf16, fabsf128, scalbnf16, scalbnf128],
     attributes: [
         #[cfg_attr(x86_no_sse, ignore)] // FIXME(correctness): wrong result on i586
         [exp10, exp10f, exp2, exp2f, rint]

crates/libm-test/tests/multiprecision.rs

@@ -63,6 +63,8 @@ libm_macros::for_each_function! {
         remquof,
         scalbn,
         scalbnf,
+        scalbnf16,
+        scalbnf128,
 
         // FIXME: test needed, see
         // https://github.com/rust-lang/libm/pull/311#discussion_r1818273392
@@ -158,6 +160,8 @@ libm_macros::for_each_function! {
         remquof,
         scalbn,
         scalbnf,
+        scalbnf16,
+        scalbnf128,
         yn,
         ynf,
 

crates/libm-test/tests/z_extensive/run.rs

@@ -61,6 +61,8 @@ fn register_all_tests() -> Vec<Trial> {
             remquof,
             scalbn,
             scalbnf,
+            scalbnf16,
+            scalbnf128,
 
             // FIXME: test needed, see
             // https://github.com/rust-lang/libm/pull/311#discussion_r1818273392

etc/function-definitions.json

@@ -630,16 +630,32 @@
     "scalbn": {
         "sources": [
             "src/libm_helper.rs",
+            "src/math/generic/scalbn.rs",
             "src/math/scalbn.rs"
         ],
         "type": "f64"
     },
     "scalbnf": {
         "sources": [
+            "src/math/generic/scalbn.rs",
             "src/math/scalbnf.rs"
         ],
         "type": "f32"
     },
+    "scalbnf128": {
+        "sources": [
+            "src/math/generic/scalbn.rs",
+            "src/math/scalbnf128.rs"
+        ],
+        "type": "f128"
+    },
+    "scalbnf16": {
+        "sources": [
+            "src/math/generic/scalbn.rs",
+            "src/math/scalbnf16.rs"
+        ],
+        "type": "f16"
+    },
     "sin": {
         "sources": [
             "src/libm_helper.rs",

etc/function-list.txt

@@ -95,6 +95,8 @@ round
 roundf
 scalbn
 scalbnf
+scalbnf128
+scalbnf16
 sin
 sincos
 sincosf

src/math/generic/mod.rs

@@ -1,5 +1,7 @@
 mod copysign;
 mod fabs;
+mod scalbn;
 
 pub use copysign::copysign;
 pub use fabs::fabs;
+pub use scalbn::scalbn;

src/math/generic/scalbn.rs

@@ -0,0 +1,49 @@
+use super::super::{CastFrom, CastInto, Float, IntTy, MinInt};
+
+pub fn scalbn<F: Float>(mut x: F, mut n: i32) -> F
+where
+    u32: CastInto<F::Int>,
+    F::Int: CastFrom<i32>,
+    F::Int: CastFrom<u32>,
+{
+    // Bits including the implicit bit
+    let sig_total_bits = F::SIG_BITS + 1;
+
+    // Maximum and minimum values when biased
+    let exp_max: i32 = F::EXP_BIAS as i32;
+    let exp_min = -(exp_max - 1);
+
+    // 2 ^ Emax, where Emax is the maximum biased exponent value (1023 for f64)
+    let f_exp_max = F::from_bits(F::Int::cast_from(F::EXP_BIAS << 1) << F::SIG_BITS);
+    // 2 ^ Emin, where Emin is the minimum biased exponent value (-1022 for f64)
+    let f_exp_min = F::from_bits(IntTy::<F>::ONE << F::SIG_BITS);
+    // 2 ^ sig_total_bits, representation of what can be accounted for with subnormals
+    let f_exp_subnorm = F::from_bits((F::EXP_BIAS + sig_total_bits).cast() << F::SIG_BITS);
+
+    if n > exp_max {
+        x *= f_exp_max;
+        n -= exp_max;
+        if n > exp_max {
+            x *= f_exp_max;
+            n -= exp_max;
+            if n > exp_max {
+                n = exp_max;
+            }
+        }
+    } else if n < exp_min {
+        let mul = f_exp_min * f_exp_subnorm;
+        let add = (exp_max - 1) - sig_total_bits as i32;
+
+        x *= mul;
+        n += add;
+        if n < exp_min {
+            x *= mul;
+            n += add;
+            if n < exp_min {
+                n = exp_min;
+            }
+        }
+    }
+
+    x * F::from_bits(F::Int::cast_from(F::EXP_BIAS as i32 + n) << F::SIG_BITS)
+}