Panic on NaN

Author: Kyuuhachi

library/core/src/cmp/clamp.rs

@@ -67,6 +67,7 @@ macro impl_for_float($t:ty) {
     #[rustc_const_unstable(feature = "clamp_bounds", issue = "147781")]
     impl const ClampBounds<$t> for RangeFrom<$t> {
         fn clamp(self, value: $t) -> $t {
+            assert!(!self.start.is_nan(), "min was NaN");
             value.max(self.start)
         }
     }
@@ -75,6 +76,7 @@ macro impl_for_float($t:ty) {
     #[rustc_const_unstable(feature = "clamp_bounds", issue = "147781")]
     impl const ClampBounds<$t> for RangeToInclusive<$t> {
         fn clamp(self, value: $t) -> $t {
+            assert!(!self.end.is_nan(), "max was NaN");
             value.min(self.end)
         }
     }
@@ -84,8 +86,7 @@ macro impl_for_float($t:ty) {
     impl const ClampBounds<$t> for RangeInclusive<$t> {
         fn clamp(self, value: $t) -> $t {
             let (start, end) = self.into_inner();
-            // Deliberately avoid using `clamp` to handle NaN consistently
-            value.max(start).min(end)
+            value.clamp(start, end)
         }
     }
 }

library/core/src/num/f128.rs

@@ -1325,17 +1325,20 @@ impl f128 {
         self.clamp(-limit, limit)
     }
 
-    /// Restrict a value to a certain range.
+    /// Restrict a value to a certain range, unless it is NaN.
     ///
     /// This is largely equal to `max`, `min`, or `clamp`, depending on whether the range is
-    /// `min..`, `..=max`, or `min..=max`, respectively. However, whereas `clamp` panics on NaN
-    /// values, this function treats them as unbounded, like `max` and `min`.
+    /// `min..`, `..=max`, or `min..=max`, respectively. However, unlike `max` and `min`, it will
+    /// panic if any bound is NaN.
+    ///
+    /// Note that this function returns NaN if the initial value was NaN as
+    /// well.
     ///
     /// Exclusive ranges are not permitted.
     ///
     /// # Panics
     ///
-    /// Panics on `min..=max` if `min > max`.
+    /// Panics on `min..=max` if `min > max`, or if any bound is NaN.
     ///
     /// # Examples
     ///
@@ -1345,7 +1348,7 @@ impl f128 {
     /// assert_eq!(0.0f128.clamp_to(-2.0..=1.0), 0.0);
     /// assert_eq!(2.0f128.clamp_to(..=1.0), 1.0);
     /// assert_eq!(5.0f128.clamp_to(7.0..), 7.0);
-    /// assert_eq!(4.0f128.clamp_to(1.0..=f128::NAN), 4.0);
+    /// assert!(f128::NAN.clamp_to(1.0..=2.0).is_nan());
     /// ```
     #[must_use]
     #[inline]

library/core/src/num/f16.rs

@@ -1303,17 +1303,20 @@ impl f16 {
         self.clamp(-limit, limit)
     }
 
-    /// Restrict a value to a certain range.
+    /// Restrict a value to a certain range, unless it is NaN.
     ///
     /// This is largely equal to `max`, `min`, or `clamp`, depending on whether the range is
-    /// `min..`, `..=max`, or `min..=max`, respectively. However, whereas `clamp` panics on NaN
-    /// values, this function treats them as unbounded, like `max` and `min`.
+    /// `min..`, `..=max`, or `min..=max`, respectively. However, unlike `max` and `min`, it will
+    /// panic if any bound is NaN.
+    ///
+    /// Note that this function returns NaN if the initial value was NaN as
+    /// well.
     ///
     /// Exclusive ranges are not permitted.
     ///
     /// # Panics
     ///
-    /// Panics on `min..=max` if `min > max`.
+    /// Panics on `min..=max` if `min > max`, or if any bound is NaN.
     ///
     /// # Examples
     ///
@@ -1323,7 +1326,7 @@ impl f16 {
     /// assert_eq!(0.0f16.clamp_to(-2.0..=1.0), 0.0);
     /// assert_eq!(2.0f16.clamp_to(..=1.0), 1.0);
     /// assert_eq!(5.0f16.clamp_to(7.0..), 7.0);
-    /// assert_eq!(4.0f16.clamp_to(1.0..=f16::NAN), 4.0);
+    /// assert!(f16::NAN.clamp_to(1.0..=2.0).is_nan());
     /// ```
     #[must_use]
     #[inline]

library/core/src/num/f32.rs

@@ -1477,17 +1477,20 @@ impl f32 {
         self.clamp(-limit, limit)
     }
 
-    /// Restrict a value to a certain range.
+    /// Restrict a value to a certain range, unless it is NaN.
     ///
     /// This is largely equal to `max`, `min`, or `clamp`, depending on whether the range is
-    /// `min..`, `..=max`, or `min..=max`, respectively. However, whereas `clamp` panics on NaN
-    /// values, this function treats them as unbounded, like `max` and `min`.
+    /// `min..`, `..=max`, or `min..=max`, respectively. However, unlike `max` and `min`, it will
+    /// panic if any bound is NaN.
+    ///
+    /// Note that this function returns NaN if the initial value was NaN as
+    /// well.
     ///
     /// Exclusive ranges are not permitted.
     ///
     /// # Panics
     ///
-    /// Panics on `min..=max` if `min > max`.
+    /// Panics on `min..=max` if `min > max`, or if any bound is NaN.
     ///
     /// # Examples
     ///
@@ -1497,7 +1500,7 @@ impl f32 {
     /// assert_eq!(0.0f32.clamp_to(-2.0..=1.0), 0.0);
     /// assert_eq!(2.0f32.clamp_to(..=1.0), 1.0);
     /// assert_eq!(5.0f32.clamp_to(7.0..), 7.0);
-    /// assert_eq!(4.0f32.clamp_to(1.0..=f32::NAN), 4.0);
+    /// assert!(f32::NAN.clamp_to(1.0..=2.0).is_nan());
     /// ```
     #[must_use]
     #[inline]

library/core/src/num/f64.rs

@@ -1475,17 +1475,20 @@ impl f64 {
         self.clamp(-limit, limit)
     }
 
-    /// Restrict a value to a certain range.
+    /// Restrict a value to a certain range, unless it is NaN.
     ///
     /// This is largely equal to `max`, `min`, or `clamp`, depending on whether the range is
-    /// `min..`, `..=max`, or `min..=max`, respectively. However, whereas `clamp` panics on NaN
-    /// values, this function treats them as unbounded, like `max` and `min`.
+    /// `min..`, `..=max`, or `min..=max`, respectively. However, unlike `max` and `min`, it will
+    /// panic if any bound is NaN.
+    ///
+    /// Note that this function returns NaN if the initial value was NaN as
+    /// well.
     ///
     /// Exclusive ranges are not permitted.
     ///
     /// # Panics
     ///
-    /// Panics on `min..=max` if `min > max`.
+    /// Panics on `min..=max` if `min > max`, or if any bound is NaN.
     ///
     /// # Examples
     ///
@@ -1495,7 +1498,7 @@ impl f64 {
     /// assert_eq!(0.0f64.clamp_to(-2.0..=1.0), 0.0);
     /// assert_eq!(2.0f64.clamp_to(..=1.0), 1.0);
     /// assert_eq!(5.0f64.clamp_to(7.0..), 7.0);
-    /// assert_eq!(4.0f64.clamp_to(1.0..=f64::NAN), 4.0);
+    /// assert!(f64::NAN.clamp_to(1.0..=2.0).is_nan());
     /// ```
     #[must_use]
     #[inline]