Auto merge of #42430 - nagisa:core-float, r=alexcrichton

Re-implement float min/max in rust

This also adds the relevant implementations into libcore.

See #42423

5 files changed, 118 insertions, 0 deletions

diff --git a/src/libcore/num/f32.rs b/src/libcore/num/f32.rs
index 91ca213e96e..cb28035682d 100644
--- a/src/libcore/num/f32.rs
+++ b/src/libcore/num/f32.rs
@@ -242,4 +242,32 @@ impl Float for f32 {
         let value: f32 = consts::PI;
         self * (value / 180.0f32)
     }
+
+    /// Returns the maximum of the two numbers.
+    #[inline]
+    fn max(self, other: f32) -> f32 {
+        // IEEE754 says: maxNum(x, y) is the canonicalized number y if x < y, x if y < x, the
+        // canonicalized number if one operand is a number and the other a quiet NaN. Otherwise it
+        // is either x or y, canonicalized (this means results might differ among implementations).
+        // When either x or y is a signalingNaN, then the result is according to 6.2.
+        //
+        // Since we do not support sNaN in Rust yet, we do not need to handle them.
+        // FIXME(nagisa): due to https://bugs.llvm.org/show_bug.cgi?id=33303 we canonicalize by
+        // multiplying by 1.0. Should switch to the `canonicalize` when it works.
+        (if self < other || self.is_nan() { other } else { self }) * 1.0
+    }
+
+    /// Returns the minimum of the two numbers.
+    #[inline]
+    fn min(self, other: f32) -> f32 {
+        // IEEE754 says: minNum(x, y) is the canonicalized number x if x < y, y if y < x, the
+        // canonicalized number if one operand is a number and the other a quiet NaN. Otherwise it
+        // is either x or y, canonicalized (this means results might differ among implementations).
+        // When either x or y is a signalingNaN, then the result is according to 6.2.
+        //
+        // Since we do not support sNaN in Rust yet, we do not need to handle them.
+        // FIXME(nagisa): due to https://bugs.llvm.org/show_bug.cgi?id=33303 we canonicalize by
+        // multiplying by 1.0. Should switch to the `canonicalize` when it works.
+        (if self < other || other.is_nan() { self } else { other }) * 1.0
+    }
 }
diff --git a/src/libcore/num/f64.rs b/src/libcore/num/f64.rs
index 7d6d6cef049..ac6b1e67cd2 100644
--- a/src/libcore/num/f64.rs
+++ b/src/libcore/num/f64.rs
@@ -242,4 +242,32 @@ impl Float for f64 {
         let value: f64 = consts::PI;
         self * (value / 180.0)
     }
+
+    /// Returns the maximum of the two numbers.
+    #[inline]
+    fn max(self, other: f64) -> f64 {
+        // IEEE754 says: maxNum(x, y) is the canonicalized number y if x < y, x if y < x, the
+        // canonicalized number if one operand is a number and the other a quiet NaN. Otherwise it
+        // is either x or y, canonicalized (this means results might differ among implementations).
+        // When either x or y is a signalingNaN, then the result is according to 6.2.
+        //
+        // Since we do not support sNaN in Rust yet, we do not need to handle them.
+        // FIXME(nagisa): due to https://bugs.llvm.org/show_bug.cgi?id=33303 we canonicalize by
+        // multiplying by 1.0. Should switch to the `canonicalize` when it works.
+        (if self < other || self.is_nan() { other } else { self }) * 1.0
+    }
+
+    /// Returns the minimum of the two numbers.
+    #[inline]
+    fn min(self, other: f64) -> f64 {
+        // IEEE754 says: minNum(x, y) is the canonicalized number x if x < y, y if y < x, the
+        // canonicalized number if one operand is a number and the other a quiet NaN. Otherwise it
+        // is either x or y, canonicalized (this means results might differ among implementations).
+        // When either x or y is a signalingNaN, then the result is according to 6.2.
+        //
+        // Since we do not support sNaN in Rust yet, we do not need to handle them.
+        // FIXME(nagisa): due to https://bugs.llvm.org/show_bug.cgi?id=33303 we canonicalize by
+        // multiplying by 1.0. Should switch to the `canonicalize` when it works.
+        (if self < other || other.is_nan() { self } else { other }) * 1.0
+    }
 }
