f*::min/max: fix comparing with libm and IEEE operations

Author: RalfJung

library/core/src/intrinsics/mod.rs

@@ -2949,8 +2949,7 @@ pub const unsafe fn write_bytes<T>(dst: *mut T, val: u8, count: usize);
 
 /// Returns the minimum of two `f16` values, ignoring NaN.
 ///
-/// This behaves like IEEE 754-2008 minNum. In particular:
-/// If one of the arguments is NaN, then the other argument is returned. If the inputs compare equal
+/// If one of the arguments is NaN (quiet or signaling), then the other argument is returned. If the inputs compare equal
 /// (such as for the case of `+0.0` and `-0.0`), either input may be returned non-deterministically.
 ///
 /// Note that, unlike most intrinsics, this is safe to call;
@@ -2965,8 +2964,7 @@ pub const fn minnumf16(x: f16, y: f16) -> f16;
 
 /// Returns the minimum of two `f32` values, ignoring NaN.
 ///
-/// This behaves like IEEE 754-2008 minNum. In particular:
-/// If one of the arguments is NaN, then the other argument is returned. If the inputs compare equal
+/// If one of the arguments is NaN (quiet or signaling), then the other argument is returned. If the inputs compare equal
 /// (such as for the case of `+0.0` and `-0.0`), either input may be returned non-deterministically.
 ///
 /// Note that, unlike most intrinsics, this is safe to call;
@@ -2982,8 +2980,7 @@ pub const fn minnumf32(x: f32, y: f32) -> f32;
 
 /// Returns the minimum of two `f64` values, ignoring NaN.
 ///
-/// This behaves like IEEE 754-2008 minNum. In particular:
-/// If one of the arguments is NaN, then the other argument is returned. If the inputs compare equal
+/// If one of the arguments is NaN (quiet or signaling), then the other argument is returned. If the inputs compare equal
 /// (such as for the case of `+0.0` and `-0.0`), either input may be returned non-deterministically.
 ///
 /// Note that, unlike most intrinsics, this is safe to call;
@@ -2999,8 +2996,7 @@ pub const fn minnumf64(x: f64, y: f64) -> f64;
 
 /// Returns the minimum of two `f128` values, ignoring NaN.
 ///
-/// This behaves like IEEE 754-2008 minNum. In particular:
-/// If one of the arguments is NaN, then the other argument is returned. If the inputs compare equal
+/// If one of the arguments is NaN (quiet or signaling), then the other argument is returned. If the inputs compare equal
 /// (such as for the case of `+0.0` and `-0.0`), either input may be returned non-deterministically.
 ///
 /// Note that, unlike most intrinsics, this is safe to call;
