diff --git a/tests/run-pass/float.rs b/tests/run-pass/float.rs index 5acaf6a2a9..738df2f6c5 100644 --- a/tests/run-pass/float.rs +++ b/tests/run-pass/float.rs @@ -11,6 +11,12 @@ fn assert_eq(x: T, y: T) { } fn main() { + basic(); + casts(); + ops(); +} + +fn basic() { // basic arithmetic assert_eq(6.0_f32*6.0_f32, 36.0_f32); assert_eq(6.0_f64*6.0_f64, 36.0_f64); @@ -18,9 +24,22 @@ fn main() { assert_eq(-{5.0_f64}, -5.0_f64); // infinities, NaN assert!((5.0_f32/0.0).is_infinite()); + assert_ne!({5.0_f32/0.0}, {-5.0_f32/0.0}); assert!((5.0_f64/0.0).is_infinite()); + assert_ne!({5.0_f64/0.0}, {5.0_f64/-0.0}); assert!((-5.0_f32).sqrt().is_nan()); assert!((-5.0_f64).sqrt().is_nan()); + assert_ne!(f32::NAN, f32::NAN); + assert_ne!(f64::NAN, f64::NAN); + // negative zero + let posz = 0.0f32; + let negz = -0.0f32; + assert_eq(posz, negz); + assert_ne!(posz.to_bits(), negz.to_bits()); + let posz = 0.0f64; + let negz = -0.0f64; + assert_eq(posz, negz); + assert_ne!(posz.to_bits(), negz.to_bits()); // byte-level transmute let x: u64 = unsafe { std::mem::transmute(42.0_f64) }; let y: f64 = unsafe { std::mem::transmute(x) }; @@ -28,57 +47,180 @@ fn main() { let x: u32 = unsafe { std::mem::transmute(42.0_f32) }; let y: f32 = unsafe { std::mem::transmute(x) }; assert_eq(y, 42.0_f32); +} + +fn casts() { + // f32 -> i32 + assert_eq::(0.0f32 as i32, 0); + assert_eq::(-0.0f32 as i32, 0); + assert_eq::(/*0x1p-149*/ f32::from_bits(0x00000001) as i32, 0); + assert_eq::(/*-0x1p-149*/ f32::from_bits(0x80000001) as i32, 0); + assert_eq::(/*0x1.19999ap+0*/ f32::from_bits(0x3f8ccccd) as i32, 1); + assert_eq::(/*-0x1.19999ap+0*/ f32::from_bits(0xbf8ccccd) as i32, -1); + assert_eq::(1.9f32 as i32, 1); + assert_eq::(-1.9f32 as i32, -1); + assert_eq::(5.0f32 as i32, 5); + assert_eq::(-5.0f32 as i32, -5); + assert_eq::(2147483520.0f32 as i32, 2147483520); + assert_eq::(-2147483648.0f32 as i32, -2147483648); + // unrepresentable casts + assert_eq::(2147483648.0f32 as i32, i32::MAX); + assert_eq::(-2147483904.0f32 as i32, i32::MIN); + assert_eq::(f32::MAX as i32, i32::MAX); + assert_eq::(f32::MIN as i32, i32::MIN); + assert_eq::(f32::INFINITY as i32, i32::MAX); + assert_eq::(f32::NEG_INFINITY as i32, i32::MIN); + assert_eq::(f32::NAN as i32, 0); + assert_eq::((-f32::NAN) as i32, 0); + + // f32 -> u32 + assert_eq::(0.0f32 as u32, 0); + assert_eq::(-0.0f32 as u32, 0); + assert_eq::(/*0x1p-149*/ f32::from_bits(0x1) as u32, 0); + assert_eq::(/*-0x1p-149*/ f32::from_bits(0x80000001) as u32, 0); + assert_eq::(/*0x1.19999ap+0*/ f32::from_bits(0x3f8ccccd) as u32, 1); + assert_eq::(1.9f32 as u32, 1); + assert_eq::(5.0f32 as u32, 5); + assert_eq::(2147483648.0f32 as u32, 0x8000_0000); + assert_eq::(4294967040.0f32 as u32, 0u32.wrapping_sub(256)); + assert_eq::(/*-0x1.ccccccp-1*/ f32::from_bits(0xbf666666) as u32, 0); + assert_eq::(/*-0x1.fffffep-1*/ f32::from_bits(0xbf7fffff) as u32, 0); + assert_eq::((u32::MAX-127) as f32 as u32, u32::MAX); // rounding loss + assert_eq::((u32::MAX-128) as f32 as u32, u32::MAX-255); // rounding loss + // unrepresentable casts + assert_eq::(4294967296.0f32 as u32, u32::MAX); + assert_eq::(-5.0f32 as u32, 0); + assert_eq::(f32::MAX as u32, u32::MAX); + assert_eq::(f32::MIN as u32, 0); + assert_eq::(f32::INFINITY as u32, u32::MAX); + assert_eq::(f32::NEG_INFINITY as u32, 0); + assert_eq::(f32::NAN as u32, 0); + assert_eq::((-f32::NAN) as u32, 0); + + // f32 -> i64 + assert_eq::(4294967296.0f32 as i64, 4294967296); + assert_eq::(-4294967296.0f32 as i64, -4294967296); + assert_eq::(9223371487098961920.0f32 as i64, 9223371487098961920); + assert_eq::(-9223372036854775808.0f32 as i64, -9223372036854775808); + + // f64 -> i32 + assert_eq::(0.0f64 as i32, 0); + assert_eq::(-0.0f64 as i32, 0); + assert_eq::(/*0x1.199999999999ap+0*/ f64::from_bits(0x3ff199999999999a) as i32, 1); + assert_eq::(/*-0x1.199999999999ap+0*/ f64::from_bits(0xbff199999999999a) as i32, -1); + assert_eq::(1.9f64 as i32, 1); + assert_eq::(-1.9f64 as i32, -1); + assert_eq::(1e8f64 as i32, 100_000_000); + assert_eq::(2147483647.0f64 as i32, 2147483647); + assert_eq::(-2147483648.0f64 as i32, -2147483648); + // unrepresentable casts + assert_eq::(2147483648.0f64 as i32, i32::MAX); + assert_eq::(-2147483649.0f64 as i32, i32::MIN); + + // f64 -> i64 + assert_eq::(0.0f64 as i64, 0); + assert_eq::(-0.0f64 as i64, 0); + assert_eq::(/*0x0.0000000000001p-1022*/ f64::from_bits(0x1) as i64, 0); + assert_eq::(/*-0x0.0000000000001p-1022*/ f64::from_bits(0x8000000000000001) as i64, 0); + assert_eq::(/*0x1.199999999999ap+0*/ f64::from_bits(0x3ff199999999999a) as i64, 1); + assert_eq::(/*-0x1.199999999999ap+0*/ f64::from_bits(0xbff199999999999a) as i64, -1); + assert_eq::(5.0f64 as i64, 5); + assert_eq::(5.9f64 as i64, 5); + assert_eq::(-5.0f64 as i64, -5); + assert_eq::(-5.9f64 as i64, -5); + assert_eq::(4294967296.0f64 as i64, 4294967296); + assert_eq::(-4294967296.0f64 as i64, -4294967296); + assert_eq::(9223372036854774784.0f64 as i64, 9223372036854774784); + assert_eq::(-9223372036854775808.0f64 as i64, -9223372036854775808); + // unrepresentable casts + assert_eq::(9223372036854775808.0f64 as i64, i64::MAX); + assert_eq::(-9223372036854777856.0f64 as i64, i64::MIN); + assert_eq::(f64::MAX as i64, i64::MAX); + assert_eq::(f64::MIN as i64, i64::MIN); + assert_eq::(f64::INFINITY as i64, i64::MAX); + assert_eq::(f64::NEG_INFINITY as i64, i64::MIN); + assert_eq::(f64::NAN as i64, 0); + assert_eq::((-f64::NAN) as i64, 0); - // f32 <-> int casts - assert_eq(5.0f32 as u32, 5); - assert_eq(-5.0f32 as u32, 0); - assert_eq(5.0f32 as i32, 5); - assert_eq(-5.0f32 as i32, -5); - assert_eq(f32::MAX as i32, i32::MAX); - assert_eq(f32::INFINITY as i32, i32::MAX); - assert_eq(f32::MAX as u32, u32::MAX); - assert_eq(f32::INFINITY as u32, u32::MAX); - assert_eq(f32::MIN as i32, i32::MIN); - assert_eq(f32::NEG_INFINITY as i32, i32::MIN); - assert_eq(f32::MIN as u32, 0); - assert_eq(f32::NEG_INFINITY as u32, 0); - assert_eq(f32::NAN as i32, 0); - assert_eq(f32::NAN as u32, 0); - assert_eq((u32::MAX-127) as f32 as u32, u32::MAX); // rounding loss - assert_eq((u32::MAX-128) as f32 as u32, u32::MAX-255); // rounding loss - assert_eq(127i8 as f32, 127.0f32); - assert_eq(i128::MIN as f32, -170141183460469231731687303715884105728.0f32); - assert_eq(u128::MAX as f32, f32::INFINITY); // saturation - - // f64 <-> int casts - assert_eq(5.0f64 as u64, 5); - assert_eq(-5.0f64 as u64, 0); - assert_eq(5.0f64 as i64, 5); - assert_eq(-5.0f64 as i64, -5); - assert_eq(f64::MAX as i64, i64::MAX); - assert_eq(f64::INFINITY as i64, i64::MAX); - assert_eq(f64::MAX as u64, u64::MAX); - assert_eq(f64::INFINITY as u64, u64::MAX); - assert_eq(f64::MIN as i64, i64::MIN); - assert_eq(f64::NEG_INFINITY as i64, i64::MIN); - assert_eq(f64::MIN as u64, 0); - assert_eq(f64::NEG_INFINITY as u64, 0); - assert_eq(f64::NAN as i64, 0); - assert_eq(f64::NAN as u64, 0); - assert_eq((u64::MAX-1023) as f64 as u64, u64::MAX); // rounding loss - assert_eq((u64::MAX-1024) as f64 as u64, u64::MAX-2047); // rounding loss - assert_eq(u128::MAX as f64 as u128, u128::MAX); - assert_eq(i16::MIN as f64, -32768.0f64); - assert_eq(u128::MAX as f64, 340282366920938463463374607431768211455.0f64); // even that fits... - - // f32 <-> f64 casts - assert_eq(5.0f64 as f32, 5.0f32); - assert_eq(5.0f32 as f64, 5.0f64); - assert_eq(f64::MAX as f32, f32::INFINITY); - assert_eq(f64::MIN as f32, f32::NEG_INFINITY); - assert_eq(f32::INFINITY as f64, f64::INFINITY); - assert_eq(f32::NEG_INFINITY as f64, f64::NEG_INFINITY); + // f64 -> u64 + assert_eq::(0.0f64 as u64, 0); + assert_eq::(-0.0f64 as u64, 0); + assert_eq::(5.0f64 as u64, 5); + assert_eq::(-5.0f64 as u64, 0); + assert_eq::(1e16f64 as u64, 10000000000000000); + assert_eq::((u64::MAX-1023) as f64 as u64, u64::MAX); // rounding loss + assert_eq::((u64::MAX-1024) as f64 as u64, u64::MAX-2047); // rounding loss + assert_eq::(9223372036854775808.0f64 as u64, 9223372036854775808); + // unrepresentable casts + assert_eq::(18446744073709551616.0f64 as u64, u64::MAX); + assert_eq::(f64::MAX as u64, u64::MAX); + assert_eq::(f64::MIN as u64, 0); + assert_eq::(f64::INFINITY as u64, u64::MAX); + assert_eq::(f64::NEG_INFINITY as u64, 0); + assert_eq::(f64::NAN as u64, 0); + assert_eq::((-f64::NAN) as u64, 0); + + // int -> f32 + assert_eq::(127i8 as f32, 127.0); + assert_eq::(2147483647i32 as f32, 2147483648.0); + assert_eq::((-2147483648i32) as f32, -2147483648.0); + assert_eq::(1234567890i32 as f32, /*0x1.26580cp+30*/ f32::from_bits(0x4e932c06)); + assert_eq::(16777217i32 as f32, 16777216.0); + assert_eq::((-16777217i32) as f32, -16777216.0); + assert_eq::(16777219i32 as f32, 16777220.0); + assert_eq::((-16777219i32) as f32, -16777220.0); + assert_eq::(0x7fffff4000000001i64 as f32, /*0x1.fffffep+62*/ f32::from_bits(0x5effffff)); + assert_eq::(0x8000004000000001u64 as i64 as f32, /*-0x1.fffffep+62*/ f32::from_bits(0xdeffffff)); + assert_eq::(0x0020000020000001i64 as f32, /*0x1.000002p+53*/ f32::from_bits(0x5a000001)); + assert_eq::(0xffdfffffdfffffffu64 as i64 as f32, /*-0x1.000002p+53*/ f32::from_bits(0xda000001)); + assert_eq::(i128::MIN as f32, -170141183460469231731687303715884105728.0f32); + assert_eq::(u128::MAX as f32, f32::INFINITY); // saturation + + // int -> f64 + assert_eq::(127i8 as f64, 127.0); + assert_eq::(i16::MIN as f64, -32768.0f64); + assert_eq::(2147483647i32 as f64, 2147483647.0); + assert_eq::(-2147483648i32 as f64, -2147483648.0); + assert_eq::(987654321i32 as f64, 987654321.0); + assert_eq::(9223372036854775807i64 as f64, 9223372036854775807.0); + assert_eq::(-9223372036854775808i64 as f64, -9223372036854775808.0); + assert_eq::(4669201609102990i64 as f64, 4669201609102990.0); // Feigenbaum (?) + assert_eq::(9007199254740993i64 as f64, 9007199254740992.0); + assert_eq::(-9007199254740993i64 as f64, -9007199254740992.0); + assert_eq::(9007199254740995i64 as f64, 9007199254740996.0); + assert_eq::(-9007199254740995i64 as f64, -9007199254740996.0); + assert_eq::(u128::MAX as f64, 340282366920938463463374607431768211455.0f64); // even that fits... + + // f32 -> f64 + assert_eq::((0.0f32 as f64).to_bits(), 0.0f64.to_bits()); + assert_eq::(((-0.0f32) as f64).to_bits(), (-0.0f64).to_bits()); + assert_eq::(5.0f32 as f64, 5.0f64); + assert_eq::(/*0x1p-149*/ f32::from_bits(0x1) as f64, /*0x1p-149*/ f64::from_bits(0x36a0000000000000)); + assert_eq::(/*-0x1p-149*/ f32::from_bits(0x80000001) as f64, /*-0x1p-149*/ f64::from_bits(0xb6a0000000000000)); + assert_eq::(/*0x1.fffffep+127*/ f32::from_bits(0x7f7fffff) as f64, /*0x1.fffffep+127*/ f64::from_bits(0x47efffffe0000000)); + assert_eq::(/*-0x1.fffffep+127*/ (-f32::from_bits(0x7f7fffff)) as f64, /*-0x1.fffffep+127*/ -f64::from_bits(0x47efffffe0000000)); + assert_eq::(/*0x1p-119*/ f32::from_bits(0x4000000) as f64, /*0x1p-119*/ f64::from_bits(0x3880000000000000)); + assert_eq::(/*0x1.8f867ep+125*/ f32::from_bits(0x7e47c33f) as f64, 6.6382536710104395e+37); + assert_eq::(f32::INFINITY as f64, f64::INFINITY); + assert_eq::(f32::NEG_INFINITY as f64, f64::NEG_INFINITY); + + // f64 -> f32 + assert_eq::((0.0f64 as f32).to_bits(), 0.0f32.to_bits()); + assert_eq::(((-0.0f64) as f32).to_bits(), (-0.0f32).to_bits()); + assert_eq::(5.0f64 as f32, 5.0f32); + assert_eq::(/*0x0.0000000000001p-1022*/ f64::from_bits(0x1) as f32, 0.0); + assert_eq::(/*-0x0.0000000000001p-1022*/ (-f64::from_bits(0x1)) as f32, -0.0); + + assert_eq::(/*0x1.fffffe0000000p-127*/ f64::from_bits(0x380fffffe0000000) as f32, /*0x1p-149*/ f32::from_bits(0x800000)); + assert_eq::(/*0x1.4eae4f7024c7p+108*/ f64::from_bits(0x46b4eae4f7024c70) as f32, /*0x1.4eae5p+108*/ f32::from_bits(0x75a75728)); + + assert_eq::(f64::MAX as f32, f32::INFINITY); + assert_eq::(f64::MIN as f32, f32::NEG_INFINITY); + assert_eq::(f64::INFINITY as f32, f32::INFINITY); + assert_eq::(f64::NEG_INFINITY as f32, f32::NEG_INFINITY); +} +fn ops() { // f32 min/max assert_eq((1.0 as f32).max(-1.0), 1.0); assert_eq((1.0 as f32).min(-1.0), -1.0); diff --git a/tests/run-pass/float_fast_math.rs b/tests/run-pass/float_fast_math.rs index ba7e6ac3ec..8e5a88ff33 100644 --- a/tests/run-pass/float_fast_math.rs +++ b/tests/run-pass/float_fast_math.rs @@ -3,7 +3,19 @@ use std::intrinsics::{fadd_fast, fsub_fast, fmul_fast, fdiv_fast, frem_fast}; #[inline(never)] -pub fn test_operations(a: f64, b: f64) { +pub fn test_operations_f64(a: f64, b: f64) { + // make sure they all map to the correct operation + unsafe { + assert_eq!(fadd_fast(a, b), a + b); + assert_eq!(fsub_fast(a, b), a - b); + assert_eq!(fmul_fast(a, b), a * b); + assert_eq!(fdiv_fast(a, b), a / b); + assert_eq!(frem_fast(a, b), a % b); + } +} + +#[inline(never)] +pub fn test_operations_f32(a: f32, b: f32) { // make sure they all map to the correct operation unsafe { assert_eq!(fadd_fast(a, b), a + b); @@ -15,6 +27,8 @@ pub fn test_operations(a: f64, b: f64) { } fn main() { - test_operations(1., 2.); - test_operations(10., 5.); + test_operations_f64(1., 2.); + test_operations_f64(10., 5.); + test_operations_f32(11., 2.); + test_operations_f32(10., 15.); }