/rust/registry/src/index.crates.io-1949cf8c6b5b557f/libm-0.2.16/src/math/scalbn.rs

Source
#[cfg(f16_enabled)]
#[cfg_attr(assert_no_panic, no_panic::no_panic)]
pub fn scalbnf16(x: f16, n: i32) -> f16 {
    super::generic::scalbn(x, n)
}

#[cfg_attr(assert_no_panic, no_panic::no_panic)]
pub fn scalbnf(x: f32, n: i32) -> f32 {
    super::generic::scalbn(x, n)
}

#[cfg_attr(assert_no_panic, no_panic::no_panic)]
pub fn scalbn(x: f64, n: i32) -> f64 {
    super::generic::scalbn(x, n)
}

#[cfg(f128_enabled)]
#[cfg_attr(assert_no_panic, no_panic::no_panic)]
pub fn scalbnf128(x: f128, n: i32) -> f128 {
    super::generic::scalbn(x, n)
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::support::{CastFrom, CastInto, Float};

    // Tests against N3220
    fn spec_test<F: Float>(f: impl Fn(F, i32) -> F)
    where
        u32: CastInto<F::Int>,
        F::Int: CastFrom<i32>,
        F::Int: CastFrom<u32>,
    {
        // `scalbn(±0, n)` returns `±0`.
        assert_biteq!(f(F::NEG_ZERO, 10), F::NEG_ZERO);
        assert_biteq!(f(F::NEG_ZERO, 0), F::NEG_ZERO);
        assert_biteq!(f(F::NEG_ZERO, -10), F::NEG_ZERO);
        assert_biteq!(f(F::ZERO, 10), F::ZERO);
        assert_biteq!(f(F::ZERO, 0), F::ZERO);
        assert_biteq!(f(F::ZERO, -10), F::ZERO);

        // `scalbn(x, 0)` returns `x`.
        assert_biteq!(f(F::MIN, 0), F::MIN);
        assert_biteq!(f(F::MAX, 0), F::MAX);
        assert_biteq!(f(F::INFINITY, 0), F::INFINITY);
        assert_biteq!(f(F::NEG_INFINITY, 0), F::NEG_INFINITY);
        assert_biteq!(f(F::ZERO, 0), F::ZERO);
        assert_biteq!(f(F::NEG_ZERO, 0), F::NEG_ZERO);

        // `scalbn(±∞, n)` returns `±∞`.
        assert_biteq!(f(F::INFINITY, 10), F::INFINITY);
        assert_biteq!(f(F::INFINITY, -10), F::INFINITY);
        assert_biteq!(f(F::NEG_INFINITY, 10), F::NEG_INFINITY);
        assert_biteq!(f(F::NEG_INFINITY, -10), F::NEG_INFINITY);

        // NaN should remain NaNs.
        assert!(f(F::NAN, 10).is_nan());
        assert!(f(F::NAN, 0).is_nan());
        assert!(f(F::NAN, -10).is_nan());
        assert!(f(-F::NAN, 10).is_nan());
        assert!(f(-F::NAN, 0).is_nan());
        assert!(f(-F::NAN, -10).is_nan());
    }

    #[test]
    #[cfg(f16_enabled)]
    fn spec_test_f16() {
        spec_test::<f16>(scalbnf16);
    }

    #[test]
    fn spec_test_f32() {
        spec_test::<f32>(scalbnf);
    }

    #[test]
    fn spec_test_f64() {
        spec_test::<f64>(scalbn);
    }

    #[test]
    #[cfg(f128_enabled)]
    fn spec_test_f128() {
        spec_test::<f128>(scalbnf128);
    }
}

Coverage Report

Created: 2026-02-26 07:32

Line	Count	Source
1		#[cfg(f16_enabled)]
2		#[cfg_attr(assert_no_panic, no_panic::no_panic)]
3		pub fn scalbnf16(x: f16, n: i32) -> f16 {
4		super::generic::scalbn(x, n)
5		}
6
7		#[cfg_attr(assert_no_panic, no_panic::no_panic)]
8	0	pub fn scalbnf(x: f32, n: i32) -> f32 {
9	0	super::generic::scalbn(x, n)
10	0	}
11
12		#[cfg_attr(assert_no_panic, no_panic::no_panic)]
13	0	pub fn scalbn(x: f64, n: i32) -> f64 {
14	0	super::generic::scalbn(x, n)
15	0	}
16
17		#[cfg(f128_enabled)]
18		#[cfg_attr(assert_no_panic, no_panic::no_panic)]
19		pub fn scalbnf128(x: f128, n: i32) -> f128 {
20		super::generic::scalbn(x, n)
21		}
22
23		#[cfg(test)]
24		mod tests {
25		use super::*;
26		use crate::support::{CastFrom, CastInto, Float};
27
28		// Tests against N3220
29		fn spec_test<F: Float>(f: impl Fn(F, i32) -> F)
30		where
31		u32: CastInto<F::Int>,
32		F::Int: CastFrom<i32>,
33		F::Int: CastFrom<u32>,
34		{
35		// `scalbn(±0, n)` returns `±0`.
36		assert_biteq!(f(F::NEG_ZERO, 10), F::NEG_ZERO);
37		assert_biteq!(f(F::NEG_ZERO, 0), F::NEG_ZERO);
38		assert_biteq!(f(F::NEG_ZERO, -10), F::NEG_ZERO);
39		assert_biteq!(f(F::ZERO, 10), F::ZERO);
40		assert_biteq!(f(F::ZERO, 0), F::ZERO);
41		assert_biteq!(f(F::ZERO, -10), F::ZERO);
42
43		// `scalbn(x, 0)` returns `x`.
44		assert_biteq!(f(F::MIN, 0), F::MIN);
45		assert_biteq!(f(F::MAX, 0), F::MAX);
46		assert_biteq!(f(F::INFINITY, 0), F::INFINITY);
47		assert_biteq!(f(F::NEG_INFINITY, 0), F::NEG_INFINITY);
48		assert_biteq!(f(F::ZERO, 0), F::ZERO);
49		assert_biteq!(f(F::NEG_ZERO, 0), F::NEG_ZERO);
50
51		// `scalbn(±∞, n)` returns `±∞`.
52		assert_biteq!(f(F::INFINITY, 10), F::INFINITY);
53		assert_biteq!(f(F::INFINITY, -10), F::INFINITY);
54		assert_biteq!(f(F::NEG_INFINITY, 10), F::NEG_INFINITY);
55		assert_biteq!(f(F::NEG_INFINITY, -10), F::NEG_INFINITY);
56
57		// NaN should remain NaNs.
58		assert!(f(F::NAN, 10).is_nan());
59		assert!(f(F::NAN, 0).is_nan());
60		assert!(f(F::NAN, -10).is_nan());
61		assert!(f(-F::NAN, 10).is_nan());
62		assert!(f(-F::NAN, 0).is_nan());
63		assert!(f(-F::NAN, -10).is_nan());
64		}
65
66		#[test]
67		#[cfg(f16_enabled)]
68		fn spec_test_f16() {
69		spec_test::<f16>(scalbnf16);
70		}
71
72		#[test]
73		fn spec_test_f32() {
74		spec_test::<f32>(scalbnf);
75		}
76
77		#[test]
78		fn spec_test_f64() {
79		spec_test::<f64>(scalbn);
80		}
81
82		#[test]
83		#[cfg(f128_enabled)]
84		fn spec_test_f128() {
85		spec_test::<f128>(scalbnf128);
86		}
87		}