Auto merge of #147818 - rperier:unify_and_dedup_max_recip_float_tests, r=tgross35

Unify and deduplicate max recip float tests
cc #141726
This is a proposal to unify and deduplicate max recip tests for f16 and f128

Author: bors

library/coretests/tests/floats/f128.rs

@@ -1,8 +1,6 @@
 // FIXME(f16_f128): only tested on platforms that have symbols and aren't buggy
 #![cfg(target_has_reliable_f128)]
 
-#[cfg(any(miri, target_has_reliable_f128_math))]
-usesuper::assert_approx_eq;
 usesuper::assert_biteq;
 
 // Note these tolerances make sense around zero, but not for more extreme exponents.
@@ -20,16 +18,6 @@ const TOL_PRECISE: f128 = 1e-28;
 // FIXME(f16_f128,miri): many of these have to be disabled since miri does not yet support
 // the intrinsics.
 
-#[test]
-#[cfg(any(miri, target_has_reliable_f128_math))]
-fntest_max_recip(){
-assert_approx_eq!(
- f128::MAX.recip(),
-8.40525785778023376565669454330438228902076605e-4933,
-1e-4900
-);
-}
-
 #[test]
 fntest_from(){
 assert_biteq!(f128::from(false),0.0);

library/coretests/tests/floats/f16.rs

@@ -1,7 +1,7 @@
 // FIXME(f16_f128): only tested on platforms that have symbols and aren't buggy
 #![cfg(target_has_reliable_f16)]
 
-usesuper::{assert_approx_eq,assert_biteq};
+usesuper::assert_biteq;
 
 /// Tolerance for results on the order of 10.0e-2
 #[allow(unused)]
@@ -22,12 +22,6 @@ const TOL_P4: f16 = 10.0;
 // FIXME(f16_f128,miri): many of these have to be disabled since miri does not yet support
 // the intrinsics.
 
-#[test]
-#[cfg(any(miri, target_has_reliable_f16_math))]
-fntest_max_recip(){
-assert_approx_eq!(f16::MAX.recip(),1.526624e-5f16,1e-4);
-}
-
 #[test]
 fntest_from(){
 assert_biteq!(f16::from(false),0.0);

library/coretests/tests/floats/mod.rs

@@ -38,6 +38,8 @@ trait TestableFloat: Sized {
 constMUL_ADD_RESULT:Self;
 /// The result of (-12.3).mul_add(-4.5, -6.7)
 constNEG_MUL_ADD_RESULT:Self;
+/// Reciprocal of the maximum val
+constMAX_RECIP:Self;
 }
 
 implTestableFloatforf16{
@@ -64,6 +66,7 @@ impl TestableFloat for f16 {
 constRAW_MINUS_14_DOT_25:Self = Self::from_bits(0xcb20);
 constMUL_ADD_RESULT:Self = 62.031;
 constNEG_MUL_ADD_RESULT:Self = 48.625;
+constMAX_RECIP:Self = 1.526624e-5;
 }
 
 implTestableFloatforf32{
@@ -92,6 +95,7 @@ impl TestableFloat for f32 {
 constRAW_MINUS_14_DOT_25:Self = Self::from_bits(0xc1640000);
 constMUL_ADD_RESULT:Self = 62.05;
 constNEG_MUL_ADD_RESULT:Self = 48.65;
+constMAX_RECIP:Self = 2.938736e-39;
 }
 
 implTestableFloatforf64{
@@ -116,6 +120,7 @@ impl TestableFloat for f64 {
 constRAW_MINUS_14_DOT_25:Self = Self::from_bits(0xc02c800000000000);
 constMUL_ADD_RESULT:Self = 62.050000000000004;
 constNEG_MUL_ADD_RESULT:Self = 48.650000000000006;
+constMAX_RECIP:Self = 5.562684646268003e-309;
 }
 
 implTestableFloatforf128{
@@ -140,6 +145,7 @@ impl TestableFloat for f128 {
 constRAW_MINUS_14_DOT_25:Self = Self::from_bits(0xc002c800000000000000000000000000);
 constMUL_ADD_RESULT:Self = 62.0500000000000000000000000000000037;
 constNEG_MUL_ADD_RESULT:Self = 48.6500000000000000000000000000000049;
+constMAX_RECIP:Self = 8.40525785778023376565669454330438228902076605e-4933;
 }
 
 /// Determine the tolerance for values of the argument type.
@@ -1425,13 +1431,15 @@ float_test! {
 let nan:Float = Float::NAN;
 let inf:Float = Float::INFINITY;
 let neg_inf:Float = Float::NEG_INFINITY;
+let max:Float = Float::MAX;
  assert_biteq!((1.0asFloat).recip(),1.0);
  assert_biteq!((2.0asFloat).recip(),0.5);
  assert_biteq!((-0.4asFloat).recip(), -2.5);
  assert_biteq!((0.0asFloat).recip(), inf);
  assert!(nan.recip().is_nan());
  assert_biteq!(inf.recip(),0.0);
  assert_biteq!(neg_inf.recip(), -0.0);
+ assert_biteq!(max.recip(),Float::MAX_RECIP);
 }
 }