diff --git a/src/libcore/num/mod.rs b/src/libcore/num/mod.rs
index 62d75445cc9..cbd59ed3713 100644
--- a/src/libcore/num/mod.rs
+++ b/src/libcore/num/mod.rs
@@ -2459,6 +2459,13 @@ pub trait Float: Sized {
     /// Convert degrees to radians.
     #[stable(feature = "deg_rad_conversions", since="1.7.0")]
     fn to_radians(self) -> Self;
+
+    /// Returns the maximum of the two numbers.
+    #[stable(feature = "core_float_min_max", since="1.20.0")]
+    fn max(self, other: Self) -> Self;
+    /// Returns the minimum of the two numbers.
+    #[stable(feature = "core_float_min_max", since="1.20.0")]
+    fn min(self, other: Self) -> Self;
 }
 
 macro_rules! from_str_radix_int_impl {
diff --git a/src/libcore/tests/lib.rs b/src/libcore/tests/lib.rs
index 77a9307f43e..337f8aa31dc 100644
--- a/src/libcore/tests/lib.rs
+++ b/src/libcore/tests/lib.rs
@@ -13,6 +13,7 @@
 #![feature(box_syntax)]
 #![feature(char_escape_debug)]
 #![feature(const_fn)]
+#![feature(core_float)]
 #![feature(core_private_bignum)]
 #![feature(core_private_diy_float)]
 #![feature(dec2flt)]
diff --git a/src/libcore/tests/num/mod.rs b/src/libcore/tests/num/mod.rs
index 8fdcc36a268..f233b649a8f 100644
--- a/src/libcore/tests/num/mod.rs
+++ b/src/libcore/tests/num/mod.rs
@@ -399,3 +399,57 @@ test_impl_try_from_signed_to_unsigned_err! { test_try_i32u16, i32, u16 }
 test_impl_try_from_signed_to_unsigned_err! { test_try_i64u8, i64, u8 }
 test_impl_try_from_signed_to_unsigned_err! { test_try_i64u16, i64, u16 }
 test_impl_try_from_signed_to_unsigned_err! { test_try_i64u32, i64, u32 }
+
+macro_rules! test_float {
+    ($modname: ident, $fty: ty, $inf: expr, $neginf: expr, $nan: expr) => { mod $modname {
+        use core::num::Float;
+        // FIXME(nagisa): these tests should test for sign of -0.0
+        #[test]
+        fn min() {
+            assert_eq!(0.0.min(0.0), 0.0);
+            assert_eq!((-0.0).min(-0.0), -0.0);
+            assert_eq!(9.0.min(9.0), 9.0);
+            assert_eq!((-9.0).min(0.0), -9.0);
+            assert_eq!(0.0.min(9.0), 0.0);
+            assert_eq!((-0.0).min(-9.0), -9.0);
+            assert_eq!($inf.min(9.0), 9.0);
+            assert_eq!(9.0.min($inf), 9.0);
+            assert_eq!($inf.min(-9.0), -9.0);
+            assert_eq!((-9.0).min($inf), -9.0);
+            assert_eq!($neginf.min(9.0), $neginf);
+            assert_eq!(9.0.min($neginf), $neginf);
+            assert_eq!($neginf.min(-9.0), $neginf);
+            assert_eq!((-9.0).min($neginf), $neginf);
+            assert_eq!($nan.min(9.0), 9.0);
+            assert_eq!($nan.min(-9.0), -9.0);
+            assert_eq!(9.0.min($nan), 9.0);
+            assert_eq!((-9.0).min($nan), -9.0);
+            assert!($nan.min($nan).is_nan());
+        }
+        #[test]
+        fn max() {
+            assert_eq!(0.0.max(0.0), 0.0);
+            assert_eq!((-0.0).max(-0.0), -0.0);
+            assert_eq!(9.0.max(9.0), 9.0);
+            assert_eq!((-9.0).max(0.0), 0.0);
+            assert_eq!(0.0.max(9.0), 9.0);
+            assert_eq!((-0.0).max(-9.0), -0.0);
+            assert_eq!($inf.max(9.0), $inf);
+            assert_eq!(9.0.max($inf), $inf);
+            assert_eq!($inf.max(-9.0), $inf);
+            assert_eq!((-9.0).max($inf), $inf);
+            assert_eq!($neginf.max(9.0), 9.0);
+            assert_eq!(9.0.max($neginf), 9.0);
+            assert_eq!($neginf.max(-9.0), -9.0);
+            assert_eq!((-9.0).max($neginf), -9.0);
+            assert_eq!($nan.max(9.0), 9.0);
+            assert_eq!($nan.max(-9.0), -9.0);
+            assert_eq!(9.0.max($nan), 9.0);
+            assert_eq!((-9.0).max($nan), -9.0);
+            assert!($nan.max($nan).is_nan());
+        }
+    } }
+}
+
+test_float!(f32, f32, ::core::f32::INFINITY, ::core::f32::NEG_INFINITY, ::core::f32::NAN);
+test_float!(f64, f64, ::core::f64::INFINITY, ::core::f64::NEG_INFINITY, ::core::f64::NAN);