core: Implement feature float_exact_integer_constants

Implement accepted ACP for `MAX_EXACT_INTEGER` and `MIN_EXACT_INTEGER`
on `f16`, `f32`, `f64`, and `f128`
Add tests to `coretests/tests/num`

Author: okaneco

library/core/src/num/f128.rs

@@ -272,6 +272,32 @@ impl f128 {
     #[unstable(feature = "f128", issue = "116909")]
     pub const NEG_INFINITY: f128 = -1.0_f128 / 0.0_f128;
 
+    /// Maximum integer that can be represented exactly in an [`f128`] value,
+    /// with no other integer converting to the same floating point value.
+    ///
+    /// Values contained inclusively within [`MIN_EXACT_INTEGER`] to
+    /// [`MAX_EXACT_INTEGER`] can be losslessly converted between integer
+    /// and floating point.
+    ///
+    /// [`MAX_EXACT_INTEGER`]: f128::MAX_EXACT_INTEGER
+    /// [`MIN_EXACT_INTEGER`]: f128::MIN_EXACT_INTEGER
+    // #[unstable(feature = "f128", issue = "116909")]
+    #[unstable(feature = "float_exact_integer_constants", issue = "152466")]
+    pub const MAX_EXACT_INTEGER: i128 = (1 << Self::MANTISSA_DIGITS) - 1;
+
+    /// Minimum integer that can be represented exactly in an [`f128`] value,
+    /// with no other integer converting to the same floating point value.
+    ///
+    /// Values contained inclusively within [`MIN_EXACT_INTEGER`] to
+    /// [`MAX_EXACT_INTEGER`] can be losslessly converted between integer
+    /// and floating point.
+    ///
+    /// [`MAX_EXACT_INTEGER`]: f128::MAX_EXACT_INTEGER
+    /// [`MIN_EXACT_INTEGER`]: f128::MIN_EXACT_INTEGER
+    // #[unstable(feature = "f128", issue = "116909")]
+    #[unstable(feature = "float_exact_integer_constants", issue = "152466")]
+    pub const MIN_EXACT_INTEGER: i128 = -Self::MAX_EXACT_INTEGER;
+
     /// Sign bit
     pub(crate) const SIGN_MASK: u128 = 0x8000_0000_0000_0000_0000_0000_0000_0000;
 

library/core/src/num/f16.rs

@@ -266,6 +266,32 @@ impl f16 {
     #[unstable(feature = "f16", issue = "116909")]
     pub const NEG_INFINITY: f16 = -1.0_f16 / 0.0_f16;
 
+    /// Maximum integer that can be represented exactly in an [`f16`] value,
+    /// with no other integer converting to the same floating point value.
+    ///
+    /// Values contained inclusively within [`MIN_EXACT_INTEGER`] to
+    /// [`MAX_EXACT_INTEGER`] can be losslessly converted between integer
+    /// and floating point.
+    ///
+    /// [`MAX_EXACT_INTEGER`]: f16::MAX_EXACT_INTEGER
+    /// [`MIN_EXACT_INTEGER`]: f16::MIN_EXACT_INTEGER
+    // #[unstable(feature = "f16", issue = "116909")]
+    #[unstable(feature = "float_exact_integer_constants", issue = "152466")]
+    pub const MAX_EXACT_INTEGER: i16 = (1 << Self::MANTISSA_DIGITS) - 1;
+
+    /// Minimum integer that can be represented exactly in an [`f16`] value,
+    /// with no other integer converting to the same floating point value.
+    ///
+    /// Values contained inclusively within [`MIN_EXACT_INTEGER`] to
+    /// [`MAX_EXACT_INTEGER`] can be losslessly converted between integer
+    /// and floating point.
+    ///
+    /// [`MAX_EXACT_INTEGER`]: f16::MAX_EXACT_INTEGER
+    /// [`MIN_EXACT_INTEGER`]: f16::MIN_EXACT_INTEGER
+    // #[unstable(feature = "f16", issue = "116909")]
+    #[unstable(feature = "float_exact_integer_constants", issue = "152466")]
+    pub const MIN_EXACT_INTEGER: i16 = -Self::MAX_EXACT_INTEGER;
+
     /// Sign bit
     pub(crate) const SIGN_MASK: u16 = 0x8000;
 

library/core/src/num/f32.rs

@@ -513,6 +513,30 @@ impl f32 {
     #[stable(feature = "assoc_int_consts", since = "1.43.0")]
     pub const NEG_INFINITY: f32 = -1.0_f32 / 0.0_f32;
 
+    /// Maximum integer that can be represented exactly in an [`f32`] value,
+    /// with no other integer converting to the same floating point value.
+    ///
+    /// Values contained inclusively within [`MIN_EXACT_INTEGER`] to
+    /// [`MAX_EXACT_INTEGER`] can be losslessly converted between integer
+    /// and floating point.
+    ///
+    /// [`MAX_EXACT_INTEGER`]: f32::MAX_EXACT_INTEGER
+    /// [`MIN_EXACT_INTEGER`]: f32::MIN_EXACT_INTEGER
+    #[unstable(feature = "float_exact_integer_constants", issue = "152466")]
+    pub const MAX_EXACT_INTEGER: i32 = (1 << Self::MANTISSA_DIGITS) - 1;
+
+    /// Minimum integer that can be represented exactly in an [`f32`] value,
+    /// with no other integer converting to the same floating point value.
+    ///
+    /// Values contained inclusively within [`MIN_EXACT_INTEGER`] to
+    /// [`MAX_EXACT_INTEGER`] can be losslessly converted between integer
+    /// and floating point.
+    ///
+    /// [`MAX_EXACT_INTEGER`]: f32::MAX_EXACT_INTEGER
+    /// [`MIN_EXACT_INTEGER`]: f32::MIN_EXACT_INTEGER
+    #[unstable(feature = "float_exact_integer_constants", issue = "152466")]
+    pub const MIN_EXACT_INTEGER: i32 = -Self::MAX_EXACT_INTEGER;
+
     /// Sign bit
     pub(crate) const SIGN_MASK: u32 = 0x8000_0000;
 

library/core/src/num/f64.rs

@@ -512,6 +512,30 @@ impl f64 {
     #[stable(feature = "assoc_int_consts", since = "1.43.0")]
     pub const NEG_INFINITY: f64 = -1.0_f64 / 0.0_f64;
 
+    /// Maximum integer that can be represented exactly in an [`f64`] value,
+    /// with no other integer converting to the same floating point value.
+    ///
+    /// Values contained inclusively within [`MIN_EXACT_INTEGER`] to
+    /// [`MAX_EXACT_INTEGER`] can be losslessly converted between integer
+    /// and floating point.
+    ///
+    /// [`MAX_EXACT_INTEGER`]: f64::MAX_EXACT_INTEGER
+    /// [`MIN_EXACT_INTEGER`]: f64::MIN_EXACT_INTEGER
+    #[unstable(feature = "float_exact_integer_constants", issue = "152466")]
+    pub const MAX_EXACT_INTEGER: i64 = (1 << Self::MANTISSA_DIGITS) - 1;
+
+    /// Minimum integer that can be represented exactly in an [`f64`] value,
+    /// with no other integer converting to the same floating point value.
+    ///
+    /// Values contained inclusively within [`MIN_EXACT_INTEGER`] to
+    /// [`MAX_EXACT_INTEGER`] can be losslessly converted between integer
+    /// and floating point.
+    ///
+    /// [`MAX_EXACT_INTEGER`]: f64::MAX_EXACT_INTEGER
+    /// [`MIN_EXACT_INTEGER`]: f64::MIN_EXACT_INTEGER
+    #[unstable(feature = "float_exact_integer_constants", issue = "152466")]
+    pub const MIN_EXACT_INTEGER: i64 = -Self::MAX_EXACT_INTEGER;
+
     /// Sign bit
     pub(crate) const SIGN_MASK: u64 = 0x8000_0000_0000_0000;
 

library/coretests/tests/lib.rs

@@ -55,6 +55,7 @@
 #![feature(f16)]
 #![feature(f128)]
 #![feature(float_algebraic)]
+#![feature(float_exact_integer_constants)]
 #![feature(float_gamma)]
 #![feature(float_minimum_maximum)]
 #![feature(flt2dec)]

library/coretests/tests/num/float_exact_integer.rs

@@ -0,0 +1,62 @@
+// Test the `float_exact_integer_constants` feature
+macro_rules! test_float_exact_integer_constants {
+    ($fn_name:ident, $float:ty, $integer:ty) => {
+        #[test]
+        fn $fn_name() {
+            {
+                // The maximum integer that converts to a unique floating point
+                // value.
+                const MAX_EXACT_INTEGER: $integer = <$float>::MAX_EXACT_INTEGER;
+
+                let max_minus_one = (MAX_EXACT_INTEGER - 1) as $float as $integer;
+                let max_plus_one = (MAX_EXACT_INTEGER + 1) as $float as $integer;
+                let max_plus_two = (MAX_EXACT_INTEGER + 2) as $float as $integer;
+
+                // Lossless roundtrips.
+                assert_eq!(MAX_EXACT_INTEGER - 1, max_minus_one);
+                assert_eq!(MAX_EXACT_INTEGER, MAX_EXACT_INTEGER as $float as $integer);
+                assert_eq!(MAX_EXACT_INTEGER + 1, max_plus_one);
+                // The first non-unique conversion, which roundtrips to one less
+                // than the starting value.
+                assert_ne!(MAX_EXACT_INTEGER + 2, max_plus_two);
+
+                // max-1 | max+0 | max+1 | max+2
+                // After roundtripping, +1 and +2 will equal each other.
+                assert_ne!(max_minus_one, MAX_EXACT_INTEGER);
+                assert_ne!(MAX_EXACT_INTEGER, max_plus_one);
+                assert_eq!(max_plus_one, max_plus_two);
+            }
+
+            {
+                // The minimum integer that converts to a unique floating point
+                // value.
+                const MIN_EXACT_INTEGER: $integer = <$float>::MIN_EXACT_INTEGER;
+
+                // Same logic as the previous block, but we work our way leftward
+                // across the number line from (min_exact + 1) to (min_exact - 2).
+                let min_plus_one = (MIN_EXACT_INTEGER + 1) as $float as $integer;
+                let min_minus_one = (MIN_EXACT_INTEGER - 1) as $float as $integer;
+                let min_minus_two = (MIN_EXACT_INTEGER - 2) as $float as $integer;
+
+                // Lossless roundtrips.
+                assert_eq!(MIN_EXACT_INTEGER + 1, min_plus_one);
+                assert_eq!(MIN_EXACT_INTEGER, MIN_EXACT_INTEGER as $float as $integer);
+                assert_eq!(MIN_EXACT_INTEGER - 1, min_minus_one);
+                // The first non-unique conversion, which roundtrips to one
+                // greater than the starting value.
+                assert_ne!(MIN_EXACT_INTEGER - 2, min_minus_two);
+
+                // min-2 | min-1 | min | min+1
+                // After roundtripping, -2 and -1 will equal each other.
+                assert_ne!(min_plus_one, MIN_EXACT_INTEGER);
+                assert_ne!(MIN_EXACT_INTEGER, min_minus_one);
+                assert_eq!(min_minus_one, min_minus_two);
+            }
+        }
+    };
+}
+
+test_float_exact_integer_constants! { test_f16_min_max_exact_integer, f16, i16 }
+test_float_exact_integer_constants! { test_f32_min_max_exact_integer, f32, i32 }
+test_float_exact_integer_constants! { test_f64_min_max_exact_integer, f64, i64 }
+test_float_exact_integer_constants! { test_f128_min_max_exact_integer, f128, i128 }

library/coretests/tests/num/mod.rs

@@ -24,6 +24,7 @@ mod u8;
 mod bignum;
 mod const_from;
 mod dec2flt;
+mod float_exact_integer;
 mod float_iter_sum_identity;
 mod flt2dec;
 mod ieee754;