Skip to content

remove usages of to-be-deprecated float consts #4903

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
RalfJung merged 1 commit into from
Mar 15, 2026
Merged

remove usages of to-be-deprecated float consts #4903

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
100 changes: 52 additions & 48 deletions tests/pass/float.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -7,21 +7,25 @@
#![allow(arithmetic_overflow)]
#![allow(internal_features)]
#![allow(unnecessary_transmutes)]
#![deny(deprecated_in_future)]

#[path = "../utils/mod.rs"]
mod utils;
use std::any::type_name;
use std::cmp::min;
use std::f16::consts as f16_consts;
use std::f32::consts as f32_consts;
use std::f64::consts as f64_consts;
use std::f128::consts as f128_consts;
use std::fmt::{Debug, Display, LowerHex};
use std::hint::black_box;
use std::{f16, f32, f64, f128};

use utils::check_nondet;

/// Compare the two floats, allowing for $ulp many ULPs of error.
///
/// ULP means "Units in the Last Place" or "Units of Least Precision".
/// The ULP of a float `a`` is the smallest possible change at `a`, so the ULP difference represents how
/// The ULP of a float `a` is the smallest possible change at `a`, so the ULP difference represents how
/// many discrete floating-point steps are needed to reach the actual value from the expected value.
///
/// Essentially ULP can be seen as a distance metric of floating-point numbers, but with
Expand Down Expand Up @@ -1019,10 +1023,10 @@ fn mul_add() {
assert_eq!(3.0f64.mul_add(2.0f64, 5.0f64), 11.0);
assert_eq!(3.0f128.mul_add(2.0f128, 5.0f128), 11.0);

assert_eq!(0.0f16.mul_add(-2.0f16, f16::consts::E), f16::consts::E);
assert_eq!(0.0f32.mul_add(-2.0f32, f32::consts::E), f32::consts::E);
assert_eq!(0.0f64.mul_add(-2.0f64, f64::consts::E), f64::consts::E);
assert_eq!(0.0f128.mul_add(-2.0f128, f128::consts::E), f128::consts::E);
assert_eq!(0.0f16.mul_add(-2.0f16, f16_consts::E), f16_consts::E);
assert_eq!(0.0f32.mul_add(-2.0f32, f32_consts::E), f32_consts::E);
assert_eq!(0.0f64.mul_add(-2.0f64, f64_consts::E), f64_consts::E);
assert_eq!(0.0f128.mul_add(-2.0f128, f128_consts::E), f128_consts::E);

assert_eq!((-3.2f16).mul_add(2.4, f16::NEG_INFINITY), f16::NEG_INFINITY);
assert_eq!((-3.2f32).mul_add(2.4, f32::NEG_INFINITY), f32::NEG_INFINITY);
Expand Down Expand Up @@ -1125,16 +1129,16 @@ fn libm() {
assert_biteq((-0f32).powi(9), -0.0, "-0^x = -0 where x is negative");
assert_biteq((-0f64).powi(99), -0.0, "-0^x = -0 where x is negative");

assert_approx_eq!(1f16.exp(), f16::consts::E);
assert_approx_eq!(1f32.exp(), f32::consts::E);
assert_approx_eq!(1f64.exp(), f64::consts::E);
assert_approx_eq!(1f16.exp(), f16_consts::E);
assert_approx_eq!(1f32.exp(), f32_consts::E);
assert_approx_eq!(1f64.exp(), f64_consts::E);
assert_eq!(0f16.exp(), 1.0);
assert_eq!(0f32.exp(), 1.0);
assert_eq!(0f64.exp(), 1.0);

assert_approx_eq!(1f16.exp_m1(), f16::consts::E - 1.0);
assert_approx_eq!(1f32.exp_m1(), f32::consts::E - 1.0);
assert_approx_eq!(1f64.exp_m1(), f64::consts::E - 1.0);
assert_approx_eq!(1f16.exp_m1(), f16_consts::E - 1.0);
assert_approx_eq!(1f32.exp_m1(), f32_consts::E - 1.0);
assert_approx_eq!(1f64.exp_m1(), f64_consts::E - 1.0);
assert_approx_eq!(f16::NEG_INFINITY.exp_m1(), -1.0);
assert_approx_eq!(f32::NEG_INFINITY.exp_m1(), -1.0);
assert_approx_eq!(f64::NEG_INFINITY.exp_m1(), -1.0);
Expand All @@ -1146,9 +1150,9 @@ fn libm() {
assert_eq!(0f32.exp2(), 1.0);
assert_eq!(0f64.exp2(), 1.0);

assert_approx_eq!(f16::consts::E.ln(), 1f16);
assert_approx_eq!(f32::consts::E.ln(), 1f32);
assert_approx_eq!(f64::consts::E.ln(), 1f64);
assert_approx_eq!(f16_consts::E.ln(), 1f16);
assert_approx_eq!(f32_consts::E.ln(), 1f32);
assert_approx_eq!(f64_consts::E.ln(), 1f64);
assert_eq!(1f16.ln(), 0.0);
assert_eq!(1f32.ln(), 0.0);
assert_eq!(1f64.ln(), 0.0);
Expand All @@ -1159,11 +1163,11 @@ fn libm() {

assert_approx_eq!(10f16.log10(), 1f16);
assert_approx_eq!(10f32.log10(), 1f32);
assert_approx_eq!(f64::consts::E.log10(), f64::consts::LOG10_E);
assert_approx_eq!(f64_consts::E.log10(), f64_consts::LOG10_E);

assert_approx_eq!(8f16.log2(), 3f16);
assert_approx_eq!(8f32.log2(), 3f32);
assert_approx_eq!(f64::consts::E.log2(), f64::consts::LOG2_E);
assert_approx_eq!(f64_consts::E.log2(), f64_consts::LOG2_E);

#[allow(deprecated)]
{
Expand All @@ -1189,13 +1193,13 @@ fn libm() {
assert_eq!(0f16.sin(), 0f16);
assert_eq!(0f32.sin(), 0f32);
assert_eq!(0f64.sin(), 0f64);
assert_approx_eq!(f16::consts::FRAC_PI_6.sin(), 0.5);
assert_approx_eq!(f32::consts::FRAC_PI_6.sin(), 0.5);
assert_approx_eq!(f64::consts::FRAC_PI_6.sin(), 0.5);
assert_approx_eq!(f16_consts::FRAC_PI_6.sin(), 0.5);
assert_approx_eq!(f32_consts::FRAC_PI_6.sin(), 0.5);
assert_approx_eq!(f64_consts::FRAC_PI_6.sin(), 0.5);
// Increase error tolerance to 16ULP because of the extra operation.
assert_approx_eq!(f16::consts::FRAC_PI_4.sin().asin(), f16::consts::FRAC_PI_4, 16);
assert_approx_eq!(f32::consts::FRAC_PI_4.sin().asin(), f32::consts::FRAC_PI_4, 16);
assert_approx_eq!(f64::consts::FRAC_PI_4.sin().asin(), f64::consts::FRAC_PI_4, 16);
assert_approx_eq!(f16_consts::FRAC_PI_4.sin().asin(), f16_consts::FRAC_PI_4, 16);
assert_approx_eq!(f32_consts::FRAC_PI_4.sin().asin(), f32_consts::FRAC_PI_4, 16);
assert_approx_eq!(f64_consts::FRAC_PI_4.sin().asin(), f64_consts::FRAC_PI_4, 16);
assert_biteq(0.0f16.asin(), 0.0f16, "asin(+0) = +0");
assert_biteq((-0.0f16).asin(), -0.0, "asin(-0) = -0");
assert_biteq(0.0f32.asin(), 0.0f32, "asin(+0) = +0");
Expand All @@ -1212,12 +1216,12 @@ fn libm() {

// Ensure `sin` always returns something that is a valid input for `asin`, and same for
// `cos` and `acos`.
let halve_pi_f16 = std::f16::consts::FRAC_PI_2;
let halve_pi_f32 = std::f32::consts::FRAC_PI_2;
let halve_pi_f64 = std::f64::consts::FRAC_PI_2;
let pi_f16 = std::f16::consts::PI;
let pi_f32 = std::f32::consts::PI;
let pi_f64 = std::f64::consts::PI;
let halve_pi_f16 = f16_consts::FRAC_PI_2;
let halve_pi_f32 = f32_consts::FRAC_PI_2;
let halve_pi_f64 = f64_consts::FRAC_PI_2;
let pi_f16 = f16_consts::PI;
let pi_f32 = f32_consts::PI;
let pi_f64 = f64_consts::PI;
for _ in 0..64 {
// sin() should be clamped to [-1, 1] so asin() can never return NaN
assert!(!halve_pi_f16.sin().asin().is_nan());
Expand All @@ -1232,13 +1236,13 @@ fn libm() {
assert_eq!(0f16.cos(), 1f16);
assert_eq!(0f32.cos(), 1f32);
assert_eq!(0f64.cos(), 1f64);
assert_approx_eq!(f16::consts::FRAC_PI_3.cos(), 0.5);
assert_approx_eq!(f32::consts::FRAC_PI_3.cos(), 0.5);
assert_approx_eq!(f64::consts::FRAC_PI_3.cos(), 0.5);
assert_approx_eq!(f16_consts::FRAC_PI_3.cos(), 0.5);
assert_approx_eq!(f32_consts::FRAC_PI_3.cos(), 0.5);
assert_approx_eq!(f64_consts::FRAC_PI_3.cos(), 0.5);
// Increase error tolerance to 16ULP because of the extra operation.
assert_approx_eq!(f16::consts::FRAC_PI_4.cos().acos(), f16::consts::FRAC_PI_4, 16);
assert_approx_eq!(f32::consts::FRAC_PI_4.cos().acos(), f32::consts::FRAC_PI_4, 16);
assert_approx_eq!(f64::consts::FRAC_PI_4.cos().acos(), f64::consts::FRAC_PI_4, 16);
assert_approx_eq!(f16_consts::FRAC_PI_4.cos().acos(), f16_consts::FRAC_PI_4, 16);
assert_approx_eq!(f32_consts::FRAC_PI_4.cos().acos(), f32_consts::FRAC_PI_4, 16);
assert_approx_eq!(f64_consts::FRAC_PI_4.cos().acos(), f64_consts::FRAC_PI_4, 16);
assert_biteq(1.0f16.acos(), 0.0, "acos(1) = 0");
assert_biteq(1.0f32.acos(), 0.0, "acos(1) = 0");
assert_biteq(1.0f64.acos(), 0.0, "acos(1) = 0");
Expand Down Expand Up @@ -1314,15 +1318,15 @@ fn libm() {

assert_approx_eq!(
1.0f16.tanh(),
(1.0 - f16::consts::E.powi(-2)) / (1.0 + f16::consts::E.powi(-2))
(1.0 - f16_consts::E.powi(-2)) / (1.0 + f16_consts::E.powi(-2))
);
assert_approx_eq!(
1.0f32.tanh(),
(1.0 - f32::consts::E.powi(-2)) / (1.0 + f32::consts::E.powi(-2))
(1.0 - f32_consts::E.powi(-2)) / (1.0 + f32_consts::E.powi(-2))
);
assert_approx_eq!(
1.0f64.tanh(),
(1.0 - f64::consts::E.powi(-2)) / (1.0 + f64::consts::E.powi(-2))
(1.0 - f64_consts::E.powi(-2)) / (1.0 + f64_consts::E.powi(-2))
);
assert_eq!(f16::INFINITY.tanh(), 1.0);
assert_eq!(f16::NEG_INFINITY.tanh(), -1.0);
Expand All @@ -1338,22 +1342,22 @@ fn libm() {
assert_approx_eq!(5.0f16.gamma(), 24.0);
assert_approx_eq!(5.0f32.gamma(), 24.0);
assert_approx_eq!(5.0f64.gamma(), 24.0);
assert_approx_eq!((-0.5f16).gamma(), (-2.0) * f16::consts::PI.sqrt());
assert_approx_eq!((-0.5f32).gamma(), (-2.0) * f32::consts::PI.sqrt());
assert_approx_eq!((-0.5f64).gamma(), (-2.0) * f64::consts::PI.sqrt());
assert_approx_eq!((-0.5f16).gamma(), (-2.0) * f16_consts::PI.sqrt());
assert_approx_eq!((-0.5f32).gamma(), (-2.0) * f32_consts::PI.sqrt());
assert_approx_eq!((-0.5f64).gamma(), (-2.0) * f64_consts::PI.sqrt());

assert_eq!(2.0f16.ln_gamma(), (0.0, 1));
assert_eq!(2.0f32.ln_gamma(), (0.0, 1));
assert_eq!(2.0f64.ln_gamma(), (0.0, 1));
// Gamma(-0.5) = -2*sqrt(π)
let (val, sign) = (-0.5f16).ln_gamma();
assert_approx_eq!(val, (2.0 * f16::consts::PI.sqrt()).ln());
assert_approx_eq!(val, (2.0 * f16_consts::PI.sqrt()).ln());
assert_eq!(sign, -1);
let (val, sign) = (-0.5f32).ln_gamma();
assert_approx_eq!(val, (2.0 * f32::consts::PI.sqrt()).ln());
assert_approx_eq!(val, (2.0 * f32_consts::PI.sqrt()).ln());
assert_eq!(sign, -1);
let (val, sign) = (-0.5f64).ln_gamma();
assert_approx_eq!(val, (2.0 * f64::consts::PI.sqrt()).ln());
assert_approx_eq!(val, (2.0 * f64_consts::PI.sqrt()).ln());
assert_eq!(sign, -1);

assert_approx_eq!(1.0f16.erf(), 0.84270079294971486934122063508260926f16);
Expand Down Expand Up @@ -1558,7 +1562,7 @@ fn test_non_determinism() {
check_nondet(|| a.log(b));
check_nondet(|| a.exp());
check_nondet(|| 10f16.exp2());
check_nondet(|| f16::consts::E.ln());
check_nondet(|| f16_consts::E.ln());
check_nondet(|| 10f16.log10());
check_nondet(|| 8f16.log2());
check_nondet(|| 1f16.sin());
Expand Down Expand Up @@ -1594,7 +1598,7 @@ fn test_non_determinism() {
check_nondet(|| a.log(b));
check_nondet(|| a.exp());
check_nondet(|| 10f32.exp2());
check_nondet(|| f32::consts::E.ln());
check_nondet(|| f32_consts::E.ln());
check_nondet(|| 10f32.log10());
check_nondet(|| 8f32.log2());
check_nondet(|| 1f32.ln_1p());
Expand Down Expand Up @@ -1631,8 +1635,8 @@ fn test_non_determinism() {
check_nondet(|| a.exp());
check_nondet(|| 50f64.exp2());
check_nondet(|| 3f64.ln());
check_nondet(|| f64::consts::E.log10());
check_nondet(|| f64::consts::E.log2());
check_nondet(|| f64_consts::E.log10());
check_nondet(|| f64_consts::E.log2());
check_nondet(|| 1f64.ln_1p());
check_nondet(|| 27.0f64.cbrt());
check_nondet(|| 3.0f64.hypot(4.0f64));
Expand Down
3 changes: 2 additions & 1 deletion tests/pass/shims/x86/intrinsics-x86-sse.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -6,9 +6,10 @@
use std::arch::x86::*;
#[cfg(target_arch = "x86_64")]
use std::arch::x86_64::*;
use std::f32::NAN;
use std::mem::transmute;

const NAN: f32 = f32::NAN;

fn main() {
assert!(is_x86_feature_detected!("sse"));

Expand Down
3 changes: 2 additions & 1 deletion tests/pass/shims/x86/intrinsics-x86-sse2.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -6,9 +6,10 @@
use std::arch::x86::*;
#[cfg(target_arch = "x86_64")]
use std::arch::x86_64::*;
use std::f64::NAN;
use std::mem::transmute;

const NAN: f64 = f64::NAN;

fn main() {
assert!(is_x86_feature_detected!("sse2"));

Expand Down
Loading