constify float::{div,rem}_euclid

RalfJung · RalfJung · commit 7f834b7f1c22 · 2025-05-30T08:21:16.000+02:00
diff --git a/library/core/src/num/f128.rs b/library/core/src/num/f128.rs
@@ -1709,8 +1709,9 @@ impl f128 {
     #[inline]
     #[rustc_allow_incoherent_impl]
     #[unstable(feature = "f128", issue = "116909")]
+    #[rustc_const_unstable(feature = "const_float_euclidean_division", issue = "141572")]
     #[must_use = "method returns a new number and does not mutate the original value"]
-    pub fn div_euclid(self, rhs: f128) -> f128 {
+    pub const fn div_euclid(self, rhs: f128) -> f128 {
         let q = (self / rhs).trunc();
         if self % rhs < 0.0 {
             return if rhs > 0.0 { q - 1.0 } else { q + 1.0 };
@@ -1758,7 +1759,8 @@ impl f128 {
     #[doc(alias = "modulo", alias = "mod")]
     #[unstable(feature = "f128", issue = "116909")]
     #[must_use = "method returns a new number and does not mutate the original value"]
-    pub fn rem_euclid(self, rhs: f128) -> f128 {
+    #[rustc_const_unstable(feature = "const_float_euclidean_division", issue = "141572")]
+    pub const fn rem_euclid(self, rhs: f128) -> f128 {
         let r = self % rhs;
         if r < 0.0 { r + rhs.abs() } else { r }
     }
diff --git a/library/core/src/num/f16.rs b/library/core/src/num/f16.rs
@@ -1685,8 +1685,9 @@ impl f16 {
     #[inline]
     #[rustc_allow_incoherent_impl]
     #[unstable(feature = "f16", issue = "116909")]
+    #[rustc_const_unstable(feature = "const_float_euclidean_division", issue = "141572")]
     #[must_use = "method returns a new number and does not mutate the original value"]
-    pub fn div_euclid(self, rhs: f16) -> f16 {
+    pub const fn div_euclid(self, rhs: f16) -> f16 {
         let q = (self / rhs).trunc();
         if self % rhs < 0.0 {
             return if rhs > 0.0 { q - 1.0 } else { q + 1.0 };
@@ -1733,8 +1734,9 @@ impl f16 {
     #[rustc_allow_incoherent_impl]
     #[doc(alias = "modulo", alias = "mod")]
     #[unstable(feature = "f16", issue = "116909")]
+    #[rustc_const_unstable(feature = "const_float_euclidean_division", issue = "141572")]
     #[must_use = "method returns a new number and does not mutate the original value"]
-    pub fn rem_euclid(self, rhs: f16) -> f16 {
+    pub const fn rem_euclid(self, rhs: f16) -> f16 {
         let r = self % rhs;
         if r < 0.0 { r + rhs.abs() } else { r }
     }
diff --git a/library/core/src/num/f32.rs b/library/core/src/num/f32.rs
@@ -1826,8 +1826,9 @@ pub mod math {
     /// [`f32::div_euclid`]: ../../../std/primitive.f32.html#method.div_euclid
     #[inline]
     #[unstable(feature = "core_float_math", issue = "137578")]
+    #[rustc_const_unstable(feature = "const_float_euclidean_division", issue = "141572")]
     #[must_use = "method returns a new number and does not mutate the original value"]
-    pub fn div_euclid(x: f32, rhs: f32) -> f32 {
+    pub const fn div_euclid(x: f32, rhs: f32) -> f32 {
         let q = trunc(x / rhs);
         if x % rhs < 0.0 {
             return if rhs > 0.0 { q - 1.0 } else { q + 1.0 };
@@ -1862,7 +1863,7 @@ pub mod math {
     #[doc(alias = "modulo", alias = "mod")]
     #[unstable(feature = "core_float_math", issue = "137578")]
     #[must_use = "method returns a new number and does not mutate the original value"]
-    pub fn rem_euclid(x: f32, rhs: f32) -> f32 {
+    pub const fn rem_euclid(x: f32, rhs: f32) -> f32 {
         let r = x % rhs;
         if r < 0.0 { r + rhs.abs() } else { r }
     }
diff --git a/library/core/src/num/f64.rs b/library/core/src/num/f64.rs
@@ -1825,8 +1825,9 @@ pub mod math {
     /// [`f64::div_euclid`]: ../../../std/primitive.f64.html#method.div_euclid
     #[inline]
     #[unstable(feature = "core_float_math", issue = "137578")]
+    #[rustc_const_unstable(feature = "const_float_euclidean_division", issue = "141572")]
     #[must_use = "method returns a new number and does not mutate the original value"]
-    pub fn div_euclid(x: f64, rhs: f64) -> f64 {
+    pub const fn div_euclid(x: f64, rhs: f64) -> f64 {
         let q = trunc(x / rhs);
         if x % rhs < 0.0 {
             return if rhs > 0.0 { q - 1.0 } else { q + 1.0 };
@@ -1861,7 +1862,7 @@ pub mod math {
     #[doc(alias = "modulo", alias = "mod")]
     #[unstable(feature = "core_float_math", issue = "137578")]
     #[must_use = "method returns a new number and does not mutate the original value"]
-    pub fn rem_euclid(x: f64, rhs: f64) -> f64 {
+    pub const fn rem_euclid(x: f64, rhs: f64) -> f64 {
         let r = x % rhs;
         if r < 0.0 { r + rhs.abs() } else { r }
     }
diff --git a/library/coretests/tests/lib.rs b/library/coretests/tests/lib.rs
@@ -16,6 +16,7 @@
 #![feature(char_max_len)]
 #![feature(clone_to_uninit)]
 #![feature(const_eval_select)]
+#![feature(const_float_euclidean_division)]
 #![feature(const_float_round_methods)]
 #![feature(const_trait_impl)]
 #![feature(core_float_math)]
diff --git a/library/coretests/tests/num/mod.rs b/library/coretests/tests/num/mod.rs
@@ -932,23 +932,23 @@ macro_rules! test_float {
                 $fassert!(<$fty>::NEG_INFINITY.copysign(0.0), <$fty>::INFINITY);
             }
             #[test]
+            #[cfg(not(bootstrap))]
             fn rem_euclid() {
-                // FIXME: Use $fassert when rem_euclid becomes const
-                assert!(<$fty>::INFINITY.rem_euclid((42.0 as $fty)).is_nan());
-                assert_eq!((42.0 as $fty).rem_euclid(<$fty>::INFINITY), (42.0 as $fty));
-                assert!((42.0 as $fty).rem_euclid(<$fty>::NAN).is_nan());
-                assert!(<$fty>::INFINITY.rem_euclid(<$fty>::INFINITY).is_nan());
-                assert!(<$fty>::INFINITY.rem_euclid(<$fty>::NAN).is_nan());
-                assert!(<$fty>::NAN.rem_euclid(<$fty>::INFINITY).is_nan());
+                $fassert!(<$fty>::INFINITY.rem_euclid((42.0 as $fty)).is_nan());
+                $fassert!((42.0 as $fty).rem_euclid(<$fty>::INFINITY), (42.0 as $fty));
+                $fassert!((42.0 as $fty).rem_euclid(<$fty>::NAN).is_nan());
+                $fassert!(<$fty>::INFINITY.rem_euclid(<$fty>::INFINITY).is_nan());
+                $fassert!(<$fty>::INFINITY.rem_euclid(<$fty>::NAN).is_nan());
+                $fassert!(<$fty>::NAN.rem_euclid(<$fty>::INFINITY).is_nan());
             }
             #[test]
+            #[cfg(not(bootstrap))]
             fn div_euclid() {
-                // FIXME: Use $fassert when div_euclid becomes const
-                assert_eq!((42.0 as $fty).div_euclid(<$fty>::INFINITY), 0.0);
-                assert!((42.0 as $fty).div_euclid(<$fty>::NAN).is_nan());
-                assert!(<$fty>::INFINITY.div_euclid(<$fty>::INFINITY).is_nan());
-                assert!(<$fty>::INFINITY.div_euclid(<$fty>::NAN).is_nan());
-                assert!(<$fty>::NAN.div_euclid(<$fty>::INFINITY).is_nan());
+                $fassert!((42.0 as $fty).div_euclid(<$fty>::INFINITY), 0.0);
+                $fassert!((42.0 as $fty).div_euclid(<$fty>::NAN).is_nan());
+                $fassert!(<$fty>::INFINITY.div_euclid(<$fty>::INFINITY).is_nan());
+                $fassert!(<$fty>::INFINITY.div_euclid(<$fty>::NAN).is_nan());
+                $fassert!(<$fty>::NAN.div_euclid(<$fty>::INFINITY).is_nan());
             }
             #[test]
             #[cfg(not(bootstrap))]
diff --git a/library/std/src/f32.rs b/library/std/src/f32.rs
@@ -247,7 +247,8 @@ impl f32 {
     #[must_use = "method returns a new number and does not mutate the original value"]
     #[inline]
     #[stable(feature = "euclidean_division", since = "1.38.0")]
-    pub fn div_euclid(self, rhs: f32) -> f32 {
+    #[rustc_const_unstable(feature = "const_float_euclidean_division", issue = "141572")]
+    pub const fn div_euclid(self, rhs: f32) -> f32 {
         core::f32::math::div_euclid(self, rhs)
     }
 
@@ -284,7 +285,8 @@ impl f32 {
     #[must_use = "method returns a new number and does not mutate the original value"]
     #[inline]
     #[stable(feature = "euclidean_division", since = "1.38.0")]
-    pub fn rem_euclid(self, rhs: f32) -> f32 {
+    #[rustc_const_unstable(feature = "const_float_euclidean_division", issue = "141572")]
+    pub const fn rem_euclid(self, rhs: f32) -> f32 {
         core::f32::math::rem_euclid(self, rhs)
     }
 
diff --git a/library/std/src/f64.rs b/library/std/src/f64.rs
@@ -247,7 +247,8 @@ impl f64 {
     #[must_use = "method returns a new number and does not mutate the original value"]
     #[inline]
     #[stable(feature = "euclidean_division", since = "1.38.0")]
-    pub fn div_euclid(self, rhs: f64) -> f64 {
+    #[rustc_const_unstable(feature = "const_float_euclidean_division", issue = "141572")]
+    pub const fn div_euclid(self, rhs: f64) -> f64 {
         core::f64::math::div_euclid(self, rhs)
     }
 
@@ -284,7 +285,8 @@ impl f64 {
     #[must_use = "method returns a new number and does not mutate the original value"]
     #[inline]
     #[stable(feature = "euclidean_division", since = "1.38.0")]
-    pub fn rem_euclid(self, rhs: f64) -> f64 {
+    #[rustc_const_unstable(feature = "const_float_euclidean_division", issue = "141572")]
+    pub const fn rem_euclid(self, rhs: f64) -> f64 {
         core::f64::math::rem_euclid(self, rhs)
     }
 
diff --git a/library/std/src/lib.rs b/library/std/src/lib.rs
@@ -335,6 +335,7 @@
 #![feature(bstr_internals)]
 #![feature(char_internals)]
 #![feature(clone_to_uninit)]
+#![feature(const_float_euclidean_division)]
 #![feature(const_float_round_methods)]
 #![feature(core_intrinsics)]
 #![feature(core_io_borrowed_buf)]
