@@ -39,17 +39,6 @@ const NAN_MASK1: u128 = 0x0000aaaaaaaaaaaaaaaaaaaaaaaaaaaa;
39
39
/// Second pattern over the mantissa
40
40
const NAN_MASK2 : u128 = 0x00005555555555555555555555555555 ;
41
41
42
- /// Compare by representation
43
- #[ allow( unused_macros) ]
44
- macro_rules! assert_f128_biteq {
45
- ( $a: expr, $b: expr) => {
46
- let ( l, r) : ( & f128, & f128) = ( & $a, & $b) ;
47
- let lb = l. to_bits( ) ;
48
- let rb = r. to_bits( ) ;
49
- assert_eq!( lb, rb, "float {l:?} is not bitequal to {r:?}.\n a: {lb:#034x}\n b: {rb:#034x}" ) ;
50
- } ;
51
- }
52
-
53
42
#[ test]
54
43
fn test_num_f128 ( ) {
55
44
// FIXME(f16_f128): replace with a `test_num` call once the required `fmodl`/`fmodf128`
@@ -401,27 +390,27 @@ fn test_next_up() {
401
390
let max_down = f128:: from_bits ( MAX_DOWN_BITS ) ;
402
391
let largest_subnormal = f128:: from_bits ( LARGEST_SUBNORMAL_BITS ) ;
403
392
let smallest_normal = f128:: from_bits ( SMALLEST_NORMAL_BITS ) ;
404
- assert_f128_biteq ! ( f128:: NEG_INFINITY . next_up( ) , f128:: MIN ) ;
405
- assert_f128_biteq ! ( f128:: MIN . next_up( ) , -max_down) ;
406
- assert_f128_biteq ! ( ( -1.0 - f128:: EPSILON ) . next_up( ) , -1.0 ) ;
407
- assert_f128_biteq ! ( ( -smallest_normal) . next_up( ) , -largest_subnormal) ;
408
- assert_f128_biteq ! ( ( -tiny_up) . next_up( ) , -tiny) ;
409
- assert_f128_biteq ! ( ( -tiny) . next_up( ) , -0.0f128 ) ;
410
- assert_f128_biteq ! ( ( -0.0f128 ) . next_up( ) , tiny) ;
411
- assert_f128_biteq ! ( 0.0f128 . next_up( ) , tiny) ;
412
- assert_f128_biteq ! ( tiny. next_up( ) , tiny_up) ;
413
- assert_f128_biteq ! ( largest_subnormal. next_up( ) , smallest_normal) ;
414
- assert_f128_biteq ! ( 1.0f128 . next_up( ) , 1.0 + f128:: EPSILON ) ;
415
- assert_f128_biteq ! ( f128:: MAX . next_up( ) , f128:: INFINITY ) ;
416
- assert_f128_biteq ! ( f128:: INFINITY . next_up( ) , f128:: INFINITY ) ;
393
+ assert_biteq ! ( f128:: NEG_INFINITY . next_up( ) , f128:: MIN ) ;
394
+ assert_biteq ! ( f128:: MIN . next_up( ) , -max_down) ;
395
+ assert_biteq ! ( ( -1.0 - f128:: EPSILON ) . next_up( ) , -1.0f128 ) ;
396
+ assert_biteq ! ( ( -smallest_normal) . next_up( ) , -largest_subnormal) ;
397
+ assert_biteq ! ( ( -tiny_up) . next_up( ) , -tiny) ;
398
+ assert_biteq ! ( ( -tiny) . next_up( ) , -0.0f128 ) ;
399
+ assert_biteq ! ( ( -0.0f128 ) . next_up( ) , tiny) ;
400
+ assert_biteq ! ( 0.0f128 . next_up( ) , tiny) ;
401
+ assert_biteq ! ( tiny. next_up( ) , tiny_up) ;
402
+ assert_biteq ! ( largest_subnormal. next_up( ) , smallest_normal) ;
403
+ assert_biteq ! ( 1.0f128 . next_up( ) , 1.0 + f128:: EPSILON ) ;
404
+ assert_biteq ! ( f128:: MAX . next_up( ) , f128:: INFINITY ) ;
405
+ assert_biteq ! ( f128:: INFINITY . next_up( ) , f128:: INFINITY ) ;
417
406
418
407
// Check that NaNs roundtrip.
419
408
let nan0 = f128:: NAN ;
420
409
let nan1 = f128:: from_bits ( f128:: NAN . to_bits ( ) ^ 0x002a_aaaa ) ;
421
410
let nan2 = f128:: from_bits ( f128:: NAN . to_bits ( ) ^ 0x0055_5555 ) ;
422
- assert_f128_biteq ! ( nan0. next_up( ) , nan0) ;
423
- assert_f128_biteq ! ( nan1. next_up( ) , nan1) ;
424
- assert_f128_biteq ! ( nan2. next_up( ) , nan2) ;
411
+ assert_biteq ! ( nan0. next_up( ) , nan0) ;
412
+ assert_biteq ! ( nan1. next_up( ) , nan1) ;
413
+ assert_biteq ! ( nan2. next_up( ) , nan2) ;
425
414
}
426
415
427
416
#[ test]
@@ -431,28 +420,28 @@ fn test_next_down() {
431
420
let max_down = f128:: from_bits ( MAX_DOWN_BITS ) ;
432
421
let largest_subnormal = f128:: from_bits ( LARGEST_SUBNORMAL_BITS ) ;
433
422
let smallest_normal = f128:: from_bits ( SMALLEST_NORMAL_BITS ) ;
434
- assert_f128_biteq ! ( f128:: NEG_INFINITY . next_down( ) , f128:: NEG_INFINITY ) ;
435
- assert_f128_biteq ! ( f128:: MIN . next_down( ) , f128:: NEG_INFINITY ) ;
436
- assert_f128_biteq ! ( ( -max_down) . next_down( ) , f128:: MIN ) ;
437
- assert_f128_biteq ! ( ( -1.0f128 ) . next_down( ) , -1.0 - f128:: EPSILON ) ;
438
- assert_f128_biteq ! ( ( -largest_subnormal) . next_down( ) , -smallest_normal) ;
439
- assert_f128_biteq ! ( ( -tiny) . next_down( ) , -tiny_up) ;
440
- assert_f128_biteq ! ( ( -0.0f128 ) . next_down( ) , -tiny) ;
441
- assert_f128_biteq ! ( ( 0.0f128 ) . next_down( ) , -tiny) ;
442
- assert_f128_biteq ! ( tiny. next_down( ) , 0.0f128 ) ;
443
- assert_f128_biteq ! ( tiny_up. next_down( ) , tiny) ;
444
- assert_f128_biteq ! ( smallest_normal. next_down( ) , largest_subnormal) ;
445
- assert_f128_biteq ! ( ( 1.0 + f128:: EPSILON ) . next_down( ) , 1.0f128 ) ;
446
- assert_f128_biteq ! ( f128:: MAX . next_down( ) , max_down) ;
447
- assert_f128_biteq ! ( f128:: INFINITY . next_down( ) , f128:: MAX ) ;
423
+ assert_biteq ! ( f128:: NEG_INFINITY . next_down( ) , f128:: NEG_INFINITY ) ;
424
+ assert_biteq ! ( f128:: MIN . next_down( ) , f128:: NEG_INFINITY ) ;
425
+ assert_biteq ! ( ( -max_down) . next_down( ) , f128:: MIN ) ;
426
+ assert_biteq ! ( ( -1.0f128 ) . next_down( ) , -1.0 - f128:: EPSILON ) ;
427
+ assert_biteq ! ( ( -largest_subnormal) . next_down( ) , -smallest_normal) ;
428
+ assert_biteq ! ( ( -tiny) . next_down( ) , -tiny_up) ;
429
+ assert_biteq ! ( ( -0.0f128 ) . next_down( ) , -tiny) ;
430
+ assert_biteq ! ( ( 0.0f128 ) . next_down( ) , -tiny) ;
431
+ assert_biteq ! ( tiny. next_down( ) , 0.0f128 ) ;
432
+ assert_biteq ! ( tiny_up. next_down( ) , tiny) ;
433
+ assert_biteq ! ( smallest_normal. next_down( ) , largest_subnormal) ;
434
+ assert_biteq ! ( ( 1.0 + f128:: EPSILON ) . next_down( ) , 1.0f128 ) ;
435
+ assert_biteq ! ( f128:: MAX . next_down( ) , max_down) ;
436
+ assert_biteq ! ( f128:: INFINITY . next_down( ) , f128:: MAX ) ;
448
437
449
438
// Check that NaNs roundtrip.
450
439
let nan0 = f128:: NAN ;
451
440
let nan1 = f128:: from_bits ( f128:: NAN . to_bits ( ) ^ 0x002a_aaaa ) ;
452
441
let nan2 = f128:: from_bits ( f128:: NAN . to_bits ( ) ^ 0x0055_5555 ) ;
453
- assert_f128_biteq ! ( nan0. next_down( ) , nan0) ;
454
- assert_f128_biteq ! ( nan1. next_down( ) , nan1) ;
455
- assert_f128_biteq ! ( nan2. next_down( ) , nan2) ;
442
+ assert_biteq ! ( nan0. next_down( ) , nan0) ;
443
+ assert_biteq ! ( nan1. next_down( ) , nan1) ;
444
+ assert_biteq ! ( nan2. next_down( ) , nan2) ;
456
445
}
457
446
458
447
#[ test]
0 commit comments