1 #include this file into another for subclass testing
3 # This file is nearly identical to bigintpm.t, except that certain results
4 # are _requird_ to be different due to "upgrading" or "promoting" to BigFloat.
5 # The reverse is not true, any unmarked results can be either BigInt or
6 # BigFloat, depending on how good the internal optimization is.
8 # Plaese note that the testcount goes up by two for each extra result marked
9 # with ^, since then we test whether it has the proper class and that it left
10 # the upgrade variable alone.
12 my $version = ${"$class\::VERSION"};
14 ##############################################################################
15 # for testing inheritance of _swap
19 use Math::BigInt lib => $main::CL;
21 @ISA = (qw/Math::BigInt/);
24 # customized overload for sub, since original does not use swap there
25 '-' => sub { my @a = ref($_[0])->_swap(@_);
30 # a fake _swap, which reverses the params
31 my $self = shift; # for override in subclass
34 my $c = ref ($_[0] ) || 'Math::Foo';
35 return ( $_[0]->copy(), $_[1] );
39 return ( Math::Foo->new($_[1]), $_[0] );
43 ##############################################################################
46 my $CALC = $class->config()->{lib}; ok ($CALC,$CL);
48 my ($f,$z,$a,$exp,@a,$m,$e,$round_mode,$expected_class);
53 next if /^#/; # skip comments
60 $round_mode = $_; $round_mode =~ s/^\$/$class\->/; next;
63 @args = split(/:/,$_,99); $ans = pop(@args);
64 $expected_class = $class;
67 $expected_class = $ECL; $ans =~ s/\^$//;
69 $try = "\$x = $class->new(\"$args[0]\");";
72 $try = "\$x = $class->bnorm(\"$args[0]\");";
74 } elsif ($f =~ /^is_(zero|one|odd|even|negative|positive|nan|int)$/) {
76 } elsif ($f eq "as_hex") {
77 $try .= '$x->as_hex();';
78 } elsif ($f eq "as_bin") {
79 $try .= '$x->as_bin();';
80 } elsif ($f eq "is_inf") {
81 $try .= "\$x->is_inf('$args[1]');";
82 } elsif ($f eq "binf") {
83 $try .= "\$x->binf('$args[1]');";
84 } elsif ($f eq "bone") {
85 $try .= "\$x->bone('$args[1]');";
87 } elsif ($f =~ /^b(nan|floor|ceil|sstr|neg|abs|inc|dec|not|sqrt|fac)$/) {
89 } elsif ($f eq "length") {
90 $try .= '$x->length();';
91 } elsif ($f eq "exponent"){
92 # ->bstr() to see if an object is returned
93 $try .= '$x = $x->exponent()->bstr();';
94 } elsif ($f eq "mantissa"){
95 # ->bstr() to see if an object is returned
96 $try .= '$x = $x->mantissa()->bstr();';
97 } elsif ($f eq "parts"){
98 $try .= '($m,$e) = $x->parts();';
99 # ->bstr() to see if an object is returned
100 $try .= '$m = $m->bstr(); $m = "NaN" if !defined $m;';
101 $try .= '$e = $e->bstr(); $e = "NaN" if !defined $e;';
104 $try .= "\$y = $class->new('$args[1]');";
107 $try .= '$x <=> $y;';
108 } elsif ($f eq "bround") {
109 $try .= "$round_mode; \$x->bround(\$y);";
110 } elsif ($f eq "bacmp"){
111 $try .= '$x->bacmp($y);';
112 } elsif ($f eq "badd"){
114 } elsif ($f eq "bsub"){
116 } elsif ($f eq "bmul"){
118 } elsif ($f eq "bdiv"){
120 } elsif ($f eq "bdiv-list"){
121 $try .= 'join (",",$x->bdiv($y));';
123 } elsif ($f =~ /^.=$/){
124 $try .= "\$x $f \$y;";
126 } elsif ($f =~ /^.$/){
127 $try .= "\$x $f \$y;";
128 } elsif ($f eq "bmod"){
130 } elsif ($f eq "bgcd")
132 if (defined $args[2])
134 $try .= " \$z = $class->new('$args[2]'); ";
136 $try .= "$class\::bgcd(\$x, \$y";
137 $try .= ", \$z" if (defined $args[2]);
142 if (defined $args[2])
144 $try .= " \$z = $class->new('$args[2]'); ";
146 $try .= "$class\::blcm(\$x, \$y";
147 $try .= ", \$z" if (defined $args[2]);
149 }elsif ($f eq "blsft"){
150 if (defined $args[2])
152 $try .= "\$x->blsft(\$y,$args[2]);";
156 $try .= "\$x << \$y;";
158 }elsif ($f eq "brsft"){
159 if (defined $args[2])
161 $try .= "\$x->brsft(\$y,$args[2]);";
165 $try .= "\$x >> \$y;";
167 }elsif ($f eq "band"){
168 $try .= "\$x & \$y;";
169 }elsif ($f eq "bior"){
170 $try .= "\$x | \$y;";
171 }elsif ($f eq "bxor"){
172 $try .= "\$x ^ \$y;";
173 }elsif ($f eq "bpow"){
174 $try .= "\$x ** \$y;";
175 }elsif ($f eq "digit"){
176 $try = "\$x = $class->new('$args[0]'); \$x->digit($args[1]);";
177 } else { warn "Unknown op '$f'"; }
178 } # end else all other ops
181 # convert hex/binary targets to decimal
182 if ($ans =~ /^(0x0x|0b0b)/)
184 $ans =~ s/^0[xb]//; $ans = Math::BigInt->new($ans)->bstr();
192 # print "try: $try ans: $ans1 $ans\n";
193 print "# Tried: '$try'\n" if !ok ($ans1, $ans);
194 if ($expected_class ne $class)
196 ok (ref($ans1),$expected_class); # also checks that it really is ref!
197 ok ($Math::BigInt::upgrade,'Math::BigFloat'); # still okay?
200 # check internal state of number objects
201 is_valid($ans1,$f) if ref $ans1;
202 } # endwhile data tests
209 ###############################################################################
210 ###############################################################################
211 # Perl 5.005 does not like ok ($x,undef)
217 ok (1,1) and return if !defined $x;
221 ###############################################################################
222 # sub to check validity of a BigInt internally, to ensure that no op leaves a
223 # number object in an invalid state (f.i. "-0")
229 # The checks here are loosened a bit to allow BigInt or BigFloats to pass
233 # $e = "Not a reference to $c" if (ref($x) || '') ne $c;
236 $e = "Illegal sign $x->{sign} (expected: '+', '-', '-inf', '+inf' or 'NaN'"
237 if $e eq '0' && $x->{sign} !~ /^(\+|-|\+inf|-inf|NaN)$/;
239 $e = "-0 is invalid!" if $e ne '0' && $x->{sign} eq '-' && $x == 0;
240 #$e = $CALC->_check($x->{value}) if $e eq '0';
242 # test done, see if error did crop up
243 ok (1,1), return if ($e eq '0');
245 ok (1,$e." after op '$f'");
324 -123456789:+987654321:-1
325 +123456789:-987654321:-1
326 +987654321:+123456789:1
327 -987654321:+123456789:1
370 0b10000000000001:8193
371 0b100000000000001:16385
372 0b1000000000000001:32769
373 0b10000000000000001:65537
374 0b100000000000000001:131073
375 0b1000000000000000001:262145
376 0b10000000000000000001:524289
377 0b100000000000000000001:1048577
378 0b1000000000000000000001:2097153
379 0b10000000000000000000001:4194305
380 0b100000000000000000000001:8388609
381 0b1000000000000000000000001:16777217
382 0b10000000000000000000000001:33554433
383 0b100000000000000000000000001:67108865
384 0b1000000000000000000000000001:134217729
385 0b10000000000000000000000000001:268435457
386 0b100000000000000000000000000001:536870913
387 0b1000000000000000000000000000001:1073741825
388 0b10000000000000000000000000000001:2147483649
389 0b100000000000000000000000000000001:4294967297
390 0b1000000000000000000000000000000001:8589934593
391 0b10000000000000000000000000000000001:17179869185
403 0x1_2_3_4_56_78:305419896
404 0xa_b_c_d_e_f:11259375
433 0x40000001:1073741825
434 0x80000001:2147483649
435 0x100000001:4294967297
436 0x200000001:8589934593
437 0x400000001:17179869185
438 0x800000001:34359738369
452 # only one underscore between two digits
470 # bug with two E's in number beeing valid
483 01234567891:1234567891
484 012345678912:12345678912
485 0123456789123:123456789123
486 01234567891234:1234567891234
503 -123456789:-123456789
512 # floating point input
520 # non-integer numbers
555 # it must be exactly /^[+-]inf$/
562 +1:+48:281474976710656
565 +12345:4:10:123450000
571 1234567890123:12:10:1234567890123000000000000
576 +281474976710656:+48:1
587 1230000000000:10:10:123
588 09876123456789067890:12:10:9876123
589 1234561234567890123:13:10:123456
603 +123456789:-123456789
638 -123456789:987654321:-1
639 +123456789:-987654321:1
640 -987654321:123456789:-1
700 +99999999:+1:100000000
701 +999999999:+1:1000000000
702 +9999999999:+1:10000000000
703 +99999999999:+1:100000000000
711 +100000000:-1:99999999
712 +1000000000:-1:999999999
713 +10000000000:-1:9999999999
714 +123456789:987654321:1111111110
715 -123456789:987654321:864197532
716 -123456789:-987654321:-1111111110
717 +123456789:-987654321:-864197532
745 +99999999:+1:99999998
746 +999999999:+1:999999998
747 +9999999999:+1:9999999998
748 +99999999999:+1:99999999998
755 +10000000:-1:10000001
756 +100000000:-1:100000001
757 +1000000000:-1:1000000001
758 +10000000000:-1:10000000001
759 +123456789:+987654321:-864197532
760 -123456789:+987654321:-1111111110
761 -123456789:-987654321:864197532
762 +123456789:-987654321:1111111110
780 123456789123456789:0:0
781 0:123456789123456789:0
791 10101:10101:102030201
792 1001001:1001001:1002003002001
793 100010001:100010001:10002000300020001
794 10000100001:10000100001:100002000030000200001
795 11111111111:9:99999999999
796 22222222222:9:199999999998
797 33333333333:9:299999999997
798 44444444444:9:399999999996
799 55555555555:9:499999999995
800 66666666666:9:599999999994
801 77777777777:9:699999999993
802 88888888888:9:799999999992
803 99999999999:9:899999999991
805 +12345:+12345:152399025
806 +99999:+11111:1111088889
808 99999:100000:9999900000
809 999999:1000000:999999000000
810 9999999:10000000:99999990000000
811 99999999:100000000:9999999900000000
812 999999999:1000000000:999999999000000000
813 9999999999:10000000000:99999999990000000000
814 99999999999:100000000000:9999999999900000000000
815 999999999999:1000000000000:999999999999000000000000
816 9999999999999:10000000000000:99999999999990000000000000
817 99999999999999:100000000000000:9999999999999900000000000000
818 999999999999999:1000000000000000:999999999999999000000000000000
819 9999999999999999:10000000000000000:99999999999999990000000000000000
820 99999999999999999:100000000000000000:9999999999999999900000000000000000
821 999999999999999999:1000000000000000000:999999999999999999000000000000000000
822 9999999999999999999:10000000000000000000:99999999999999999990000000000000000000
832 # inf handling and general remainder
838 # see table in documentation in MBI
857 # exceptions to reminder rule
866 # inf handling (see table in doc)
900 1000000000:9:111111111
901 2000000000:9:222222222
902 3000000000:9:333333333
903 4000000000:9:444444444
904 5000000000:9:555555555
905 6000000000:9:666666666
906 7000000000:9:777777777
907 8000000000:9:888888888
908 9000000000:9:1000000000
912 1000000000:3:333333333
917 999999999999:9:111111111111
918 999999999999:99:10101010101
919 999999999999:999:1001001001
920 999999999999:9999:100010001
921 999999999999999:99999:10000100001
922 +1111088889:99999:11111
927 1:3:0.3333333333333333333333333333333333333333
928 1:-3:-0.3333333333333333333333333333333333333333
929 -2:-3:0.6666666666666666666666666666666666666667
930 -2:3:-0.6666666666666666666666666666666666666667
939 # bug in Calc with '99999' vs $BASE-1
940 10000000000000000000000000000000000000000000000000000000000000000000000000000000000:10000000375084540248994272022843165711074:999999962491547381984643365663244474111576
943 # inf handling, see table in doc
962 # exceptions to reminder rule
1001 999999999999999:99999:0
1015 152403346:12345:4321
1049 +281474976710656:0:0
1050 +281474976710656:1:0
1051 +281474976710656:+281474976710656:281474976710656
1058 # equal arguments are treated special, so also do some test with unequal ones
1059 0xFFFF:0xFFFF:0x0xFFFF
1060 0xFFFFFF:0xFFFFFF:0x0xFFFFFF
1061 0xFFFFFFFF:0xFFFFFFFF:0x0xFFFFFFFF
1062 0xFFFFFFFFFF:0xFFFFFFFFFF:0x0xFFFFFFFFFF
1063 0xFFFFFFFFFFFF:0xFFFFFFFFFFFF:0x0xFFFFFFFFFFFF
1064 0xF0F0:0xF0F0:0x0xF0F0
1065 0x0F0F:0x0F0F:0x0x0F0F
1066 0xF0F0F0:0xF0F0F0:0x0xF0F0F0
1067 0x0F0F0F:0x0F0F0F:0x0x0F0F0F
1068 0xF0F0F0F0:0xF0F0F0F0:0x0xF0F0F0F0
1069 0x0F0F0F0F:0x0F0F0F0F:0x0x0F0F0F0F
1070 0xF0F0F0F0F0:0xF0F0F0F0F0:0x0xF0F0F0F0F0
1071 0x0F0F0F0F0F:0x0F0F0F0F0F:0x0x0F0F0F0F0F
1072 0xF0F0F0F0F0F0:0xF0F0F0F0F0F0:0x0xF0F0F0F0F0F0
1073 0x0F0F0F0F0F0F:0x0F0F0F0F0F0F:0x0x0F0F0F0F0F0F
1074 0x1F0F0F0F0F0F:0x3F0F0F0F0F0F:0x0x1F0F0F0F0F0F
1081 +281474976710656:0:281474976710656
1082 +281474976710656:1:281474976710657
1083 +281474976710656:281474976710656:281474976710656
1089 # equal arguments are treated special, so also do some test with unequal ones
1090 0xFFFF:0xFFFF:0x0xFFFF
1091 0xFFFFFF:0xFFFFFF:0x0xFFFFFF
1092 0xFFFFFFFF:0xFFFFFFFF:0x0xFFFFFFFF
1093 0xFFFFFFFFFF:0xFFFFFFFFFF:0x0xFFFFFFFFFF
1094 0xFFFFFFFFFFFF:0xFFFFFFFFFFFF:0x0xFFFFFFFFFFFF
1096 0:0xFFFFFF:0x0xFFFFFF
1097 0:0xFFFFFFFF:0x0xFFFFFFFF
1098 0:0xFFFFFFFFFF:0x0xFFFFFFFFFF
1099 0:0xFFFFFFFFFFFF:0x0xFFFFFFFFFFFF
1101 0xFFFFFF:0:0x0xFFFFFF
1102 0xFFFFFFFF:0:0x0xFFFFFFFF
1103 0xFFFFFFFFFF:0:0x0xFFFFFFFFFF
1104 0xFFFFFFFFFFFF:0:0x0xFFFFFFFFFFFF
1105 0xF0F0:0xF0F0:0x0xF0F0
1106 0x0F0F:0x0F0F:0x0x0F0F
1107 0xF0F0:0x0F0F:0x0xFFFF
1108 0xF0F0F0:0xF0F0F0:0x0xF0F0F0
1109 0x0F0F0F:0x0F0F0F:0x0x0F0F0F
1110 0x0F0F0F:0xF0F0F0:0x0xFFFFFF
1111 0xF0F0F0F0:0xF0F0F0F0:0x0xF0F0F0F0
1112 0x0F0F0F0F:0x0F0F0F0F:0x0x0F0F0F0F
1113 0x0F0F0F0F:0xF0F0F0F0:0x0xFFFFFFFF
1114 0xF0F0F0F0F0:0xF0F0F0F0F0:0x0xF0F0F0F0F0
1115 0x0F0F0F0F0F:0x0F0F0F0F0F:0x0x0F0F0F0F0F
1116 0x0F0F0F0F0F:0xF0F0F0F0F0:0x0xFFFFFFFFFF
1117 0xF0F0F0F0F0F0:0xF0F0F0F0F0F0:0x0xF0F0F0F0F0F0
1118 0x0F0F0F0F0F0F:0x0F0F0F0F0F0F:0x0x0F0F0F0F0F0F
1119 0x0F0F0F0F0F0F:0xF0F0F0F0F0F0:0x0xFFFFFFFFFFFF
1120 0x1F0F0F0F0F0F:0xF0F0F0F0F0F0:0x0xFFFFFFFFFFFF
1127 +281474976710656:0:281474976710656
1128 +281474976710656:1:281474976710657
1129 +281474976710656:281474976710656:0
1137 # equal arguments are treated special, so also do some test with unequal ones
1140 0xFFFFFFFF:0xFFFFFFFF:0
1141 0xFFFFFFFFFF:0xFFFFFFFFFF:0
1142 0xFFFFFFFFFFFF:0xFFFFFFFFFFFF:0
1144 0:0xFFFFFF:0x0xFFFFFF
1145 0:0xFFFFFFFF:0x0xFFFFFFFF
1146 0:0xFFFFFFFFFF:0x0xFFFFFFFFFF
1147 0:0xFFFFFFFFFFFF:0x0xFFFFFFFFFFFF
1149 0xFFFFFF:0:0x0xFFFFFF
1150 0xFFFFFFFF:0:0x0xFFFFFFFF
1151 0xFFFFFFFFFF:0:0x0xFFFFFFFFFF
1152 0xFFFFFFFFFFFF:0:0x0xFFFFFFFFFFFF
1155 0xF0F0:0x0F0F:0x0xFFFF
1158 0x0F0F0F:0xF0F0F0:0x0xFFFFFF
1159 0xF0F0F0F0:0xF0F0F0F0:0
1160 0x0F0F0F0F:0x0F0F0F0F:0
1161 0x0F0F0F0F:0xF0F0F0F0:0x0xFFFFFFFF
1162 0xF0F0F0F0F0:0xF0F0F0F0F0:0
1163 0x0F0F0F0F0F:0x0F0F0F0F0F:0
1164 0x0F0F0F0F0F:0xF0F0F0F0F0:0x0xFFFFFFFFFF
1165 0xF0F0F0F0F0F0:0xF0F0F0F0F0F0:0
1166 0x0F0F0F0F0F0F:0x0F0F0F0F0F0F:0
1167 0x0F0F0F0F0F0F:0xF0F0F0F0F0F0:0x0xFFFFFFFFFFFF
1172 +281474976710656:-281474976710657
1267 -inf:1234500012:-inf
1268 +inf:-12345000123:inf
1269 -inf:-12345000123:-inf
1270 # 1 ** -x => 1 / (1 ** x)
1290 10:20:100000000000000000000
1291 123456:2:15241383936
1298 10000000000000000:17
1300 215960156869840440586892398248:30
1302 145:12.04159457879229548012824103037860805243^
1304 143:11.95826074310139802112984075619561661399^
1306 170:13.03840481040529742916594311485836883306^
1308 168:12.96148139681572046193193487217599331541^
1310 3:1.732050807568877293527446341505872366943^
1311 2:1.41421356237309504880168872420969807857^
1313 12:3.464101615137754587054892683011744733886^
1316 4000000000000:2000000
1317 152399026:12345.00004050222755607815159966235881398^
1319 152399024:12344.99995949777231103967404745303741942^
1327 $round_mode('trunc')
1337 +10123456789:5:10123000000
1338 -10123456789:5:-10123000000
1339 +10123456789:9:10123456700
1340 -10123456789:9:-10123456700
1341 +101234500:6:101234000
1342 -101234500:6:-101234000
1343 #+101234500:-4:101234000
1344 #-101234500:-4:-101234000
1346 +20123456789:5:20123000000
1347 -20123456789:5:-20123000000
1348 +20123456789:9:20123456800
1349 -20123456789:9:-20123456800
1350 +201234500:6:201234000
1351 -201234500:6:-201234000
1352 #+201234500:-4:201234000
1353 #-201234500:-4:-201234000
1354 +12345000:4:12340000
1355 -12345000:4:-12340000
1357 +30123456789:5:30123000000
1358 -30123456789:5:-30123000000
1359 +30123456789:9:30123456800
1360 -30123456789:9:-30123456800
1361 +301234500:6:301235000
1362 -301234500:6:-301234000
1363 #+301234500:-4:301235000
1364 #-301234500:-4:-301234000
1365 +12345000:4:12350000
1366 -12345000:4:-12340000
1368 +40123456789:5:40123000000
1369 -40123456789:5:-40123000000
1370 +40123456789:9:40123456800
1371 -40123456789:9:-40123456800
1372 +401234500:6:401234000
1373 +401234500:6:401234000
1374 #-401234500:-4:-401235000
1375 #-401234500:-4:-401235000
1376 +12345000:4:12340000
1377 -12345000:4:-12350000
1379 +50123456789:5:50123000000
1380 -50123456789:5:-50123000000
1381 +50123456789:9:50123456800
1382 -50123456789:9:-50123456800
1383 +501234500:6:501235000
1384 -501234500:6:-501235000
1385 #+501234500:-4:501235000
1386 #-501234500:-4:-501235000
1387 +12345000:4:12350000
1388 -12345000:4:-12350000
1390 +60123456789:5:60123000000
1391 -60123456789:5:-60123000000
1392 +60123456789:9:60123456800
1393 -60123456789:9:-60123456800
1394 +601234500:6:601234000
1395 -601234500:6:-601234000
1396 #+601234500:-4:601234000
1397 #-601234500:-4:-601234000
1404 +12345000:4:12340000
1405 -12345000:4:-12340000
1423 # floor and ceil tests are pretty pointless in integer space...but play safe
1450 0x123456789123456789:0x123456789123456789
1460 0b1010111101010101010110110110110110101:0b1010111101010101010110110110110110101