1
- // Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
1
+ // Copyright 2012-2015 The Rust Project Developers. See the COPYRIGHT
2
2
// file at the top-level directory of this distribution and at
3
3
// http://rust-lang.org/COPYRIGHT.
4
4
//
@@ -468,6 +468,11 @@ mod tests {
468
468
use num:: * ;
469
469
use num:: FpCategory as Fp ;
470
470
471
+ #[ test]
472
+ fn test_num_f32 ( ) {
473
+ test_num ( 10f32 , 2f32 ) ;
474
+ }
475
+
471
476
#[ test]
472
477
fn test_min_nan ( ) {
473
478
assert_eq ! ( NAN . min( 2.0 ) , 2.0 ) ;
@@ -481,8 +486,49 @@ mod tests {
481
486
}
482
487
483
488
#[ test]
484
- fn test_num_f32 ( ) {
485
- test_num ( 10f32 , 2f32 ) ;
489
+ fn test_is_normal ( ) {
490
+ let nan: f32 = Float :: nan ( ) ;
491
+ let inf: f32 = Float :: infinity ( ) ;
492
+ let neg_inf: f32 = Float :: neg_infinity ( ) ;
493
+ let zero: f32 = Float :: zero ( ) ;
494
+ let neg_zero: f32 = Float :: neg_zero ( ) ;
495
+ assert ! ( !nan. is_normal( ) ) ;
496
+ assert ! ( !inf. is_normal( ) ) ;
497
+ assert ! ( !neg_inf. is_normal( ) ) ;
498
+ assert ! ( !zero. is_normal( ) ) ;
499
+ assert ! ( !neg_zero. is_normal( ) ) ;
500
+ assert ! ( 1f32 . is_normal( ) ) ;
501
+ assert ! ( 1e-37f32 . is_normal( ) ) ;
502
+ assert ! ( !1e-38f32 . is_normal( ) ) ;
503
+ }
504
+
505
+ #[ test]
506
+ fn test_classify ( ) {
507
+ let nan: f32 = Float :: nan ( ) ;
508
+ let inf: f32 = Float :: infinity ( ) ;
509
+ let neg_inf: f32 = Float :: neg_infinity ( ) ;
510
+ let zero: f32 = Float :: zero ( ) ;
511
+ let neg_zero: f32 = Float :: neg_zero ( ) ;
512
+ assert_eq ! ( nan. classify( ) , Fp :: Nan ) ;
513
+ assert_eq ! ( inf. classify( ) , Fp :: Infinite ) ;
514
+ assert_eq ! ( neg_inf. classify( ) , Fp :: Infinite ) ;
515
+ assert_eq ! ( zero. classify( ) , Fp :: Zero ) ;
516
+ assert_eq ! ( neg_zero. classify( ) , Fp :: Zero ) ;
517
+ assert_eq ! ( 1f32 . classify( ) , Fp :: Normal ) ;
518
+ assert_eq ! ( 1e-37f32 . classify( ) , Fp :: Normal ) ;
519
+ assert_eq ! ( 1e-38f32 . classify( ) , Fp :: Subnormal ) ;
520
+ }
521
+
522
+ #[ test]
523
+ fn test_integer_decode ( ) {
524
+ assert_eq ! ( 3.14159265359f32 . integer_decode( ) , ( 13176795 , -22 , 1 ) ) ;
525
+ assert_eq ! ( ( -8573.5918555f32 ) . integer_decode( ) , ( 8779358 , -10 , -1 ) ) ;
526
+ assert_eq ! ( 2f32 . powf( 100.0 ) . integer_decode( ) , ( 8388608 , 77 , 1 ) ) ;
527
+ assert_eq ! ( 0f32 . integer_decode( ) , ( 0 , -150 , 1 ) ) ;
528
+ assert_eq ! ( ( -0f32 ) . integer_decode( ) , ( 0 , -150 , -1 ) ) ;
529
+ assert_eq ! ( INFINITY . integer_decode( ) , ( 8388608 , 105 , 1 ) ) ;
530
+ assert_eq ! ( NEG_INFINITY . integer_decode( ) , ( 8388608 , 105 , -1 ) ) ;
531
+ assert_eq ! ( NAN . integer_decode( ) , ( 12582912 , 105 , 1 ) ) ;
486
532
}
487
533
488
534
#[ test]
@@ -555,6 +601,65 @@ mod tests {
555
601
assert_approx_eq ! ( ( -1.7f32 ) . fract( ) , -0.7f32 ) ;
556
602
}
557
603
604
+ #[ test]
605
+ pub fn test_abs ( ) {
606
+ assert_eq ! ( INFINITY . abs( ) , INFINITY ) ;
607
+ assert_eq ! ( 1f32 . abs( ) , 1f32 ) ;
608
+ assert_eq ! ( 0f32 . abs( ) , 0f32 ) ;
609
+ assert_eq ! ( ( -0f32 ) . abs( ) , 0f32 ) ;
610
+ assert_eq ! ( ( -1f32 ) . abs( ) , 1f32 ) ;
611
+ assert_eq ! ( NEG_INFINITY . abs( ) , INFINITY ) ;
612
+ assert_eq ! ( ( 1f32 /NEG_INFINITY ) . abs( ) , 0f32 ) ;
613
+ assert ! ( NAN . abs( ) . is_nan( ) ) ;
614
+ }
615
+
616
+ #[ test]
617
+ fn test_signum ( ) {
618
+ assert_eq ! ( INFINITY . signum( ) , 1f32 ) ;
619
+ assert_eq ! ( 1f32 . signum( ) , 1f32 ) ;
620
+ assert_eq ! ( 0f32 . signum( ) , 1f32 ) ;
621
+ assert_eq ! ( ( -0f32 ) . signum( ) , -1f32 ) ;
622
+ assert_eq ! ( ( -1f32 ) . signum( ) , -1f32 ) ;
623
+ assert_eq ! ( NEG_INFINITY . signum( ) , -1f32 ) ;
624
+ assert_eq ! ( ( 1f32 /NEG_INFINITY ) . signum( ) , -1f32 ) ;
625
+ assert ! ( NAN . signum( ) . is_nan( ) ) ;
626
+ }
627
+
628
+ #[ test]
629
+ fn test_is_positive ( ) {
630
+ assert ! ( INFINITY . is_positive( ) ) ;
631
+ assert ! ( 1f32 . is_positive( ) ) ;
632
+ assert ! ( 0f32 . is_positive( ) ) ;
633
+ assert ! ( !( -0f32 ) . is_positive( ) ) ;
634
+ assert ! ( !( -1f32 ) . is_positive( ) ) ;
635
+ assert ! ( !NEG_INFINITY . is_positive( ) ) ;
636
+ assert ! ( !( 1f32 /NEG_INFINITY ) . is_positive( ) ) ;
637
+ assert ! ( !NAN . is_positive( ) ) ;
638
+ }
639
+
640
+ #[ test]
641
+ fn test_is_negative ( ) {
642
+ assert ! ( !INFINITY . is_negative( ) ) ;
643
+ assert ! ( !1f32 . is_negative( ) ) ;
644
+ assert ! ( !0f32 . is_negative( ) ) ;
645
+ assert ! ( ( -0f32 ) . is_negative( ) ) ;
646
+ assert ! ( ( -1f32 ) . is_negative( ) ) ;
647
+ assert ! ( NEG_INFINITY . is_negative( ) ) ;
648
+ assert ! ( ( 1f32 /NEG_INFINITY ) . is_negative( ) ) ;
649
+ assert ! ( !NAN . is_negative( ) ) ;
650
+ }
651
+
652
+ #[ test]
653
+ fn test_sqrt_domain ( ) {
654
+ assert ! ( NAN . sqrt( ) . is_nan( ) ) ;
655
+ assert ! ( NEG_INFINITY . sqrt( ) . is_nan( ) ) ;
656
+ assert ! ( ( -1.0f32 ) . sqrt( ) . is_nan( ) ) ;
657
+ assert_eq ! ( ( -0.0f32 ) . sqrt( ) , -0.0 ) ;
658
+ assert_eq ! ( 0.0f32 . sqrt( ) , 0.0 ) ;
659
+ assert_eq ! ( 1.0f32 . sqrt( ) , 1.0 ) ;
660
+ assert_eq ! ( INFINITY . sqrt( ) , INFINITY ) ;
661
+ }
662
+
558
663
#[ test]
559
664
fn test_exp ( ) {
560
665
assert_eq ! ( 1.0 , 0.0f32 . exp( ) ) ;
@@ -582,6 +687,71 @@ mod tests {
582
687
assert ! ( nan. exp2( ) . is_nan( ) ) ;
583
688
}
584
689
690
+ #[ test]
691
+ fn test_ldexp ( ) {
692
+ // We have to use from_str until base-2 exponents
693
+ // are supported in floating-point literals
694
+ let f1: f32 = FromStrRadix :: from_str_radix ( "1p-123" , 16 ) . unwrap ( ) ;
695
+ let f2: f32 = FromStrRadix :: from_str_radix ( "1p-111" , 16 ) . unwrap ( ) ;
696
+ assert_eq ! ( Float :: ldexp( 1f32 , -123 ) , f1) ;
697
+ assert_eq ! ( Float :: ldexp( 1f32 , -111 ) , f2) ;
698
+
699
+ assert_eq ! ( Float :: ldexp( 0f32 , -123 ) , 0f32 ) ;
700
+ assert_eq ! ( Float :: ldexp( -0f32 , -123 ) , -0f32 ) ;
701
+
702
+ let inf: f32 = Float :: infinity ( ) ;
703
+ let neg_inf: f32 = Float :: neg_infinity ( ) ;
704
+ let nan: f32 = Float :: nan ( ) ;
705
+ assert_eq ! ( Float :: ldexp( inf, -123 ) , inf) ;
706
+ assert_eq ! ( Float :: ldexp( neg_inf, -123 ) , neg_inf) ;
707
+ assert ! ( Float :: ldexp( nan, -123 ) . is_nan( ) ) ;
708
+ }
709
+
710
+ #[ test]
711
+ fn test_frexp ( ) {
712
+ // We have to use from_str until base-2 exponents
713
+ // are supported in floating-point literals
714
+ let f1: f32 = FromStrRadix :: from_str_radix ( "1p-123" , 16 ) . unwrap ( ) ;
715
+ let f2: f32 = FromStrRadix :: from_str_radix ( "1p-111" , 16 ) . unwrap ( ) ;
716
+ let ( x1, exp1) = f1. frexp ( ) ;
717
+ let ( x2, exp2) = f2. frexp ( ) ;
718
+ assert_eq ! ( ( x1, exp1) , ( 0.5f32 , -122 ) ) ;
719
+ assert_eq ! ( ( x2, exp2) , ( 0.5f32 , -110 ) ) ;
720
+ assert_eq ! ( Float :: ldexp( x1, exp1) , f1) ;
721
+ assert_eq ! ( Float :: ldexp( x2, exp2) , f2) ;
722
+
723
+ assert_eq ! ( 0f32 . frexp( ) , ( 0f32 , 0 ) ) ;
724
+ assert_eq ! ( ( -0f32 ) . frexp( ) , ( -0f32 , 0 ) ) ;
725
+ }
726
+
727
+ #[ test] #[ cfg_attr( windows, ignore) ] // FIXME #8755
728
+ fn test_frexp_nowin ( ) {
729
+ let inf: f32 = Float :: infinity ( ) ;
730
+ let neg_inf: f32 = Float :: neg_infinity ( ) ;
731
+ let nan: f32 = Float :: nan ( ) ;
732
+ assert_eq ! ( match inf. frexp( ) { ( x, _) => x } , inf) ;
733
+ assert_eq ! ( match neg_inf. frexp( ) { ( x, _) => x } , neg_inf) ;
734
+ assert ! ( match nan. frexp( ) { ( x, _) => x. is_nan( ) } )
735
+ }
736
+
737
+ #[ test]
738
+ fn test_abs_sub ( ) {
739
+ assert_eq ! ( ( -1f32 ) . abs_sub( 1f32 ) , 0f32 ) ;
740
+ assert_eq ! ( 1f32 . abs_sub( 1f32 ) , 0f32 ) ;
741
+ assert_eq ! ( 1f32 . abs_sub( 0f32 ) , 1f32 ) ;
742
+ assert_eq ! ( 1f32 . abs_sub( -1f32 ) , 2f32 ) ;
743
+ assert_eq ! ( NEG_INFINITY . abs_sub( 0f32 ) , 0f32 ) ;
744
+ assert_eq ! ( INFINITY . abs_sub( 1f32 ) , INFINITY ) ;
745
+ assert_eq ! ( 0f32 . abs_sub( NEG_INFINITY ) , INFINITY ) ;
746
+ assert_eq ! ( 0f32 . abs_sub( INFINITY ) , 0f32 ) ;
747
+ }
748
+
749
+ #[ test]
750
+ fn test_abs_sub_nowin ( ) {
751
+ assert ! ( NAN . abs_sub( -1f32 ) . is_nan( ) ) ;
752
+ assert ! ( 1f32 . abs_sub( NAN ) . is_nan( ) ) ;
753
+ }
754
+
585
755
#[ test]
586
756
fn test_asinh ( ) {
587
757
assert_eq ! ( 0.0f32 . asinh( ) , 0.0f32 ) ;
@@ -674,174 +844,4 @@ mod tests {
674
844
assert_approx_eq ! ( ln_2, 2f32 . ln( ) ) ;
675
845
assert_approx_eq ! ( ln_10, 10f32 . ln( ) ) ;
676
846
}
677
-
678
- #[ test]
679
- pub fn test_abs ( ) {
680
- assert_eq ! ( INFINITY . abs( ) , INFINITY ) ;
681
- assert_eq ! ( 1f32 . abs( ) , 1f32 ) ;
682
- assert_eq ! ( 0f32 . abs( ) , 0f32 ) ;
683
- assert_eq ! ( ( -0f32 ) . abs( ) , 0f32 ) ;
684
- assert_eq ! ( ( -1f32 ) . abs( ) , 1f32 ) ;
685
- assert_eq ! ( NEG_INFINITY . abs( ) , INFINITY ) ;
686
- assert_eq ! ( ( 1f32 /NEG_INFINITY ) . abs( ) , 0f32 ) ;
687
- assert ! ( NAN . abs( ) . is_nan( ) ) ;
688
- }
689
-
690
- #[ test]
691
- fn test_abs_sub ( ) {
692
- assert_eq ! ( ( -1f32 ) . abs_sub( 1f32 ) , 0f32 ) ;
693
- assert_eq ! ( 1f32 . abs_sub( 1f32 ) , 0f32 ) ;
694
- assert_eq ! ( 1f32 . abs_sub( 0f32 ) , 1f32 ) ;
695
- assert_eq ! ( 1f32 . abs_sub( -1f32 ) , 2f32 ) ;
696
- assert_eq ! ( NEG_INFINITY . abs_sub( 0f32 ) , 0f32 ) ;
697
- assert_eq ! ( INFINITY . abs_sub( 1f32 ) , INFINITY ) ;
698
- assert_eq ! ( 0f32 . abs_sub( NEG_INFINITY ) , INFINITY ) ;
699
- assert_eq ! ( 0f32 . abs_sub( INFINITY ) , 0f32 ) ;
700
- }
701
-
702
- #[ test]
703
- fn test_abs_sub_nowin ( ) {
704
- assert ! ( NAN . abs_sub( -1f32 ) . is_nan( ) ) ;
705
- assert ! ( 1f32 . abs_sub( NAN ) . is_nan( ) ) ;
706
- }
707
-
708
- #[ test]
709
- fn test_signum ( ) {
710
- assert_eq ! ( INFINITY . signum( ) , 1f32 ) ;
711
- assert_eq ! ( 1f32 . signum( ) , 1f32 ) ;
712
- assert_eq ! ( 0f32 . signum( ) , 1f32 ) ;
713
- assert_eq ! ( ( -0f32 ) . signum( ) , -1f32 ) ;
714
- assert_eq ! ( ( -1f32 ) . signum( ) , -1f32 ) ;
715
- assert_eq ! ( NEG_INFINITY . signum( ) , -1f32 ) ;
716
- assert_eq ! ( ( 1f32 /NEG_INFINITY ) . signum( ) , -1f32 ) ;
717
- assert ! ( NAN . signum( ) . is_nan( ) ) ;
718
- }
719
-
720
- #[ test]
721
- fn test_is_positive ( ) {
722
- assert ! ( INFINITY . is_positive( ) ) ;
723
- assert ! ( 1f32 . is_positive( ) ) ;
724
- assert ! ( 0f32 . is_positive( ) ) ;
725
- assert ! ( !( -0f32 ) . is_positive( ) ) ;
726
- assert ! ( !( -1f32 ) . is_positive( ) ) ;
727
- assert ! ( !NEG_INFINITY . is_positive( ) ) ;
728
- assert ! ( !( 1f32 /NEG_INFINITY ) . is_positive( ) ) ;
729
- assert ! ( !NAN . is_positive( ) ) ;
730
- }
731
-
732
- #[ test]
733
- fn test_is_negative ( ) {
734
- assert ! ( !INFINITY . is_negative( ) ) ;
735
- assert ! ( !1f32 . is_negative( ) ) ;
736
- assert ! ( !0f32 . is_negative( ) ) ;
737
- assert ! ( ( -0f32 ) . is_negative( ) ) ;
738
- assert ! ( ( -1f32 ) . is_negative( ) ) ;
739
- assert ! ( NEG_INFINITY . is_negative( ) ) ;
740
- assert ! ( ( 1f32 /NEG_INFINITY ) . is_negative( ) ) ;
741
- assert ! ( !NAN . is_negative( ) ) ;
742
- }
743
-
744
- #[ test]
745
- fn test_is_normal ( ) {
746
- let nan: f32 = Float :: nan ( ) ;
747
- let inf: f32 = Float :: infinity ( ) ;
748
- let neg_inf: f32 = Float :: neg_infinity ( ) ;
749
- let zero: f32 = Float :: zero ( ) ;
750
- let neg_zero: f32 = Float :: neg_zero ( ) ;
751
- assert ! ( !nan. is_normal( ) ) ;
752
- assert ! ( !inf. is_normal( ) ) ;
753
- assert ! ( !neg_inf. is_normal( ) ) ;
754
- assert ! ( !zero. is_normal( ) ) ;
755
- assert ! ( !neg_zero. is_normal( ) ) ;
756
- assert ! ( 1f32 . is_normal( ) ) ;
757
- assert ! ( 1e-37f32 . is_normal( ) ) ;
758
- assert ! ( !1e-38f32 . is_normal( ) ) ;
759
- }
760
-
761
- #[ test]
762
- fn test_classify ( ) {
763
- let nan: f32 = Float :: nan ( ) ;
764
- let inf: f32 = Float :: infinity ( ) ;
765
- let neg_inf: f32 = Float :: neg_infinity ( ) ;
766
- let zero: f32 = Float :: zero ( ) ;
767
- let neg_zero: f32 = Float :: neg_zero ( ) ;
768
- assert_eq ! ( nan. classify( ) , Fp :: Nan ) ;
769
- assert_eq ! ( inf. classify( ) , Fp :: Infinite ) ;
770
- assert_eq ! ( neg_inf. classify( ) , Fp :: Infinite ) ;
771
- assert_eq ! ( zero. classify( ) , Fp :: Zero ) ;
772
- assert_eq ! ( neg_zero. classify( ) , Fp :: Zero ) ;
773
- assert_eq ! ( 1f32 . classify( ) , Fp :: Normal ) ;
774
- assert_eq ! ( 1e-37f32 . classify( ) , Fp :: Normal ) ;
775
- assert_eq ! ( 1e-38f32 . classify( ) , Fp :: Subnormal ) ;
776
- }
777
-
778
- #[ test]
779
- fn test_ldexp ( ) {
780
- // We have to use from_str until base-2 exponents
781
- // are supported in floating-point literals
782
- let f1: f32 = FromStrRadix :: from_str_radix ( "1p-123" , 16 ) . unwrap ( ) ;
783
- let f2: f32 = FromStrRadix :: from_str_radix ( "1p-111" , 16 ) . unwrap ( ) ;
784
- assert_eq ! ( Float :: ldexp( 1f32 , -123 ) , f1) ;
785
- assert_eq ! ( Float :: ldexp( 1f32 , -111 ) , f2) ;
786
-
787
- assert_eq ! ( Float :: ldexp( 0f32 , -123 ) , 0f32 ) ;
788
- assert_eq ! ( Float :: ldexp( -0f32 , -123 ) , -0f32 ) ;
789
-
790
- let inf: f32 = Float :: infinity ( ) ;
791
- let neg_inf: f32 = Float :: neg_infinity ( ) ;
792
- let nan: f32 = Float :: nan ( ) ;
793
- assert_eq ! ( Float :: ldexp( inf, -123 ) , inf) ;
794
- assert_eq ! ( Float :: ldexp( neg_inf, -123 ) , neg_inf) ;
795
- assert ! ( Float :: ldexp( nan, -123 ) . is_nan( ) ) ;
796
- }
797
-
798
- #[ test]
799
- fn test_frexp ( ) {
800
- // We have to use from_str until base-2 exponents
801
- // are supported in floating-point literals
802
- let f1: f32 = FromStrRadix :: from_str_radix ( "1p-123" , 16 ) . unwrap ( ) ;
803
- let f2: f32 = FromStrRadix :: from_str_radix ( "1p-111" , 16 ) . unwrap ( ) ;
804
- let ( x1, exp1) = f1. frexp ( ) ;
805
- let ( x2, exp2) = f2. frexp ( ) ;
806
- assert_eq ! ( ( x1, exp1) , ( 0.5f32 , -122 ) ) ;
807
- assert_eq ! ( ( x2, exp2) , ( 0.5f32 , -110 ) ) ;
808
- assert_eq ! ( Float :: ldexp( x1, exp1) , f1) ;
809
- assert_eq ! ( Float :: ldexp( x2, exp2) , f2) ;
810
-
811
- assert_eq ! ( 0f32 . frexp( ) , ( 0f32 , 0 ) ) ;
812
- assert_eq ! ( ( -0f32 ) . frexp( ) , ( -0f32 , 0 ) ) ;
813
- }
814
-
815
- #[ test] #[ cfg_attr( windows, ignore) ] // FIXME #8755
816
- fn test_frexp_nowin ( ) {
817
- let inf: f32 = Float :: infinity ( ) ;
818
- let neg_inf: f32 = Float :: neg_infinity ( ) ;
819
- let nan: f32 = Float :: nan ( ) ;
820
- assert_eq ! ( match inf. frexp( ) { ( x, _) => x } , inf) ;
821
- assert_eq ! ( match neg_inf. frexp( ) { ( x, _) => x } , neg_inf) ;
822
- assert ! ( match nan. frexp( ) { ( x, _) => x. is_nan( ) } )
823
- }
824
-
825
- #[ test]
826
- fn test_integer_decode ( ) {
827
- assert_eq ! ( 3.14159265359f32 . integer_decode( ) , ( 13176795 , -22 , 1 ) ) ;
828
- assert_eq ! ( ( -8573.5918555f32 ) . integer_decode( ) , ( 8779358 , -10 , -1 ) ) ;
829
- assert_eq ! ( 2f32 . powf( 100.0 ) . integer_decode( ) , ( 8388608 , 77 , 1 ) ) ;
830
- assert_eq ! ( 0f32 . integer_decode( ) , ( 0 , -150 , 1 ) ) ;
831
- assert_eq ! ( ( -0f32 ) . integer_decode( ) , ( 0 , -150 , -1 ) ) ;
832
- assert_eq ! ( INFINITY . integer_decode( ) , ( 8388608 , 105 , 1 ) ) ;
833
- assert_eq ! ( NEG_INFINITY . integer_decode( ) , ( 8388608 , 105 , -1 ) ) ;
834
- assert_eq ! ( NAN . integer_decode( ) , ( 12582912 , 105 , 1 ) ) ;
835
- }
836
-
837
- #[ test]
838
- fn test_sqrt_domain ( ) {
839
- assert ! ( NAN . sqrt( ) . is_nan( ) ) ;
840
- assert ! ( NEG_INFINITY . sqrt( ) . is_nan( ) ) ;
841
- assert ! ( ( -1.0f32 ) . sqrt( ) . is_nan( ) ) ;
842
- assert_eq ! ( ( -0.0f32 ) . sqrt( ) , -0.0 ) ;
843
- assert_eq ! ( 0.0f32 . sqrt( ) , 0.0 ) ;
844
- assert_eq ! ( 1.0f32 . sqrt( ) , 1.0 ) ;
845
- assert_eq ! ( INFINITY . sqrt( ) , INFINITY ) ;
846
- }
847
847
}
0 commit comments