diff --git a/library/coretests/Cargo.toml b/library/coretests/Cargo.toml
index e0ddcd466aea5..1b67672267299 100644
--- a/library/coretests/Cargo.toml
+++ b/library/coretests/Cargo.toml
@@ -36,4 +36,6 @@ check-cfg = [
     'cfg(target_has_reliable_f16_math)',
     'cfg(target_has_reliable_f128)',
     'cfg(target_has_reliable_f128_math)',
+    # Set by Cranelift codegen tests; f16/f128 math functions are not supported there.
+    'cfg(randomized_layouts)',
 ]
diff --git a/library/coretests/tests/floats/mod.rs b/library/coretests/tests/floats/mod.rs
index 63d5b8fb2c6e9..b6b2461df74de 100644
--- a/library/coretests/tests/floats/mod.rs
+++ b/library/coretests/tests/floats/mod.rs
@@ -807,8 +807,8 @@ float_test! {
     attrs: {
         const: #[cfg(false)],
         // FIXME(f16_f128): `powi` does not work in Miri for these types
-        f16: #[cfg(all(not(miri), target_has_reliable_f16_math))],
-        f128: #[cfg(all(not(miri), target_has_reliable_f128_math))],
+        f16: #[cfg(all(not(miri), not(randomized_layouts), target_has_reliable_f16_math))],
+        f128: #[cfg(all(not(miri), not(randomized_layouts), target_has_reliable_f128_math))],
     },
     test<Float> {
         // test if large differences in magnitude are still correctly computed.
@@ -1448,8 +1448,8 @@ float_test! {
     attrs: {
         const: #[cfg(false)],
         // FIXME(f16_f128): `powi` does not work in Miri for these types
-        f16: #[cfg(all(not(miri), target_has_reliable_f16_math))],
-        f128: #[cfg(all(not(miri), target_has_reliable_f128_math))],
+        f16: #[cfg(all(not(miri), not(randomized_layouts), target_has_reliable_f16_math))],
+        f128: #[cfg(all(not(miri), not(randomized_layouts), target_has_reliable_f128_math))],
     },
     test<Float> {
         let nan: Float = Float::NAN;
@@ -1582,3 +1582,275 @@ float_test! {
         assert_biteq!((flt(-3.2)).mul_add(2.4, neg_inf), neg_inf);
     }
 }
+
+float_test! {
+    name: exp,
+    attrs: {
+        const: #[cfg(false)],
+        f16: #[cfg(all(not(miri), not(randomized_layouts), target_has_reliable_f16_math))],
+        const f16: #[cfg(false)],
+        f128: #[cfg(all(not(miri), not(randomized_layouts), target_has_reliable_f128_math))],
+        const f128: #[cfg(false)],
+    },
+    test<Float> {
+        let nan: Float = Float::NAN;
+        let inf: Float = Float::INFINITY;
+        let neg_inf: Float = Float::NEG_INFINITY;
+        assert_biteq!((0.0 as Float).exp(), 1.0);
+        assert_approx_eq!((1.0 as Float).exp(), 2.718281828459045235360287471352662497759);
+        assert_approx_eq!((5.0 as Float).exp(), 148.4131591025766034211155800405522796234);
+        assert_biteq!(inf.exp(), inf);
+        assert_biteq!(neg_inf.exp(), 0.0);
+        assert!(nan.exp().is_nan());
+    }
+}
+
+float_test! {
+    name: exp2,
+    attrs: {
+        const: #[cfg(false)],
+        f16: #[cfg(all(not(miri), not(randomized_layouts), target_has_reliable_f16_math))],
+        const f16: #[cfg(false)],
+        f128: #[cfg(all(not(miri), not(randomized_layouts), target_has_reliable_f128_math))],
+        const f128: #[cfg(false)],
+    },
+    test<Float> {
+        let nan: Float = Float::NAN;
+        let inf: Float = Float::INFINITY;
+        let neg_inf: Float = Float::NEG_INFINITY;
+        assert_biteq!((0.0 as Float).exp2(), 1.0);
+        assert_biteq!((5.0 as Float).exp2(), 32.0);
+        assert_biteq!(inf.exp2(), inf);
+        assert_biteq!(neg_inf.exp2(), 0.0);
+        assert!(nan.exp2().is_nan());
+    }
+}
+
+float_test! {
+    name: ln,
+    attrs: {
+        const: #[cfg(false)],
+        f16: #[cfg(all(not(miri), not(randomized_layouts), target_has_reliable_f16_math))],
+        const f16: #[cfg(false)],
+        f128: #[cfg(all(not(miri), not(randomized_layouts), target_has_reliable_f128_math))],
+        const f128: #[cfg(false)],
+    },
+    test<Float> {
+        let nan: Float = Float::NAN;
+        let inf: Float = Float::INFINITY;
+        let neg_inf: Float = Float::NEG_INFINITY;
+        assert_approx_eq!((1.0 as Float).exp().ln(), 1.0);
+        assert!(nan.ln().is_nan());
+        assert_biteq!(inf.ln(), inf);
+        assert!(neg_inf.ln().is_nan());
+        assert!((-2.3 as Float).ln().is_nan());
+        assert_biteq!((-0.0 as Float).ln(), neg_inf);
+        assert_biteq!((0.0 as Float).ln(), neg_inf);
+        assert_approx_eq!((4.0 as Float).ln(), 1.386294361119890618834464242916353136);
+    }
+}
+
+float_test! {
+    name: log,
+    attrs: {
+        const: #[cfg(false)],
+        f16: #[cfg(all(not(miri), not(randomized_layouts), target_has_reliable_f16_math))],
+        const f16: #[cfg(false)],
+        f128: #[cfg(all(not(miri), not(randomized_layouts), target_has_reliable_f128_math))],
+        const f128: #[cfg(false)],
+    },
+    test<Float> {
+        let nan: Float = Float::NAN;
+        let inf: Float = Float::INFINITY;
+        let neg_inf: Float = Float::NEG_INFINITY;
+        assert_biteq!((10.0 as Float).log(10.0), 1.0);
+        assert_approx_eq!((2.3 as Float).log(3.5), 0.664857711361478710036766645911922010272);
+        assert_biteq!((1.0 as Float).exp().log((1.0 as Float).exp()), 1.0);
+        assert!((1.0 as Float).log(1.0).is_nan());
+        assert!((1.0 as Float).log(-13.9).is_nan());
+        assert!(nan.log(2.3).is_nan());
+        assert_biteq!(inf.log(10.0), inf);
+        assert!(neg_inf.log(8.8).is_nan());
+        assert!((-2.3 as Float).log(0.1).is_nan());
+        assert_biteq!((-0.0 as Float).log(2.0), neg_inf);
+        assert_biteq!((0.0 as Float).log(7.0), neg_inf);
+    }
+}
+
+float_test! {
+    name: log2,
+    attrs: {
+        const: #[cfg(false)],
+        f16: #[cfg(all(not(miri), not(randomized_layouts), target_has_reliable_f16_math))],
+        const f16: #[cfg(false)],
+        f128: #[cfg(all(not(miri), not(randomized_layouts), target_has_reliable_f128_math))],
+        const f128: #[cfg(false)],
+    },
+    test<Float> {
+        let nan: Float = Float::NAN;
+        let inf: Float = Float::INFINITY;
+        let neg_inf: Float = Float::NEG_INFINITY;
+        assert_approx_eq!((10.0 as Float).log2(), 3.32192809488736234787031942948939017);
+        assert_approx_eq!((2.3 as Float).log2(), 1.2016338611696504130002982471978765921);
+        assert_approx_eq!((1.0 as Float).exp().log2(), 1.4426950408889634073599246810018921381);
+        assert!(nan.log2().is_nan());
+        assert_biteq!(inf.log2(), inf);
+        assert!(neg_inf.log2().is_nan());
+        assert!((-2.3 as Float).log2().is_nan());
+        assert_biteq!((-0.0 as Float).log2(), neg_inf);
+        assert_biteq!((0.0 as Float).log2(), neg_inf);
+    }
+}
+
+float_test! {
+    name: log10,
+    attrs: {
+        const: #[cfg(false)],
+        f16: #[cfg(all(not(miri), not(randomized_layouts), target_has_reliable_f16_math))],
+        const f16: #[cfg(false)],
+        f128: #[cfg(all(not(miri), not(randomized_layouts), target_has_reliable_f128_math))],
+        const f128: #[cfg(false)],
+    },
+    test<Float> {
+        let nan: Float = Float::NAN;
+        let inf: Float = Float::INFINITY;
+        let neg_inf: Float = Float::NEG_INFINITY;
+        assert_biteq!((10.0 as Float).log10(), 1.0);
+        assert_approx_eq!((2.3 as Float).log10(), 0.36172783601759284532595218865859309898);
+        assert_approx_eq!((1.0 as Float).exp().log10(), 0.43429448190325182765112891891660508222);
+        assert_biteq!((1.0 as Float).log10(), 0.0);
+        assert!(nan.log10().is_nan());
+        assert_biteq!(inf.log10(), inf);
+        assert!(neg_inf.log10().is_nan());
+        assert!((-2.3 as Float).log10().is_nan());
+        assert_biteq!((-0.0 as Float).log10(), neg_inf);
+        assert_biteq!((0.0 as Float).log10(), neg_inf);
+    }
+}
+
+float_test! {
+    name: asinh,
+    attrs: {
+        const: #[cfg(false)],
+        f16: #[cfg(all(not(miri), not(randomized_layouts), target_has_reliable_f16_math))],
+        const f16: #[cfg(false)],
+        f128: #[cfg(all(not(miri), not(randomized_layouts), target_has_reliable_f128_math))],
+        const f128: #[cfg(false)],
+    },
+    test<Float> {
+        let nan: Float = Float::NAN;
+        let inf: Float = Float::INFINITY;
+        let neg_inf: Float = Float::NEG_INFINITY;
+        assert_biteq!((0.0 as Float).asinh(), 0.0);
+        assert_biteq!((-0.0 as Float).asinh(), -0.0);
+        assert_biteq!(inf.asinh(), inf);
+        assert_biteq!(neg_inf.asinh(), neg_inf);
+        assert!(nan.asinh().is_nan());
+        assert!((-0.0 as Float).asinh().is_sign_negative());
+        // issue 63271
+        assert_approx_eq!((2.0 as Float).asinh(), 1.443635475178810342493276740273105);
+        assert_approx_eq!((-2.0 as Float).asinh(), -1.443635475178810342493276740273105);
+    }
+}
+
+float_test! {
+    name: acosh,
+    attrs: {
+        const: #[cfg(false)],
+        f16: #[cfg(all(not(miri), not(randomized_layouts), target_has_reliable_f16_math))],
+        const f16: #[cfg(false)],
+        f128: #[cfg(all(not(miri), not(randomized_layouts), target_has_reliable_f128_math))],
+        const f128: #[cfg(false)],
+    },
+    test<Float> {
+        let nan: Float = Float::NAN;
+        let inf: Float = Float::INFINITY;
+        let neg_inf: Float = Float::NEG_INFINITY;
+        assert_biteq!((1.0 as Float).acosh(), 0.0);
+        assert!((0.999 as Float).acosh().is_nan());
+        assert_biteq!(inf.acosh(), inf);
+        assert!(neg_inf.acosh().is_nan());
+        assert!(nan.acosh().is_nan());
+        assert_approx_eq!((2.0 as Float).acosh(), 1.31695789692481670862504634730796844);
+        assert_approx_eq!((3.0 as Float).acosh(), 1.76274717403908605046521864995958461);
+    }
+}
+
+float_test! {
+    name: atanh,
+    attrs: {
+        const: #[cfg(false)],
+        f16: #[cfg(all(not(miri), not(randomized_layouts), target_has_reliable_f16_math))],
+        const f16: #[cfg(false)],
+        f128: #[cfg(all(not(miri), not(randomized_layouts), target_has_reliable_f128_math))],
+        const f128: #[cfg(false)],
+    },
+    test<Float> {
+        let nan: Float = Float::NAN;
+        let inf: Float = Float::INFINITY;
+        let neg_inf: Float = Float::NEG_INFINITY;
+        assert_biteq!((0.0 as Float).atanh(), 0.0);
+        assert_biteq!((-0.0 as Float).atanh(), -0.0);
+        assert_biteq!((1.0 as Float).atanh(), inf);
+        assert_biteq!((-1.0 as Float).atanh(), neg_inf);
+        assert!((2.0 as Float).atanh().is_nan());
+        assert!((-2.0 as Float).atanh().is_nan());
+        assert!(inf.atanh().is_nan());
+        assert!(neg_inf.atanh().is_nan());
+        assert!(nan.atanh().is_nan());
+        assert_approx_eq!((0.5 as Float).atanh(), 0.54930614433405484569762261846126285);
+        assert_approx_eq!((-0.5 as Float).atanh(), -0.54930614433405484569762261846126285);
+    }
+}
+
+float_test! {
+    name: gamma,
+    attrs: {
+        const: #[cfg(false)],
+        f16: #[cfg(all(not(miri), not(randomized_layouts), target_has_reliable_f16_math))],
+        const f16: #[cfg(false)],
+        f128: #[cfg(all(not(miri), not(randomized_layouts), target_has_reliable_f128_math))],
+        const f128: #[cfg(false)],
+    },
+    test<Float> {
+        let nan: Float = Float::NAN;
+        let inf: Float = Float::INFINITY;
+        let neg_inf: Float = Float::NEG_INFINITY;
+        // precision can differ among platforms
+        assert_approx_eq!((1.0 as Float).gamma(), 1.0);
+        assert_approx_eq!((2.0 as Float).gamma(), 1.0);
+        assert_approx_eq!((3.0 as Float).gamma(), 2.0);
+        assert_approx_eq!((4.0 as Float).gamma(), 6.0);
+        assert_approx_eq!((5.0 as Float).gamma(), 24.0);
+        assert_approx_eq!((0.5 as Float).gamma(), Float::PI.sqrt());
+        assert_approx_eq!((-0.5 as Float).gamma(), -2.0 * Float::PI.sqrt());
+        assert_biteq!((0.0 as Float).gamma(), inf);
+        assert_biteq!((-0.0 as Float).gamma(), neg_inf);
+        assert!((-1.0 as Float).gamma().is_nan());
+        assert!((-2.0 as Float).gamma().is_nan());
+        assert!(nan.gamma().is_nan());
+        assert!(neg_inf.gamma().is_nan());
+        assert_biteq!(inf.gamma(), inf);
+    }
+}
+
+float_test! {
+    name: ln_gamma,
+    attrs: {
+        const: #[cfg(false)],
+        f16: #[cfg(all(not(miri), not(randomized_layouts), target_has_reliable_f16_math))],
+        const f16: #[cfg(false)],
+        f128: #[cfg(all(not(miri), not(randomized_layouts), target_has_reliable_f128_math))],
+        const f128: #[cfg(false)],
+    },
+    test<Float> {
+        assert_approx_eq!((1.0 as Float).ln_gamma().0, 0.0);
+        assert_eq!((1.0 as Float).ln_gamma().1, 1);
+        assert_approx_eq!((2.0 as Float).ln_gamma().0, 0.0);
+        assert_eq!((2.0 as Float).ln_gamma().1, 1);
+        assert_approx_eq!((3.0 as Float).ln_gamma().0, (2.0 as Float).ln());
+        assert_eq!((3.0 as Float).ln_gamma().1, 1);
+        assert_approx_eq!((-0.5 as Float).ln_gamma().0, (2.0 * Float::PI.sqrt()).ln());
+        assert_eq!((-0.5 as Float).ln_gamma().1, -1);
+    }
+}
diff --git a/library/std/tests/floats/f128.rs b/library/std/tests/floats/f128.rs
index e7c90faa05c23..72ed6f0b71f67 100644
--- a/library/std/tests/floats/f128.rs
+++ b/library/std/tests/floats/f128.rs
@@ -6,12 +6,6 @@ use std::ops::{Add, Div, Mul, Sub};
 
 // Note these tolerances make sense around zero, but not for more extreme exponents.
 
-/// Default tolerances. Works for values that should be near precise but not exact. Roughly
-/// the precision carried by `100 * 100`.
-#[cfg(not(miri))]
-#[cfg(target_has_reliable_f128_math)]
-const TOL: f128 = 1e-12;
-
 /// For operations that are near exact, usually not involving math of different
 /// signs.
 const TOL_PRECISE: f128 = 1e-28;
@@ -65,220 +59,6 @@ fn test_powf() {
     assert_eq!(neg_inf.powf(3.0), neg_inf);
 }
 
-#[test]
-#[cfg(not(miri))]
-#[cfg(target_has_reliable_f128_math)]
-fn test_exp() {
-    assert_eq!(1.0, 0.0f128.exp());
-    assert_approx_eq!(consts::E, 1.0f128.exp(), TOL);
-    assert_approx_eq!(148.41315910257660342111558004055227962348775, 5.0f128.exp(), TOL);
-
-    let inf: f128 = f128::INFINITY;
-    let neg_inf: f128 = f128::NEG_INFINITY;
-    let nan: f128 = f128::NAN;
-    assert_eq!(inf, inf.exp());
-    assert_eq!(0.0, neg_inf.exp());
-    assert!(nan.exp().is_nan());
-}
-
-#[test]
-#[cfg(not(miri))]
-#[cfg(target_has_reliable_f128_math)]
-fn test_exp2() {
-    assert_eq!(32.0, 5.0f128.exp2());
-    assert_eq!(1.0, 0.0f128.exp2());
-
-    let inf: f128 = f128::INFINITY;
-    let neg_inf: f128 = f128::NEG_INFINITY;
-    let nan: f128 = f128::NAN;
-    assert_eq!(inf, inf.exp2());
-    assert_eq!(0.0, neg_inf.exp2());
-    assert!(nan.exp2().is_nan());
-}
-
-#[test]
-#[cfg(not(miri))]
-#[cfg(target_has_reliable_f128_math)]
-fn test_ln() {
-    let nan: f128 = f128::NAN;
-    let inf: f128 = f128::INFINITY;
-    let neg_inf: f128 = f128::NEG_INFINITY;
-    assert_approx_eq!(1.0f128.exp().ln(), 1.0, TOL);
-    assert!(nan.ln().is_nan());
-    assert_eq!(inf.ln(), inf);
-    assert!(neg_inf.ln().is_nan());
-    assert!((-2.3f128).ln().is_nan());
-    assert_eq!((-0.0f128).ln(), neg_inf);
-    assert_eq!(0.0f128.ln(), neg_inf);
-    assert_approx_eq!(4.0f128.ln(), 1.3862943611198906188344642429163531366, TOL);
-}
-
-#[test]
-#[cfg(not(miri))]
-#[cfg(target_has_reliable_f128_math)]
-fn test_log() {
-    let nan: f128 = f128::NAN;
-    let inf: f128 = f128::INFINITY;
-    let neg_inf: f128 = f128::NEG_INFINITY;
-    assert_eq!(10.0f128.log(10.0), 1.0);
-    assert_approx_eq!(2.3f128.log(3.5), 0.66485771361478710036766645911922010272, TOL);
-    assert_eq!(1.0f128.exp().log(1.0f128.exp()), 1.0);
-    assert!(1.0f128.log(1.0).is_nan());
-    assert!(1.0f128.log(-13.9).is_nan());
-    assert!(nan.log(2.3).is_nan());
-    assert_eq!(inf.log(10.0), inf);
-    assert!(neg_inf.log(8.8).is_nan());
-    assert!((-2.3f128).log(0.1).is_nan());
-    assert_eq!((-0.0f128).log(2.0), neg_inf);
-    assert_eq!(0.0f128.log(7.0), neg_inf);
-}
-
-#[test]
-#[cfg(not(miri))]
-#[cfg(target_has_reliable_f128_math)]
-fn test_log2() {
-    let nan: f128 = f128::NAN;
-    let inf: f128 = f128::INFINITY;
-    let neg_inf: f128 = f128::NEG_INFINITY;
-    assert_approx_eq!(10.0f128.log2(), 3.32192809488736234787031942948939017, TOL);
-    assert_approx_eq!(2.3f128.log2(), 1.2016338611696504130002982471978765921, TOL);
-    assert_approx_eq!(1.0f128.exp().log2(), 1.4426950408889634073599246810018921381, TOL);
-    assert!(nan.log2().is_nan());
-    assert_eq!(inf.log2(), inf);
-    assert!(neg_inf.log2().is_nan());
-    assert!((-2.3f128).log2().is_nan());
-    assert_eq!((-0.0f128).log2(), neg_inf);
-    assert_eq!(0.0f128.log2(), neg_inf);
-}
-
-#[test]
-#[cfg(not(miri))]
-#[cfg(target_has_reliable_f128_math)]
-fn test_log10() {
-    let nan: f128 = f128::NAN;
-    let inf: f128 = f128::INFINITY;
-    let neg_inf: f128 = f128::NEG_INFINITY;
-    assert_eq!(10.0f128.log10(), 1.0);
-    assert_approx_eq!(2.3f128.log10(), 0.36172783601759284532595218865859309898, TOL);
-    assert_approx_eq!(1.0f128.exp().log10(), 0.43429448190325182765112891891660508222, TOL);
-    assert_eq!(1.0f128.log10(), 0.0);
-    assert!(nan.log10().is_nan());
-    assert_eq!(inf.log10(), inf);
-    assert!(neg_inf.log10().is_nan());
-    assert!((-2.3f128).log10().is_nan());
-    assert_eq!((-0.0f128).log10(), neg_inf);
-    assert_eq!(0.0f128.log10(), neg_inf);
-}
-
-#[test]
-#[cfg(not(miri))]
-#[cfg(target_has_reliable_f128_math)]
-fn test_asinh() {
-    // Lower accuracy results are allowed, use increased tolerances
-    assert_eq!(0.0f128.asinh(), 0.0f128);
-    assert_eq!((-0.0f128).asinh(), -0.0f128);
-
-    let inf: f128 = f128::INFINITY;
-    let neg_inf: f128 = f128::NEG_INFINITY;
-    let nan: f128 = f128::NAN;
-    assert_eq!(inf.asinh(), inf);
-    assert_eq!(neg_inf.asinh(), neg_inf);
-    assert!(nan.asinh().is_nan());
-    assert!((-0.0f128).asinh().is_sign_negative());
-
-    // issue 63271
-    assert_approx_eq!(2.0f128.asinh(), 1.443635475178810342493276740273105f128, TOL_IMPR);
-    assert_approx_eq!((-2.0f128).asinh(), -1.443635475178810342493276740273105f128, TOL_IMPR);
-    // regression test for the catastrophic cancellation fixed in 72486
-    assert_approx_eq!(
-        (-67452098.07139316f128).asinh(),
-        -18.720075426274544393985484294000831757220,
-        TOL_IMPR
-    );
-
-    // test for low accuracy from issue 104548
-    assert_approx_eq!(60.0f128, 60.0f128.sinh().asinh(), TOL_IMPR);
-    // mul needed for approximate comparison to be meaningful
-    assert_approx_eq!(1.0f128, 1e-15f128.sinh().asinh() * 1e15f128, TOL_IMPR);
-}
-
-#[test]
-#[cfg(not(miri))]
-#[cfg(target_has_reliable_f128_math)]
-fn test_acosh() {
-    assert_eq!(1.0f128.acosh(), 0.0f128);
-    assert!(0.999f128.acosh().is_nan());
-
-    let inf: f128 = f128::INFINITY;
-    let neg_inf: f128 = f128::NEG_INFINITY;
-    let nan: f128 = f128::NAN;
-    assert_eq!(inf.acosh(), inf);
-    assert!(neg_inf.acosh().is_nan());
-    assert!(nan.acosh().is_nan());
-    assert_approx_eq!(2.0f128.acosh(), 1.31695789692481670862504634730796844f128, TOL_IMPR);
-    assert_approx_eq!(3.0f128.acosh(), 1.76274717403908605046521864995958461f128, TOL_IMPR);
-
-    // test for low accuracy from issue 104548
-    assert_approx_eq!(60.0f128, 60.0f128.cosh().acosh(), TOL_IMPR);
-}
-
-#[test]
-#[cfg(not(miri))]
-#[cfg(target_has_reliable_f128_math)]
-fn test_atanh() {
-    assert_eq!(0.0f128.atanh(), 0.0f128);
-    assert_eq!((-0.0f128).atanh(), -0.0f128);
-
-    let inf: f128 = f128::INFINITY;
-    let neg_inf: f128 = f128::NEG_INFINITY;
-    let nan: f128 = f128::NAN;
-    assert_eq!(1.0f128.atanh(), inf);
-    assert_eq!((-1.0f128).atanh(), neg_inf);
-    assert!(2f128.atanh().atanh().is_nan());
-    assert!((-2f128).atanh().atanh().is_nan());
-    assert!(inf.atanh().is_nan());
-    assert!(neg_inf.atanh().is_nan());
-    assert!(nan.atanh().is_nan());
-    assert_approx_eq!(0.5f128.atanh(), 0.54930614433405484569762261846126285f128, TOL_IMPR);
-    assert_approx_eq!((-0.5f128).atanh(), -0.54930614433405484569762261846126285f128, TOL_IMPR);
-}
-
-#[test]
-#[cfg(not(miri))]
-#[cfg(target_has_reliable_f128_math)]
-fn test_gamma() {
-    // precision can differ among platforms
-    assert_approx_eq!(1.0f128.gamma(), 1.0f128, TOL_IMPR);
-    assert_approx_eq!(2.0f128.gamma(), 1.0f128, TOL_IMPR);
-    assert_approx_eq!(3.0f128.gamma(), 2.0f128, TOL_IMPR);
-    assert_approx_eq!(4.0f128.gamma(), 6.0f128, TOL_IMPR);
-    assert_approx_eq!(5.0f128.gamma(), 24.0f128, TOL_IMPR);
-    assert_approx_eq!(0.5f128.gamma(), consts::PI.sqrt(), TOL_IMPR);
-    assert_approx_eq!((-0.5f128).gamma(), -2.0 * consts::PI.sqrt(), TOL_IMPR);
-    assert_eq!(0.0f128.gamma(), f128::INFINITY);
-    assert_eq!((-0.0f128).gamma(), f128::NEG_INFINITY);
-    assert!((-1.0f128).gamma().is_nan());
-    assert!((-2.0f128).gamma().is_nan());
-    assert!(f128::NAN.gamma().is_nan());
-    assert!(f128::NEG_INFINITY.gamma().is_nan());
-    assert_eq!(f128::INFINITY.gamma(), f128::INFINITY);
-    assert_eq!(1760.9f128.gamma(), f128::INFINITY);
-}
-
-#[test]
-#[cfg(not(miri))]
-#[cfg(target_has_reliable_f128_math)]
-fn test_ln_gamma() {
-    assert_approx_eq!(1.0f128.ln_gamma().0, 0.0f128, TOL_IMPR);
-    assert_eq!(1.0f128.ln_gamma().1, 1);
-    assert_approx_eq!(2.0f128.ln_gamma().0, 0.0f128, TOL_IMPR);
-    assert_eq!(2.0f128.ln_gamma().1, 1);
-    assert_approx_eq!(3.0f128.ln_gamma().0, 2.0f128.ln(), TOL_IMPR);
-    assert_eq!(3.0f128.ln_gamma().1, 1);
-    assert_approx_eq!((-0.5f128).ln_gamma().0, (2.0 * consts::PI.sqrt()).ln(), TOL_IMPR);
-    assert_eq!((-0.5f128).ln_gamma().1, -1);
-}
-
 #[test]
 fn test_real_consts() {
     let pi: f128 = consts::PI;
diff --git a/library/std/tests/floats/f16.rs b/library/std/tests/floats/f16.rs
index 0f8b4138d2266..8a24852a8afc1 100644
--- a/library/std/tests/floats/f16.rs
+++ b/library/std/tests/floats/f16.rs
@@ -30,6 +30,9 @@ macro_rules! assert_f16_biteq {
     };
 }
 
+// FIXME(f16_f128,miri): many of these have to be disabled since miri does not yet support
+// the intrinsics.
+
 #[test]
 #[cfg(not(miri))]
 #[cfg(target_has_reliable_f16_math)]
@@ -48,214 +51,6 @@ fn test_powf() {
     assert_eq!(neg_inf.powf(3.0), neg_inf);
 }
 
-#[test]
-#[cfg(not(miri))]
-#[cfg(target_has_reliable_f16_math)]
-fn test_exp() {
-    assert_eq!(1.0, 0.0f16.exp());
-    assert_approx_eq!(2.718282, 1.0f16.exp(), TOL_0);
-    assert_approx_eq!(148.413159, 5.0f16.exp(), TOL_0);
-
-    let inf: f16 = f16::INFINITY;
-    let neg_inf: f16 = f16::NEG_INFINITY;
-    let nan: f16 = f16::NAN;
-    assert_eq!(inf, inf.exp());
-    assert_eq!(0.0, neg_inf.exp());
-    assert!(nan.exp().is_nan());
-}
-
-#[test]
-#[cfg(not(miri))]
-#[cfg(target_has_reliable_f16_math)]
-fn test_exp2() {
-    assert_eq!(32.0, 5.0f16.exp2());
-    assert_eq!(1.0, 0.0f16.exp2());
-
-    let inf: f16 = f16::INFINITY;
-    let neg_inf: f16 = f16::NEG_INFINITY;
-    let nan: f16 = f16::NAN;
-    assert_eq!(inf, inf.exp2());
-    assert_eq!(0.0, neg_inf.exp2());
-    assert!(nan.exp2().is_nan());
-}
-
-#[test]
-#[cfg(not(miri))]
-#[cfg(target_has_reliable_f16_math)]
-fn test_ln() {
-    let nan: f16 = f16::NAN;
-    let inf: f16 = f16::INFINITY;
-    let neg_inf: f16 = f16::NEG_INFINITY;
-    assert_approx_eq!(1.0f16.exp().ln(), 1.0, TOL_0);
-    assert!(nan.ln().is_nan());
-    assert_eq!(inf.ln(), inf);
-    assert!(neg_inf.ln().is_nan());
-    assert!((-2.3f16).ln().is_nan());
-    assert_eq!((-0.0f16).ln(), neg_inf);
-    assert_eq!(0.0f16.ln(), neg_inf);
-    assert_approx_eq!(4.0f16.ln(), 1.386294, TOL_0);
-}
-
-#[test]
-#[cfg(not(miri))]
-#[cfg(target_has_reliable_f16_math)]
-fn test_log() {
-    let nan: f16 = f16::NAN;
-    let inf: f16 = f16::INFINITY;
-    let neg_inf: f16 = f16::NEG_INFINITY;
-    assert_eq!(10.0f16.log(10.0), 1.0);
-    assert_approx_eq!(2.3f16.log(3.5), 0.664858, TOL_0);
-    assert_eq!(1.0f16.exp().log(1.0f16.exp()), 1.0);
-    assert!(1.0f16.log(1.0).is_nan());
-    assert!(1.0f16.log(-13.9).is_nan());
-    assert!(nan.log(2.3).is_nan());
-    assert_eq!(inf.log(10.0), inf);
-    assert!(neg_inf.log(8.8).is_nan());
-    assert!((-2.3f16).log(0.1).is_nan());
-    assert_eq!((-0.0f16).log(2.0), neg_inf);
-    assert_eq!(0.0f16.log(7.0), neg_inf);
-}
-
-#[test]
-#[cfg(not(miri))]
-#[cfg(target_has_reliable_f16_math)]
-fn test_log2() {
-    let nan: f16 = f16::NAN;
-    let inf: f16 = f16::INFINITY;
-    let neg_inf: f16 = f16::NEG_INFINITY;
-    assert_approx_eq!(10.0f16.log2(), 3.321928, TOL_0);
-    assert_approx_eq!(2.3f16.log2(), 1.201634, TOL_0);
-    assert_approx_eq!(1.0f16.exp().log2(), 1.442695, TOL_0);
-    assert!(nan.log2().is_nan());
-    assert_eq!(inf.log2(), inf);
-    assert!(neg_inf.log2().is_nan());
-    assert!((-2.3f16).log2().is_nan());
-    assert_eq!((-0.0f16).log2(), neg_inf);
-    assert_eq!(0.0f16.log2(), neg_inf);
-}
-
-#[test]
-#[cfg(not(miri))]
-#[cfg(target_has_reliable_f16_math)]
-fn test_log10() {
-    let nan: f16 = f16::NAN;
-    let inf: f16 = f16::INFINITY;
-    let neg_inf: f16 = f16::NEG_INFINITY;
-    assert_eq!(10.0f16.log10(), 1.0);
-    assert_approx_eq!(2.3f16.log10(), 0.361728, TOL_0);
-    assert_approx_eq!(1.0f16.exp().log10(), 0.434294, TOL_0);
-    assert_eq!(1.0f16.log10(), 0.0);
-    assert!(nan.log10().is_nan());
-    assert_eq!(inf.log10(), inf);
-    assert!(neg_inf.log10().is_nan());
-    assert!((-2.3f16).log10().is_nan());
-    assert_eq!((-0.0f16).log10(), neg_inf);
-    assert_eq!(0.0f16.log10(), neg_inf);
-}
-
-#[test]
-#[cfg(not(miri))]
-#[cfg(target_has_reliable_f16_math)]
-fn test_asinh() {
-    assert_eq!(0.0f16.asinh(), 0.0f16);
-    assert_eq!((-0.0f16).asinh(), -0.0f16);
-
-    let inf: f16 = f16::INFINITY;
-    let neg_inf: f16 = f16::NEG_INFINITY;
-    let nan: f16 = f16::NAN;
-    assert_eq!(inf.asinh(), inf);
-    assert_eq!(neg_inf.asinh(), neg_inf);
-    assert!(nan.asinh().is_nan());
-    assert!((-0.0f16).asinh().is_sign_negative());
-    // issue 63271
-    assert_approx_eq!(2.0f16.asinh(), 1.443635475178810342493276740273105f16, TOL_0);
-    assert_approx_eq!((-2.0f16).asinh(), -1.443635475178810342493276740273105f16, TOL_0);
-    // regression test for the catastrophic cancellation fixed in 72486
-    assert_approx_eq!((-200.0f16).asinh(), -5.991470797049389, TOL_0);
-
-    // test for low accuracy from issue 104548
-    assert_approx_eq!(10.0f16, 10.0f16.sinh().asinh(), TOL_0);
-    // mul needed for approximate comparison to be meaningful
-    assert_approx_eq!(1.0f16, 1e-3f16.sinh().asinh() * 1e3f16, TOL_0);
-}
-
-#[test]
-#[cfg(not(miri))]
-#[cfg(target_has_reliable_f16_math)]
-fn test_acosh() {
-    assert_eq!(1.0f16.acosh(), 0.0f16);
-    assert!(0.999f16.acosh().is_nan());
-
-    let inf: f16 = f16::INFINITY;
-    let neg_inf: f16 = f16::NEG_INFINITY;
-    let nan: f16 = f16::NAN;
-    assert_eq!(inf.acosh(), inf);
-    assert!(neg_inf.acosh().is_nan());
-    assert!(nan.acosh().is_nan());
-    assert_approx_eq!(2.0f16.acosh(), 1.31695789692481670862504634730796844f16, TOL_0);
-    assert_approx_eq!(3.0f16.acosh(), 1.76274717403908605046521864995958461f16, TOL_0);
-
-    // test for low accuracy from issue 104548
-    assert_approx_eq!(10.0f16, 10.0f16.cosh().acosh(), TOL_P2);
-}
-
-#[test]
-#[cfg(not(miri))]
-#[cfg(target_has_reliable_f16_math)]
-fn test_atanh() {
-    assert_eq!(0.0f16.atanh(), 0.0f16);
-    assert_eq!((-0.0f16).atanh(), -0.0f16);
-
-    let inf: f16 = f16::INFINITY;
-    let neg_inf: f16 = f16::NEG_INFINITY;
-    let nan: f16 = f16::NAN;
-    assert_eq!(1.0f16.atanh(), inf);
-    assert_eq!((-1.0f16).atanh(), neg_inf);
-    assert!(2f16.atanh().atanh().is_nan());
-    assert!((-2f16).atanh().atanh().is_nan());
-    assert!(inf.atanh().is_nan());
-    assert!(neg_inf.atanh().is_nan());
-    assert!(nan.atanh().is_nan());
-    assert_approx_eq!(0.5f16.atanh(), 0.54930614433405484569762261846126285f16, TOL_0);
-    assert_approx_eq!((-0.5f16).atanh(), -0.54930614433405484569762261846126285f16, TOL_0);
-}
-
-#[test]
-#[cfg(not(miri))]
-#[cfg(target_has_reliable_f16_math)]
-fn test_gamma() {
-    // precision can differ among platforms
-    assert_approx_eq!(1.0f16.gamma(), 1.0f16, TOL_0);
-    assert_approx_eq!(2.0f16.gamma(), 1.0f16, TOL_0);
-    assert_approx_eq!(3.0f16.gamma(), 2.0f16, TOL_0);
-    assert_approx_eq!(4.0f16.gamma(), 6.0f16, TOL_0);
-    assert_approx_eq!(5.0f16.gamma(), 24.0f16, TOL_0);
-    assert_approx_eq!(0.5f16.gamma(), consts::PI.sqrt(), TOL_0);
-    assert_approx_eq!((-0.5f16).gamma(), -2.0 * consts::PI.sqrt(), TOL_0);
-    assert_eq!(0.0f16.gamma(), f16::INFINITY);
-    assert_eq!((-0.0f16).gamma(), f16::NEG_INFINITY);
-    assert!((-1.0f16).gamma().is_nan());
-    assert!((-2.0f16).gamma().is_nan());
-    assert!(f16::NAN.gamma().is_nan());
-    assert!(f16::NEG_INFINITY.gamma().is_nan());
-    assert_eq!(f16::INFINITY.gamma(), f16::INFINITY);
-    assert_eq!(171.71f16.gamma(), f16::INFINITY);
-}
-
-#[test]
-#[cfg(not(miri))]
-#[cfg(target_has_reliable_f16_math)]
-fn test_ln_gamma() {
-    assert_approx_eq!(1.0f16.ln_gamma().0, 0.0f16, TOL_0);
-    assert_eq!(1.0f16.ln_gamma().1, 1);
-    assert_approx_eq!(2.0f16.ln_gamma().0, 0.0f16, TOL_0);
-    assert_eq!(2.0f16.ln_gamma().1, 1);
-    assert_approx_eq!(3.0f16.ln_gamma().0, 2.0f16.ln(), TOL_0);
-    assert_eq!(3.0f16.ln_gamma().1, 1);
-    assert_approx_eq!((-0.5f16).ln_gamma().0, (2.0 * consts::PI.sqrt()).ln(), TOL_0);
-    assert_eq!((-0.5f16).ln_gamma().1, -1);
-}
-
 #[test]
 fn test_real_consts() {
     // FIXME(f16_f128): add math tests when available
diff --git a/library/std/tests/floats/f32.rs b/library/std/tests/floats/f32.rs
index 3acd067091415..639bf5299dcdf 100644
--- a/library/std/tests/floats/f32.rs
+++ b/library/std/tests/floats/f32.rs
@@ -32,196 +32,6 @@ fn test_powf() {
     assert_eq!(neg_inf.powf(3.0), neg_inf);
 }
 
-#[test]
-fn test_exp() {
-    assert_eq!(1.0, 0.0f32.exp());
-    assert_approx_eq!(2.718282, 1.0f32.exp(), APPROX_DELTA);
-    assert_approx_eq!(148.413162, 5.0f32.exp(), APPROX_DELTA);
-
-    let inf: f32 = f32::INFINITY;
-    let neg_inf: f32 = f32::NEG_INFINITY;
-    let nan: f32 = f32::NAN;
-    assert_eq!(inf, inf.exp());
-    assert_eq!(0.0, neg_inf.exp());
-    assert!(nan.exp().is_nan());
-}
-
-#[test]
-fn test_exp2() {
-    assert_approx_eq!(32.0, 5.0f32.exp2(), APPROX_DELTA);
-    assert_eq!(1.0, 0.0f32.exp2());
-
-    let inf: f32 = f32::INFINITY;
-    let neg_inf: f32 = f32::NEG_INFINITY;
-    let nan: f32 = f32::NAN;
-    assert_eq!(inf, inf.exp2());
-    assert_eq!(0.0, neg_inf.exp2());
-    assert!(nan.exp2().is_nan());
-}
-
-#[test]
-fn test_ln() {
-    let nan: f32 = f32::NAN;
-    let inf: f32 = f32::INFINITY;
-    let neg_inf: f32 = f32::NEG_INFINITY;
-    assert_approx_eq!(1.0f32.exp().ln(), 1.0);
-    assert!(nan.ln().is_nan());
-    assert_eq!(inf.ln(), inf);
-    assert!(neg_inf.ln().is_nan());
-    assert!((-2.3f32).ln().is_nan());
-    assert_eq!((-0.0f32).ln(), neg_inf);
-    assert_eq!(0.0f32.ln(), neg_inf);
-    assert_approx_eq!(4.0f32.ln(), 1.386294, APPROX_DELTA);
-}
-
-#[test]
-fn test_log() {
-    let nan: f32 = f32::NAN;
-    let inf: f32 = f32::INFINITY;
-    let neg_inf: f32 = f32::NEG_INFINITY;
-    assert_approx_eq!(10.0f32.log(10.0), 1.0);
-    assert_approx_eq!(2.3f32.log(3.5), 0.664858);
-    assert_approx_eq!(1.0f32.exp().log(1.0f32.exp()), 1.0, APPROX_DELTA);
-    assert!(1.0f32.log(1.0).is_nan());
-    assert!(1.0f32.log(-13.9).is_nan());
-    assert!(nan.log(2.3).is_nan());
-    assert_eq!(inf.log(10.0), inf);
-    assert!(neg_inf.log(8.8).is_nan());
-    assert!((-2.3f32).log(0.1).is_nan());
-    assert_eq!((-0.0f32).log(2.0), neg_inf);
-    assert_eq!(0.0f32.log(7.0), neg_inf);
-}
-
-#[test]
-fn test_log2() {
-    let nan: f32 = f32::NAN;
-    let inf: f32 = f32::INFINITY;
-    let neg_inf: f32 = f32::NEG_INFINITY;
-    assert_approx_eq!(10.0f32.log2(), 3.321928, APPROX_DELTA);
-    assert_approx_eq!(2.3f32.log2(), 1.201634);
-    assert_approx_eq!(1.0f32.exp().log2(), 1.442695, APPROX_DELTA);
-    assert!(nan.log2().is_nan());
-    assert_eq!(inf.log2(), inf);
-    assert!(neg_inf.log2().is_nan());
-    assert!((-2.3f32).log2().is_nan());
-    assert_eq!((-0.0f32).log2(), neg_inf);
-    assert_eq!(0.0f32.log2(), neg_inf);
-}
-
-#[test]
-fn test_log10() {
-    let nan: f32 = f32::NAN;
-    let inf: f32 = f32::INFINITY;
-    let neg_inf: f32 = f32::NEG_INFINITY;
-    assert_approx_eq!(10.0f32.log10(), 1.0);
-    assert_approx_eq!(2.3f32.log10(), 0.361728);
-    assert_approx_eq!(1.0f32.exp().log10(), 0.434294);
-    assert_eq!(1.0f32.log10(), 0.0);
-    assert!(nan.log10().is_nan());
-    assert_eq!(inf.log10(), inf);
-    assert!(neg_inf.log10().is_nan());
-    assert!((-2.3f32).log10().is_nan());
-    assert_eq!((-0.0f32).log10(), neg_inf);
-    assert_eq!(0.0f32.log10(), neg_inf);
-}
-
-#[test]
-fn test_asinh() {
-    assert_eq!(0.0f32.asinh(), 0.0f32);
-    assert_eq!((-0.0f32).asinh(), -0.0f32);
-
-    let inf: f32 = f32::INFINITY;
-    let neg_inf: f32 = f32::NEG_INFINITY;
-    let nan: f32 = f32::NAN;
-    assert_eq!(inf.asinh(), inf);
-    assert_eq!(neg_inf.asinh(), neg_inf);
-    assert!(nan.asinh().is_nan());
-    assert!((-0.0f32).asinh().is_sign_negative()); // issue 63271
-    assert_approx_eq!(2.0f32.asinh(), 1.443635475178810342493276740273105f32);
-    assert_approx_eq!((-2.0f32).asinh(), -1.443635475178810342493276740273105f32);
-    // regression test for the catastrophic cancellation fixed in 72486
-    assert_approx_eq!((-3000.0f32).asinh(), -8.699514775987968673236893537700647f32, APPROX_DELTA);
-
-    // test for low accuracy from issue 104548
-    assert_approx_eq!(60.0f32, 60.0f32.sinh().asinh(), APPROX_DELTA);
-    // mul needed for approximate comparison to be meaningful
-    assert_approx_eq!(1.0f32, 1e-15f32.sinh().asinh() * 1e15f32);
-}
-
-#[test]
-fn test_acosh() {
-    assert_eq!(1.0f32.acosh(), 0.0f32);
-    assert!(0.999f32.acosh().is_nan());
-
-    let inf: f32 = f32::INFINITY;
-    let neg_inf: f32 = f32::NEG_INFINITY;
-    let nan: f32 = f32::NAN;
-    assert_eq!(inf.acosh(), inf);
-    assert!(neg_inf.acosh().is_nan());
-    assert!(nan.acosh().is_nan());
-    assert_approx_eq!(2.0f32.acosh(), 1.31695789692481670862504634730796844f32);
-    assert_approx_eq!(3.0f32.acosh(), 1.76274717403908605046521864995958461f32);
-
-    // test for low accuracy from issue 104548
-    assert_approx_eq!(60.0f32, 60.0f32.cosh().acosh(), APPROX_DELTA);
-}
-
-#[test]
-fn test_atanh() {
-    assert_eq!(0.0f32.atanh(), 0.0f32);
-    assert_eq!((-0.0f32).atanh(), -0.0f32);
-
-    let inf32: f32 = f32::INFINITY;
-    let neg_inf32: f32 = f32::NEG_INFINITY;
-    assert_eq!(1.0f32.atanh(), inf32);
-    assert_eq!((-1.0f32).atanh(), neg_inf32);
-
-    assert!(2f64.atanh().atanh().is_nan());
-    assert!((-2f64).atanh().atanh().is_nan());
-
-    let inf64: f32 = f32::INFINITY;
-    let neg_inf64: f32 = f32::NEG_INFINITY;
-    let nan32: f32 = f32::NAN;
-    assert!(inf64.atanh().is_nan());
-    assert!(neg_inf64.atanh().is_nan());
-    assert!(nan32.atanh().is_nan());
-
-    assert_approx_eq!(0.5f32.atanh(), 0.54930614433405484569762261846126285f32);
-    assert_approx_eq!((-0.5f32).atanh(), -0.54930614433405484569762261846126285f32);
-}
-
-#[test]
-fn test_gamma() {
-    // precision can differ between platforms
-    assert_approx_eq!(1.0f32.gamma(), 1.0f32, APPROX_DELTA);
-    assert_approx_eq!(2.0f32.gamma(), 1.0f32, APPROX_DELTA);
-    assert_approx_eq!(3.0f32.gamma(), 2.0f32, APPROX_DELTA);
-    assert_approx_eq!(4.0f32.gamma(), 6.0f32, APPROX_DELTA);
-    assert_approx_eq!(5.0f32.gamma(), 24.0f32, APPROX_DELTA);
-    assert_approx_eq!(0.5f32.gamma(), consts::PI.sqrt(), APPROX_DELTA);
-    assert_approx_eq!((-0.5f32).gamma(), -2.0 * consts::PI.sqrt(), APPROX_DELTA);
-    assert_eq!(0.0f32.gamma(), f32::INFINITY);
-    assert_eq!((-0.0f32).gamma(), f32::NEG_INFINITY);
-    assert!((-1.0f32).gamma().is_nan());
-    assert!((-2.0f32).gamma().is_nan());
-    assert!(f32::NAN.gamma().is_nan());
-    assert!(f32::NEG_INFINITY.gamma().is_nan());
-    assert_eq!(f32::INFINITY.gamma(), f32::INFINITY);
-    assert_eq!(171.71f32.gamma(), f32::INFINITY);
-}
-
-#[test]
-fn test_ln_gamma() {
-    assert_approx_eq!(1.0f32.ln_gamma().0, 0.0f32);
-    assert_eq!(1.0f32.ln_gamma().1, 1);
-    assert_approx_eq!(2.0f32.ln_gamma().0, 0.0f32);
-    assert_eq!(2.0f32.ln_gamma().1, 1);
-    assert_approx_eq!(3.0f32.ln_gamma().0, 2.0f32.ln());
-    assert_eq!(3.0f32.ln_gamma().1, 1);
-    assert_approx_eq!((-0.5f32).ln_gamma().0, (2.0 * consts::PI.sqrt()).ln(), APPROX_DELTA);
-    assert_eq!((-0.5f32).ln_gamma().1, -1);
-}
-
 #[test]
 fn test_real_consts() {
     let pi: f32 = consts::PI;
diff --git a/library/std/tests/floats/f64.rs b/library/std/tests/floats/f64.rs
index fccf20097278b..aeba226f8f9ad 100644
--- a/library/std/tests/floats/f64.rs
+++ b/library/std/tests/floats/f64.rs
@@ -27,192 +27,6 @@ fn test_powf() {
     assert_eq!(neg_inf.powf(3.0), neg_inf);
 }
 
-#[test]
-fn test_exp() {
-    assert_eq!(1.0, 0.0f64.exp());
-    assert_approx_eq!(2.718282, 1.0f64.exp());
-    assert_approx_eq!(148.413159, 5.0f64.exp());
-
-    let inf: f64 = f64::INFINITY;
-    let neg_inf: f64 = f64::NEG_INFINITY;
-    let nan: f64 = f64::NAN;
-    assert_eq!(inf, inf.exp());
-    assert_eq!(0.0, neg_inf.exp());
-    assert!(nan.exp().is_nan());
-}
-
-#[test]
-fn test_exp2() {
-    assert_approx_eq!(32.0, 5.0f64.exp2());
-    assert_eq!(1.0, 0.0f64.exp2());
-
-    let inf: f64 = f64::INFINITY;
-    let neg_inf: f64 = f64::NEG_INFINITY;
-    let nan: f64 = f64::NAN;
-    assert_eq!(inf, inf.exp2());
-    assert_eq!(0.0, neg_inf.exp2());
-    assert!(nan.exp2().is_nan());
-}
-
-#[test]
-fn test_ln() {
-    let nan: f64 = f64::NAN;
-    let inf: f64 = f64::INFINITY;
-    let neg_inf: f64 = f64::NEG_INFINITY;
-    assert_approx_eq!(1.0f64.exp().ln(), 1.0);
-    assert!(nan.ln().is_nan());
-    assert_eq!(inf.ln(), inf);
-    assert!(neg_inf.ln().is_nan());
-    assert!((-2.3f64).ln().is_nan());
-    assert_eq!((-0.0f64).ln(), neg_inf);
-    assert_eq!(0.0f64.ln(), neg_inf);
-    assert_approx_eq!(4.0f64.ln(), 1.386294);
-}
-
-#[test]
-fn test_log() {
-    let nan: f64 = f64::NAN;
-    let inf: f64 = f64::INFINITY;
-    let neg_inf: f64 = f64::NEG_INFINITY;
-    assert_approx_eq!(10.0f64.log(10.0), 1.0);
-    assert_approx_eq!(2.3f64.log(3.5), 0.664858);
-    assert_approx_eq!(1.0f64.exp().log(1.0f64.exp()), 1.0);
-    assert!(1.0f64.log(1.0).is_nan());
-    assert!(1.0f64.log(-13.9).is_nan());
-    assert!(nan.log(2.3).is_nan());
-    assert_eq!(inf.log(10.0), inf);
-    assert!(neg_inf.log(8.8).is_nan());
-    assert!((-2.3f64).log(0.1).is_nan());
-    assert_eq!((-0.0f64).log(2.0), neg_inf);
-    assert_eq!(0.0f64.log(7.0), neg_inf);
-}
-
-#[test]
-fn test_log2() {
-    let nan: f64 = f64::NAN;
-    let inf: f64 = f64::INFINITY;
-    let neg_inf: f64 = f64::NEG_INFINITY;
-    assert_approx_eq!(10.0f64.log2(), 3.321928);
-    assert_approx_eq!(2.3f64.log2(), 1.201634);
-    assert_approx_eq!(1.0f64.exp().log2(), 1.442695);
-    assert!(nan.log2().is_nan());
-    assert_eq!(inf.log2(), inf);
-    assert!(neg_inf.log2().is_nan());
-    assert!((-2.3f64).log2().is_nan());
-    assert_eq!((-0.0f64).log2(), neg_inf);
-    assert_eq!(0.0f64.log2(), neg_inf);
-}
-
-#[test]
-fn test_log10() {
-    let nan: f64 = f64::NAN;
-    let inf: f64 = f64::INFINITY;
-    let neg_inf: f64 = f64::NEG_INFINITY;
-    assert_approx_eq!(10.0f64.log10(), 1.0);
-    assert_approx_eq!(2.3f64.log10(), 0.361728);
-    assert_approx_eq!(1.0f64.exp().log10(), 0.434294);
-    assert_eq!(1.0f64.log10(), 0.0);
-    assert!(nan.log10().is_nan());
-    assert_eq!(inf.log10(), inf);
-    assert!(neg_inf.log10().is_nan());
-    assert!((-2.3f64).log10().is_nan());
-    assert_eq!((-0.0f64).log10(), neg_inf);
-    assert_eq!(0.0f64.log10(), neg_inf);
-}
-
-#[test]
-fn test_asinh() {
-    assert_eq!(0.0f64.asinh(), 0.0f64);
-    assert_eq!((-0.0f64).asinh(), -0.0f64);
-
-    let inf: f64 = f64::INFINITY;
-    let neg_inf: f64 = f64::NEG_INFINITY;
-    let nan: f64 = f64::NAN;
-    assert_eq!(inf.asinh(), inf);
-    assert_eq!(neg_inf.asinh(), neg_inf);
-    assert!(nan.asinh().is_nan());
-    assert!((-0.0f64).asinh().is_sign_negative());
-    // issue 63271
-    assert_approx_eq!(2.0f64.asinh(), 1.443635475178810342493276740273105f64);
-    assert_approx_eq!((-2.0f64).asinh(), -1.443635475178810342493276740273105f64);
-    // regression test for the catastrophic cancellation fixed in 72486
-    assert_approx_eq!((-67452098.07139316f64).asinh(), -18.72007542627454439398548429400083);
-
-    // test for low accuracy from issue 104548
-    assert_approx_eq!(60.0f64, 60.0f64.sinh().asinh());
-    // mul needed for approximate comparison to be meaningful
-    assert_approx_eq!(1.0f64, 1e-15f64.sinh().asinh() * 1e15f64);
-}
-
-#[test]
-fn test_acosh() {
-    assert_eq!(1.0f64.acosh(), 0.0f64);
-    assert!(0.999f64.acosh().is_nan());
-
-    let inf: f64 = f64::INFINITY;
-    let neg_inf: f64 = f64::NEG_INFINITY;
-    let nan: f64 = f64::NAN;
-    assert_eq!(inf.acosh(), inf);
-    assert!(neg_inf.acosh().is_nan());
-    assert!(nan.acosh().is_nan());
-    assert_approx_eq!(2.0f64.acosh(), 1.31695789692481670862504634730796844f64);
-    assert_approx_eq!(3.0f64.acosh(), 1.76274717403908605046521864995958461f64);
-
-    // test for low accuracy from issue 104548
-    assert_approx_eq!(60.0f64, 60.0f64.cosh().acosh());
-}
-
-#[test]
-fn test_atanh() {
-    assert_eq!(0.0f64.atanh(), 0.0f64);
-    assert_eq!((-0.0f64).atanh(), -0.0f64);
-
-    let inf: f64 = f64::INFINITY;
-    let neg_inf: f64 = f64::NEG_INFINITY;
-    let nan: f64 = f64::NAN;
-    assert_eq!(1.0f64.atanh(), inf);
-    assert_eq!((-1.0f64).atanh(), neg_inf);
-    assert!(2f64.atanh().atanh().is_nan());
-    assert!((-2f64).atanh().atanh().is_nan());
-    assert!(inf.atanh().is_nan());
-    assert!(neg_inf.atanh().is_nan());
-    assert!(nan.atanh().is_nan());
-    assert_approx_eq!(0.5f64.atanh(), 0.54930614433405484569762261846126285f64);
-    assert_approx_eq!((-0.5f64).atanh(), -0.54930614433405484569762261846126285f64);
-}
-
-#[test]
-fn test_gamma() {
-    // precision can differ between platforms
-    assert_approx_eq!(1.0f64.gamma(), 1.0f64);
-    assert_approx_eq!(2.0f64.gamma(), 1.0f64);
-    assert_approx_eq!(3.0f64.gamma(), 2.0f64);
-    assert_approx_eq!(4.0f64.gamma(), 6.0f64);
-    assert_approx_eq!(5.0f64.gamma(), 24.0f64);
-    assert_approx_eq!(0.5f64.gamma(), consts::PI.sqrt());
-    assert_approx_eq!((-0.5f64).gamma(), -2.0 * consts::PI.sqrt());
-    assert_eq!(0.0f64.gamma(), f64::INFINITY);
-    assert_eq!((-0.0f64).gamma(), f64::NEG_INFINITY);
-    assert!((-1.0f64).gamma().is_nan());
-    assert!((-2.0f64).gamma().is_nan());
-    assert!(f64::NAN.gamma().is_nan());
-    assert!(f64::NEG_INFINITY.gamma().is_nan());
-    assert_eq!(f64::INFINITY.gamma(), f64::INFINITY);
-    assert_eq!(171.71f64.gamma(), f64::INFINITY);
-}
-
-#[test]
-fn test_ln_gamma() {
-    assert_approx_eq!(1.0f64.ln_gamma().0, 0.0f64);
-    assert_eq!(1.0f64.ln_gamma().1, 1);
-    assert_approx_eq!(2.0f64.ln_gamma().0, 0.0f64);
-    assert_eq!(2.0f64.ln_gamma().1, 1);
-    assert_approx_eq!(3.0f64.ln_gamma().0, 2.0f64.ln());
-    assert_eq!(3.0f64.ln_gamma().1, 1);
-    assert_approx_eq!((-0.5f64).ln_gamma().0, (2.0 * consts::PI.sqrt()).ln());
-    assert_eq!((-0.5f64).ln_gamma().1, -1);
-}
-
 #[test]
 fn test_real_consts() {
     let pi: f64 = consts::PI;