@@ -3115,8 +3111,7 @@ pub const fn minimumf128(x: f128, y: f128) -> f128 {
 
 /// Returns the maximum of two `f16` values, ignoring NaN.
 ///
-/// This behaves like IEEE 754-2008 maxNum. In particular:
-/// If one of the arguments is NaN, then the other argument is returned. If the inputs compare equal
+/// If one of the arguments is NaN (quiet or signaling), then the other argument is returned. If the inputs compare equal
 /// (such as for the case of `+0.0` and `-0.0`), either input may be returned non-deterministically.
 ///
 /// Note that, unlike most intrinsics, this is safe to call;
@@ -3131,8 +3126,7 @@ pub const fn maxnumf16(x: f16, y: f16) -> f16;
 
 /// Returns the maximum of two `f32` values, ignoring NaN.
 ///
-/// This behaves like IEEE 754-2008 maxNum. In particular:
-/// If one of the arguments is NaN, then the other argument is returned. If the inputs compare equal
+/// If one of the arguments is NaN (quiet or signaling), then the other argument is returned. If the inputs compare equal
 /// (such as for the case of `+0.0` and `-0.0`), either input may be returned non-deterministically.
 ///
 /// Note that, unlike most intrinsics, this is safe to call;
@@ -3148,8 +3142,7 @@ pub const fn maxnumf32(x: f32, y: f32) -> f32;
 
 /// Returns the maximum of two `f64` values, ignoring NaN.
 ///
-/// This behaves like IEEE 754-2008 maxNum. In particular:
-/// If one of the arguments is NaN, then the other argument is returned. If the inputs compare equal
+/// If one of the arguments is NaN (quiet or signaling), then the other argument is returned. If the inputs compare equal
 /// (such as for the case of `+0.0` and `-0.0`), either input may be returned non-deterministically.
 ///
 /// Note that, unlike most intrinsics, this is safe to call;
@@ -3165,8 +3158,7 @@ pub const fn maxnumf64(x: f64, y: f64) -> f64;
 
 /// Returns the maximum of two `f128` values, ignoring NaN.
 ///
-/// This behaves like IEEE 754-2008 maxNum. In particular:
-/// If one of the arguments is NaN, then the other argument is returned. If the inputs compare equal
+/// If one of the arguments is NaN (quiet or signaling), then the other argument is returned. If the inputs compare equal
 /// (such as for the case of `+0.0` and `-0.0`), either input may be returned non-deterministically.
 ///
 /// Note that, unlike most intrinsics, this is safe to call;

library/core/src/num/f128.rs

@@ -699,9 +699,9 @@ impl f128 {
     /// [rules for arithmetic operations](f32#nan-bit-patterns). If the inputs compare equal (such
     /// as for the case of `+0.0` and `-0.0`), either input may be returned non-deterministically.
     ///
-    /// This follows the IEEE 754-2008 semantics for `maxNum`, except for handling of signaling NaNs;
-    /// this function handles all NaNs the same way and avoids `maxNum`'s problems with associativity.
-    /// This also matches the behavior of libm’s `fmax`.
+    /// The handling of NaNs follows the IEEE 754-2019 semantics for `maximumNumber`, treating all
+    /// NaNs the same way to ensure the operation is associative. The handling of signed zeros
+    /// follows the IEEE 754-2008 semantics for `maxNum`.
     ///
     /// ```
     /// #![feature(f128)]
@@ -730,9 +730,9 @@ impl f128 {
     /// [rules for arithmetic operations](f32#nan-bit-patterns). If the inputs compare equal (such
     /// as for the case of `+0.0` and `-0.0`), either input may be returned non-deterministically.
     ///
-    /// This follows the IEEE 754-2008 semantics for `minNum`, except for handling of signaling NaNs;
-    /// this function handles all NaNs the same way and avoids `minNum`'s problems with associativity.
-    /// This also matches the behavior of libm’s `fmin`.
+    /// The handling of NaNs follows the IEEE 754-2019 semantics for `minimumNumber`, treating all
+    /// NaNs the same way to ensure the operation is associative. The handling of signed zeros
+    /// follows the IEEE 754-2008 semantics for `minNum`.
     ///
     /// ```
     /// #![feature(f128)]

library/core/src/num/f16.rs

@@ -692,9 +692,9 @@ impl f16 {
     /// [rules for arithmetic operations](f32#nan-bit-patterns). If the inputs compare equal (such
     /// as for the case of `+0.0` and `-0.0`), either input may be returned non-deterministically.
     ///
-    /// This follows the IEEE 754-2008 semantics for `maxNum`, except for handling of signaling NaNs;
-    /// this function handles all NaNs the same way and avoids `maxNum`'s problems with associativity.
-    /// This also matches the behavior of libm’s `fmax`.
+    /// The handling of NaNs follows the IEEE 754-2019 semantics for `maximumNumber`, treating all
+    /// NaNs the same way to ensure the operation is associative. The handling of signed zeros
+    /// follows the IEEE 754-2008 semantics for `maxNum`.
     ///
     /// ```
     /// #![feature(f16)]
@@ -722,9 +722,9 @@ impl f16 {
     /// [rules for arithmetic operations](f32#nan-bit-patterns). If the inputs compare equal (such
     /// as for the case of `+0.0` and `-0.0`), either input may be returned non-deterministically.
     ///
-    /// This follows the IEEE 754-2008 semantics for `minNum`, except for handling of signaling NaNs;
-    /// this function handles all NaNs the same way and avoids `minNum`'s problems with associativity.
-    /// This also matches the behavior of libm’s `fmin`.
+    /// The handling of NaNs follows the IEEE 754-2019 semantics for `minimumNumber`, treating all
+    /// NaNs the same way to ensure the operation is associative. The handling of signed zeros
+    /// follows the IEEE 754-2008 semantics for `minNum`.
     ///
     /// ```
     /// #![feature(f16)]

library/core/src/num/f32.rs

@@ -902,9 +902,9 @@ impl f32 {
     /// [rules for arithmetic operations](f32#nan-bit-patterns). If the inputs compare equal (such
     /// as for the case of `+0.0` and `-0.0`), either input may be returned non-deterministically.
     ///
-    /// This follows the IEEE 754-2008 semantics for `maxNum`, except for handling of signaling NaNs;
-    /// this function handles all NaNs the same way and avoids `maxNum`'s problems with associativity.
-    /// This also matches the behavior of libm’s `fmax`.
+    /// The handling of NaNs follows the IEEE 754-2019 semantics for `maximumNumber`, treating all
+    /// NaNs the same way to ensure the operation is associative. The handling of signed zeros
+    /// follows the IEEE 754-2008 semantics for `maxNum`.
     ///
     /// ```
     /// let x = 1.0f32;
@@ -928,9 +928,9 @@ impl f32 {
     /// [rules for arithmetic operations](f32#nan-bit-patterns). If the inputs compare equal (such
     /// as for the case of `+0.0` and `-0.0`), either input may be returned non-deterministically.
     ///
-    /// This follows the IEEE 754-2008 semantics for `minNum`, except for handling of signaling NaNs;
-    /// this function handles all NaNs the same way and avoids `minNum`'s problems with associativity.
-    /// This also matches the behavior of libm’s `fmin`.
+    /// The handling of NaNs follows the IEEE 754-2019 semantics for `minimumNumber`, treating all
+    /// NaNs the same way to ensure the operation is associative. The handling of signed zeros
+    /// follows the IEEE 754-2008 semantics for `minNum`.
     ///
     /// ```
     /// let x = 1.0f32;

library/core/src/num/f64.rs

@@ -920,9 +920,9 @@ impl f64 {
     /// [rules for arithmetic operations](f32#nan-bit-patterns). If the inputs compare equal (such
     /// as for the case of `+0.0` and `-0.0`), either input may be returned non-deterministically.
     ///
-    /// This follows the IEEE 754-2008 semantics for `maxNum`, except for handling of signaling NaNs;
-    /// this function handles all NaNs the same way and avoids `maxNum`'s problems with associativity.
-    /// This also matches the behavior of libm’s `fmax`.
+    /// The handling of NaNs follows the IEEE 754-2019 semantics for `maximumNumber`, treating all
+    /// NaNs the same way to ensure the operation is associative. The handling of signed zeros
+    /// follows the IEEE 754-2008 semantics for `maxNum`.
     ///
     /// ```
     /// let x = 1.0_f64;
@@ -946,9 +946,9 @@ impl f64 {
     /// [rules for arithmetic operations](f32#nan-bit-patterns). If the inputs compare equal (such
     /// as for the case of `+0.0` and `-0.0`), either input may be returned non-deterministically.
     ///
-    /// This follows the IEEE 754-2008 semantics for `minNum`, except for handling of signaling NaNs;
-    /// this function handles all NaNs the same way and avoids `minNum`'s problems with associativity.
-    /// This also matches the behavior of libm’s `fmin`.
+    /// The handling of NaNs follows the IEEE 754-2019 semantics for `minimumNumber`, treating all
+    /// NaNs the same way to ensure the operation is associative. The handling of signed zeros
+    /// follows the IEEE 754-2008 semantics for `minNum`.
     ///
     /// ```
     /// let x = 1.0_f64;