Skip to content

Commit 669aa5c

Browse files
rperierrperier
committed
Unify and deduplicate bits conv float tests
1 parent ebdf2ab commit 669aa5c

File tree

5 files changed

+48
-110
lines changed

5 files changed

+48
-110
lines changed

‎library/coretests/tests/floats/f128.rs‎

Lines changed: 0 additions & 28 deletions
Original file line numberDiff line numberDiff line change
@@ -17,12 +17,6 @@ const TOL: f128 = 1e-12;
1717
#[allow(unused)]
1818
const TOL_PRECISE: f128 = 1e-28;
1919

20-
/// First pattern over the mantissa
21-
const NAN_MASK1: u128 = 0x0000aaaaaaaaaaaaaaaaaaaaaaaaaaaa;
22-
23-
/// Second pattern over the mantissa
24-
const NAN_MASK2: u128 = 0x00005555555555555555555555555555;
25-
2620
// FIXME(f16_f128,miri): many of these have to be disabled since miri does not yet support
2721
// the intrinsics.
2822

@@ -54,28 +48,6 @@ fn test_max_recip() {
5448
);
5549
}
5650

57-
#[test]
58-
fn test_float_bits_conv() {
59-
assert_eq!((1f128).to_bits(), 0x3fff0000000000000000000000000000);
60-
assert_eq!((12.5f128).to_bits(), 0x40029000000000000000000000000000);
61-
assert_eq!((1337f128).to_bits(), 0x40094e40000000000000000000000000);
62-
assert_eq!((-14.25f128).to_bits(), 0xc002c800000000000000000000000000);
63-
assert_biteq!(f128::from_bits(0x3fff0000000000000000000000000000), 1.0);
64-
assert_biteq!(f128::from_bits(0x40029000000000000000000000000000), 12.5);
65-
assert_biteq!(f128::from_bits(0x40094e40000000000000000000000000), 1337.0);
66-
assert_biteq!(f128::from_bits(0xc002c800000000000000000000000000), -14.25);
67-
68-
// Check that NaNs roundtrip their bits regardless of signaling-ness
69-
// 0xA is 0b1010; 0x5 is 0b0101 -- so these two together clobbers all the mantissa bits
70-
let masked_nan1 = f128::NAN.to_bits() ^ NAN_MASK1;
71-
let masked_nan2 = f128::NAN.to_bits() ^ NAN_MASK2;
72-
assert!(f128::from_bits(masked_nan1).is_nan());
73-
assert!(f128::from_bits(masked_nan2).is_nan());
74-
75-
assert_eq!(f128::from_bits(masked_nan1).to_bits(), masked_nan1);
76-
assert_eq!(f128::from_bits(masked_nan2).to_bits(), masked_nan2);
77-
}
78-
7951
#[test]
8052
fn test_from() {
8153
assert_biteq!(f128::from(false), 0.0);

‎library/coretests/tests/floats/f16.rs‎

Lines changed: 0 additions & 27 deletions
Original file line numberDiff line numberDiff line change
@@ -19,12 +19,6 @@ const TOL_P2: f16 = 0.5;
1919
#[allow(unused)]
2020
const TOL_P4: f16 = 10.0;
2121

22-
/// First pattern over the mantissa
23-
const NAN_MASK1: u16 = 0x02aa;
24-
25-
/// Second pattern over the mantissa
26-
const NAN_MASK2: u16 = 0x0155;
27-
2822
// FIXME(f16_f128,miri): many of these have to be disabled since miri does not yet support
2923
// the intrinsics.
3024

@@ -52,27 +46,6 @@ fn test_max_recip() {
5246
assert_approx_eq!(f16::MAX.recip(), 1.526624e-5f16, 1e-4);
5347
}
5448

55-
#[test]
56-
fn test_float_bits_conv() {
57-
assert_eq!((1f16).to_bits(), 0x3c00);
58-
assert_eq!((12.5f16).to_bits(), 0x4a40);
59-
assert_eq!((1337f16).to_bits(), 0x6539);
60-
assert_eq!((-14.25f16).to_bits(), 0xcb20);
61-
assert_biteq!(f16::from_bits(0x3c00), 1.0);
62-
assert_biteq!(f16::from_bits(0x4a40), 12.5);
63-
assert_biteq!(f16::from_bits(0x6539), 1337.0);
64-
assert_biteq!(f16::from_bits(0xcb20), -14.25);
65-
66-
// Check that NaNs roundtrip their bits regardless of signaling-ness
67-
let masked_nan1 = f16::NAN.to_bits() ^ NAN_MASK1;
68-
let masked_nan2 = f16::NAN.to_bits() ^ NAN_MASK2;
69-
assert!(f16::from_bits(masked_nan1).is_nan());
70-
assert!(f16::from_bits(masked_nan2).is_nan());
71-
72-
assert_eq!(f16::from_bits(masked_nan1).to_bits(), masked_nan1);
73-
assert_eq!(f16::from_bits(masked_nan2).to_bits(), masked_nan2);
74-
}
75-
7649
#[test]
7750
fn test_from() {
7851
assert_biteq!(f16::from(false), 0.0);

‎library/coretests/tests/floats/f32.rs‎

Lines changed: 0 additions & 28 deletions
Original file line numberDiff line numberDiff line change
@@ -2,12 +2,6 @@ use core::f32;
22

33
use super::assert_biteq;
44

5-
/// First pattern over the mantissa
6-
const NAN_MASK1: u32 = 0x002a_aaaa;
7-
8-
/// Second pattern over the mantissa
9-
const NAN_MASK2: u32 = 0x0055_5555;
10-
115
// FIXME(#140515): mingw has an incorrect fma https://sourceforge.net/p/mingw-w64/bugs/848/
126
#[cfg_attr(all(target_os = "windows", target_env = "gnu", not(target_abi = "llvm")), ignore)]
137
#[test]
@@ -25,25 +19,3 @@ fn test_mul_add() {
2519
assert_biteq!(f32::math::mul_add(8.9f32, inf, 3.2), inf);
2620
assert_biteq!(f32::math::mul_add(-3.2f32, 2.4, neg_inf), neg_inf);
2721
}
28-
29-
#[test]
30-
fn test_float_bits_conv() {
31-
assert_eq!((1f32).to_bits(), 0x3f800000);
32-
assert_eq!((12.5f32).to_bits(), 0x41480000);
33-
assert_eq!((1337f32).to_bits(), 0x44a72000);
34-
assert_eq!((-14.25f32).to_bits(), 0xc1640000);
35-
assert_biteq!(f32::from_bits(0x3f800000), 1.0);
36-
assert_biteq!(f32::from_bits(0x41480000), 12.5);
37-
assert_biteq!(f32::from_bits(0x44a72000), 1337.0);
38-
assert_biteq!(f32::from_bits(0xc1640000), -14.25);
39-
40-
// Check that NaNs roundtrip their bits regardless of signaling-ness
41-
// 0xA is 0b1010; 0x5 is 0b0101 -- so these two together clobbers all the mantissa bits
42-
let masked_nan1 = f32::NAN.to_bits() ^ NAN_MASK1;
43-
let masked_nan2 = f32::NAN.to_bits() ^ NAN_MASK2;
44-
assert!(f32::from_bits(masked_nan1).is_nan());
45-
assert!(f32::from_bits(masked_nan2).is_nan());
46-
47-
assert_eq!(f32::from_bits(masked_nan1).to_bits(), masked_nan1);
48-
assert_eq!(f32::from_bits(masked_nan2).to_bits(), masked_nan2);
49-
}

‎library/coretests/tests/floats/f64.rs‎

Lines changed: 0 additions & 27 deletions
Original file line numberDiff line numberDiff line change
@@ -2,12 +2,6 @@ use core::f64;
22

33
use super::assert_biteq;
44

5-
/// First pattern over the mantissa
6-
const NAN_MASK1: u64 = 0x000a_aaaa_aaaa_aaaa;
7-
8-
/// Second pattern over the mantissa
9-
const NAN_MASK2: u64 = 0x0005_5555_5555_5555;
10-
115
// FIXME(#140515): mingw has an incorrect fma https://sourceforge.net/p/mingw-w64/bugs/848/
126
#[cfg_attr(all(target_os = "windows", target_env = "gnu", not(target_abi = "llvm")), ignore)]
137
#[test]
@@ -25,24 +19,3 @@ fn test_mul_add() {
2519
assert_biteq!(8.9f64.mul_add(inf, 3.2), inf);
2620
assert_biteq!((-3.2f64).mul_add(2.4, neg_inf), neg_inf);
2721
}
28-
29-
#[test]
30-
fn test_float_bits_conv() {
31-
assert_eq!((1f64).to_bits(), 0x3ff0000000000000);
32-
assert_eq!((12.5f64).to_bits(), 0x4029000000000000);
33-
assert_eq!((1337f64).to_bits(), 0x4094e40000000000);
34-
assert_eq!((-14.25f64).to_bits(), 0xc02c800000000000);
35-
assert_biteq!(f64::from_bits(0x3ff0000000000000), 1.0);
36-
assert_biteq!(f64::from_bits(0x4029000000000000), 12.5);
37-
assert_biteq!(f64::from_bits(0x4094e40000000000), 1337.0);
38-
assert_biteq!(f64::from_bits(0xc02c800000000000), -14.25);
39-
40-
// Check that NaNs roundtrip their bits regardless of signaling-ness
41-
let masked_nan1 = f64::NAN.to_bits() ^ NAN_MASK1;
42-
let masked_nan2 = f64::NAN.to_bits() ^ NAN_MASK2;
43-
assert!(f64::from_bits(masked_nan1).is_nan());
44-
assert!(f64::from_bits(masked_nan2).is_nan());
45-
46-
assert_eq!(f64::from_bits(masked_nan1).to_bits(), masked_nan1);
47-
assert_eq!(f64::from_bits(masked_nan2).to_bits(), masked_nan2);
48-
}

‎library/coretests/tests/floats/mod.rs‎

Lines changed: 48 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -30,6 +30,10 @@ trait TestableFloat: Sized {
3030
const EPS_ADD: Self;
3131
const EPS_MUL: Self;
3232
const EPS_DIV: Self;
33+
const RAW_1: Self::Int;
34+
const RAW_12_DOT_5: Self::Int;
35+
const RAW_1337: Self::Int;
36+
const RAW_MINUS_14_DOT_25: Self::Int;
3337
}
3438

3539
impl TestableFloat for f16 {
@@ -50,6 +54,10 @@ impl TestableFloat for f16 {
5054
const EPS_ADD: Self = if cfg!(miri) { 1e1 } else { 0.0 };
5155
const EPS_MUL: Self = if cfg!(miri) { 1e3 } else { 0.0 };
5256
const EPS_DIV: Self = if cfg!(miri) { 1e0 } else { 0.0 };
57+
const RAW_1: Self::Int = 0x3c00;
58+
const RAW_12_DOT_5: Self::Int = 0x4a40;
59+
const RAW_1337: Self::Int = 0x6539;
60+
const RAW_MINUS_14_DOT_25: Self::Int = 0xcb20;
5361
}
5462

5563
impl TestableFloat for f32 {
@@ -72,6 +80,10 @@ impl TestableFloat for f32 {
7280
const EPS_ADD: Self = if cfg!(miri) { 1e-3 } else { 0.0 };
7381
const EPS_MUL: Self = if cfg!(miri) { 1e-1 } else { 0.0 };
7482
const EPS_DIV: Self = if cfg!(miri) { 1e-4 } else { 0.0 };
83+
const RAW_1: Self::Int = 0x3f800000;
84+
const RAW_12_DOT_5: Self::Int = 0x41480000;
85+
const RAW_1337: Self::Int = 0x44a72000;
86+
const RAW_MINUS_14_DOT_25: Self::Int = 0xc1640000;
7587
}
7688

7789
impl TestableFloat for f64 {
@@ -90,6 +102,10 @@ impl TestableFloat for f64 {
90102
const EPS_ADD: Self = if cfg!(miri) { 1e-6 } else { 0.0 };
91103
const EPS_MUL: Self = if cfg!(miri) { 1e-6 } else { 0.0 };
92104
const EPS_DIV: Self = if cfg!(miri) { 1e-6 } else { 0.0 };
105+
const RAW_1: Self::Int = 0x3ff0000000000000;
106+
const RAW_12_DOT_5: Self::Int = 0x4029000000000000;
107+
const RAW_1337: Self::Int = 0x4094e40000000000;
108+
const RAW_MINUS_14_DOT_25: Self::Int = 0xc02c800000000000;
93109
}
94110

95111
impl TestableFloat for f128 {
@@ -108,6 +124,10 @@ impl TestableFloat for f128 {
108124
const EPS_ADD: Self = if cfg!(miri) { 1e-6 } else { 0.0 };
109125
const EPS_MUL: Self = if cfg!(miri) { 1e-6 } else { 0.0 };
110126
const EPS_DIV: Self = if cfg!(miri) { 1e-6 } else { 0.0 };
127+
const RAW_1: Self::Int = 0x3fff0000000000000000000000000000;
128+
const RAW_12_DOT_5: Self::Int = 0x40029000000000000000000000000000;
129+
const RAW_1337: Self::Int = 0x40094e40000000000000000000000000;
130+
const RAW_MINUS_14_DOT_25: Self::Int = 0xc002c800000000000000000000000000;
111131
}
112132

113133
/// Determine the tolerance for values of the argument type.
@@ -1479,3 +1499,31 @@ float_test! {
14791499
assert_approx_eq!(a.algebraic_rem(b), a % b, Float::EPS_DIV);
14801500
}
14811501
}
1502+
1503+
float_test! {
1504+
name: to_bits_conv,
1505+
attrs: {
1506+
const: #[cfg(false)],
1507+
f16: #[cfg(target_has_reliable_f16)],
1508+
f128: #[cfg(target_has_reliable_f128)],
1509+
},
1510+
test<Float> {
1511+
assert_eq!((1 as Float).to_bits(), Float::RAW_1);
1512+
assert_eq!((12.5 as Float).to_bits(), Float::RAW_12_DOT_5);
1513+
assert_eq!((1337 as Float).to_bits(), Float::RAW_1337);
1514+
assert_eq!((-14.25 as Float).to_bits(), Float::RAW_MINUS_14_DOT_25);
1515+
assert_biteq!(Float::from_bits(Float::RAW_1), 1.0);
1516+
assert_biteq!(Float::from_bits(Float::RAW_12_DOT_5), 12.5);
1517+
assert_biteq!(Float::from_bits(Float::RAW_1337), 1337.0);
1518+
assert_biteq!(Float::from_bits(Float::RAW_MINUS_14_DOT_25), -14.25);
1519+
1520+
// Check that NaNs roundtrip their bits regardless of signaling-ness
1521+
let masked_nan1 = Float::NAN.to_bits() ^ Float::NAN_MASK1;
1522+
let masked_nan2 = Float::NAN.to_bits() ^ Float::NAN_MASK2;
1523+
assert!(Float::from_bits(masked_nan1).is_nan());
1524+
assert!(Float::from_bits(masked_nan2).is_nan());
1525+
1526+
assert_eq!(Float::from_bits(masked_nan1).to_bits(), masked_nan1);
1527+
assert_eq!(Float::from_bits(masked_nan2).to_bits(), masked_nan2);
1528+
}
1529+
}

0 commit comments

Comments
 (0)