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 (e.g. it
7 # is usually desirable to have 2 ** 2 return a BigInt, not a BigFloat).
9 # Results that are required to be BigFloat are marked with C<^> at the end.
11 # Please note that the testcount goes up by two for each extra result marked
12 # with ^, since then we test whether it has the proper class and that it left
13 # the upgrade variable alone.
15 my $version = ${"$class\::VERSION"};
17 ##############################################################################
18 # for testing inheritance of _swap
22 use Math::BigInt lib => $main::CL;
24 @ISA = (qw/Math::BigInt/);
27 # customized overload for sub, since original does not use swap there
28 '-' => sub { my @a = ref($_[0])->_swap(@_);
33 # a fake _swap, which reverses the params
34 my $self = shift; # for override in subclass
37 my $c = ref ($_[0] ) || 'Math::Foo';
38 return ( $_[0]->copy(), $_[1] );
42 return ( Math::Foo->new($_[1]), $_[0] );
46 ##############################################################################
49 my $CALC = $class->config()->{lib}; ok ($CALC,$CL);
51 my ($f,$z,$a,$exp,@a,$m,$e,$round_mode,$expected_class);
56 next if /^#/; # skip comments
63 $round_mode = $_; $round_mode =~ s/^\$/$class\->/; next;
66 @args = split(/:/,$_,99); $ans = pop(@args);
67 $expected_class = $class;
70 $expected_class = $ECL; $ans =~ s/\^$//;
72 $try = "\$x = $class->new(\"$args[0]\");";
75 $try = "\$x = $class->bnorm(\"$args[0]\");";
77 } elsif ($f =~ /^is_(zero|one|odd|even|negative|positive|nan|int)$/) {
79 } elsif ($f eq "as_hex") {
80 $try .= '$x->as_hex();';
81 } elsif ($f eq "as_bin") {
82 $try .= '$x->as_bin();';
83 } elsif ($f eq "is_inf") {
84 $try .= "\$x->is_inf('$args[1]');";
85 } elsif ($f eq "binf") {
86 $try .= "\$x->binf('$args[1]');";
87 } elsif ($f eq "bone") {
88 $try .= "\$x->bone('$args[1]');";
90 } elsif ($f =~ /^b(nan|floor|ceil|sstr|neg|abs|inc|dec|not|sqrt|fac)$/) {
92 } elsif ($f eq "length") {
93 $try .= '$x->length();';
94 } elsif ($f eq "exponent"){
95 # ->bstr() to see if an object is returned
96 $try .= '$x = $x->exponent()->bstr();';
97 } elsif ($f eq "mantissa"){
98 # ->bstr() to see if an object is returned
99 $try .= '$x = $x->mantissa()->bstr();';
100 } elsif ($f eq "parts"){
101 $try .= '($m,$e) = $x->parts();';
102 # ->bstr() to see if an object is returned
103 $try .= '$m = $m->bstr(); $m = "NaN" if !defined $m;';
104 $try .= '$e = $e->bstr(); $e = "NaN" if !defined $e;';
107 if ($args[1] !~ /\./)
109 $try .= "\$y = $class->new(\"$args[1]\");"; # BigInt
113 $try .= "\$y = $ECL->new(\"$args[1]\");"; # BigFloat
117 $try .= '$x <=> $y;';
118 } elsif ($f eq "bround") {
119 $try .= "$round_mode; \$x->bround(\$y);";
120 } elsif ($f eq "broot") {
121 $try .= "\$x->broot(\$y);";
122 } elsif ($f eq "bacmp"){
123 $try .= '$x->bacmp($y);';
124 } elsif ($f eq "badd"){
126 } elsif ($f eq "bsub"){
128 } elsif ($f eq "bmul"){
130 } elsif ($f eq "bdiv"){
132 } elsif ($f eq "bdiv-list"){
133 $try .= 'join (",",$x->bdiv($y));';
135 } elsif ($f =~ /^.=$/){
136 $try .= "\$x $f \$y;";
138 } elsif ($f =~ /^.$/){
139 $try .= "\$x $f \$y;";
140 } elsif ($f eq "bmod"){
142 } elsif ($f eq "bgcd")
144 if (defined $args[2])
146 $try .= " \$z = $class->new('$args[2]'); ";
148 $try .= "$class\::bgcd(\$x, \$y";
149 $try .= ", \$z" if (defined $args[2]);
154 if (defined $args[2])
156 $try .= " \$z = $class->new('$args[2]'); ";
158 $try .= "$class\::blcm(\$x, \$y";
159 $try .= ", \$z" if (defined $args[2]);
161 }elsif ($f eq "blsft"){
162 if (defined $args[2])
164 $try .= "\$x->blsft(\$y,$args[2]);";
168 $try .= "\$x << \$y;";
170 }elsif ($f eq "brsft"){
171 if (defined $args[2])
173 $try .= "\$x->brsft(\$y,$args[2]);";
177 $try .= "\$x >> \$y;";
179 }elsif ($f eq "band"){
180 $try .= "\$x & \$y;";
181 }elsif ($f eq "bior"){
182 $try .= "\$x | \$y;";
183 }elsif ($f eq "bxor"){
184 $try .= "\$x ^ \$y;";
185 }elsif ($f eq "bpow"){
186 $try .= "\$x ** \$y;";
187 }elsif ($f eq "digit"){
188 $try = "\$x = $class->new('$args[0]'); \$x->digit($args[1]);";
189 } else { warn "Unknown op '$f'"; }
190 } # end else all other ops
193 # convert hex/binary targets to decimal
194 if ($ans =~ /^(0x0x|0b0b)/)
196 $ans =~ s/^0[xb]//; $ans = Math::BigInt->new($ans)->bstr();
204 # print "try: $try ans: $ans1 $ans\n";
205 print "# Tried: '$try'\n" if !ok ($ans1, $ans);
206 if ($expected_class ne $class)
208 ok (ref($ans1),$expected_class); # also checks that it really is ref!
209 ok ($Math::BigInt::upgrade,'Math::BigFloat'); # still okay?
212 # check internal state of number objects
213 is_valid($ans1,$f) if ref $ans1;
214 } # endwhile data tests
217 my $warn = ''; $SIG{__WARN__} = sub { $warn = shift; };
219 # these should not warn
220 $warn = ''; eval "\$z = 3.17 <= \$y"; ok ($z, 1); ok ($warn, '');
221 $warn = ''; eval "\$z = \$y >= 3.17"; ok ($z, 1); ok ($warn, '');
227 ###############################################################################
228 ###############################################################################
229 # Perl 5.005 does not like ok ($x,undef)
235 ok (1,1) and return if !defined $x;
239 ###############################################################################
240 # sub to check validity of a BigInt internally, to ensure that no op leaves a
241 # number object in an invalid state (f.i. "-0")
247 # The checks here are loosened a bit to allow BigInt or BigFloats to pass
251 # $e = "Not a reference to $c" if (ref($x) || '') ne $c;
254 $e = "Illegal sign $x->{sign} (expected: '+', '-', '-inf', '+inf' or 'NaN'"
255 if $e eq '0' && $x->{sign} !~ /^(\+|-|\+inf|-inf|NaN)$/;
257 $e = "-0 is invalid!" if $e ne '0' && $x->{sign} eq '-' && $x == 0;
258 #$e = $CALC->_check($x->{value}) if $e eq '0';
260 # test done, see if error did crop up
261 ok (1,1), return if ($e eq '0');
263 ok (1,$e." after op '$f'");
282 100:3:33.33333333333333333333333333333333333333
342 -123456789:+987654321:-1
343 +123456789:-987654321:-1
344 +987654321:+123456789:1
345 -987654321:+123456789:1
388 0b10000000000001:8193
389 0b100000000000001:16385
390 0b1000000000000001:32769
391 0b10000000000000001:65537
392 0b100000000000000001:131073
393 0b1000000000000000001:262145
394 0b10000000000000000001:524289
395 0b100000000000000000001:1048577
396 0b1000000000000000000001:2097153
397 0b10000000000000000000001:4194305
398 0b100000000000000000000001:8388609
399 0b1000000000000000000000001:16777217
400 0b10000000000000000000000001:33554433
401 0b100000000000000000000000001:67108865
402 0b1000000000000000000000000001:134217729
403 0b10000000000000000000000000001:268435457
404 0b100000000000000000000000000001:536870913
405 0b1000000000000000000000000000001:1073741825
406 0b10000000000000000000000000000001:2147483649
407 0b100000000000000000000000000000001:4294967297
408 0b1000000000000000000000000000000001:8589934593
409 0b10000000000000000000000000000000001:17179869185
421 0x1_2_3_4_56_78:305419896
422 0xa_b_c_d_e_f:11259375
451 0x40000001:1073741825
452 0x80000001:2147483649
453 0x100000001:4294967297
454 0x200000001:8589934593
455 0x400000001:17179869185
456 0x800000001:34359738369
470 # only one underscore between two digits
488 # bug with two E's in number beeing valid
501 01234567891:1234567891
502 012345678912:12345678912
503 0123456789123:123456789123
504 01234567891234:1234567891234
521 -123456789:-123456789
530 # floating point input
538 # non-integer numbers
573 # it must be exactly /^[+-]inf$/
580 +1:+48:281474976710656
583 +12345:4:10:123450000
589 1234567890123:12:10:1234567890123000000000000
594 +281474976710656:+48:1
605 1230000000000:10:10:123
606 09876123456789067890:12:10:9876123
607 1234561234567890123:13:10:123456
621 +123456789:-123456789
656 -123456789:987654321:-1
657 +123456789:-987654321:1
658 -987654321:123456789:-1
718 +99999999:+1:100000000
719 +999999999:+1:1000000000
720 +9999999999:+1:10000000000
721 +99999999999:+1:100000000000
729 +100000000:-1:99999999
730 +1000000000:-1:999999999
731 +10000000000:-1:9999999999
732 +123456789:987654321:1111111110
733 -123456789:987654321:864197532
734 -123456789:-987654321:-1111111110
735 +123456789:-987654321:-864197532
763 +99999999:+1:99999998
764 +999999999:+1:999999998
765 +9999999999:+1:9999999998
766 +99999999999:+1:99999999998
773 +10000000:-1:10000001
774 +100000000:-1:100000001
775 +1000000000:-1:1000000001
776 +10000000000:-1:10000000001
777 +123456789:+987654321:-864197532
778 -123456789:+987654321:-1111111110
779 -123456789:-987654321:864197532
780 +123456789:-987654321:1111111110
798 123456789123456789:0:0
799 0:123456789123456789:0
809 10101:10101:102030201
810 1001001:1001001:1002003002001
811 100010001:100010001:10002000300020001
812 10000100001:10000100001:100002000030000200001
813 11111111111:9:99999999999
814 22222222222:9:199999999998
815 33333333333:9:299999999997
816 44444444444:9:399999999996
817 55555555555:9:499999999995
818 66666666666:9:599999999994
819 77777777777:9:699999999993
820 88888888888:9:799999999992
821 99999999999:9:899999999991
823 +12345:+12345:152399025
824 +99999:+11111:1111088889
826 99999:100000:9999900000
827 999999:1000000:999999000000
828 9999999:10000000:99999990000000
829 99999999:100000000:9999999900000000
830 999999999:1000000000:999999999000000000
831 9999999999:10000000000:99999999990000000000
832 99999999999:100000000000:9999999999900000000000
833 999999999999:1000000000000:999999999999000000000000
834 9999999999999:10000000000000:99999999999990000000000000
835 99999999999999:100000000000000:9999999999999900000000000000
836 999999999999999:1000000000000000:999999999999999000000000000000
837 9999999999999999:10000000000000000:99999999999999990000000000000000
838 99999999999999999:100000000000000000:9999999999999999900000000000000000
839 999999999999999999:1000000000000000000:999999999999999999000000000000000000
840 9999999999999999999:10000000000000000000:99999999999999999990000000000000000000
852 # inf handling and general remainder
858 # see table in documentation in MBI
877 # exceptions to reminder rule
886 # inf handling (see table in doc)
920 1000000000:9:111111111.1111111111111111111111111111111^
921 2000000000:9:222222222.2222222222222222222222222222222^
922 3000000000:9:333333333.3333333333333333333333333333333^
923 4000000000:9:444444444.4444444444444444444444444444444^
924 5000000000:9:555555555.5555555555555555555555555555556^
925 6000000000:9:666666666.6666666666666666666666666666667^
926 7000000000:9:777777777.7777777777777777777777777777778^
927 8000000000:9:888888888.8888888888888888888888888888889^
928 9000000000:9:1000000000
929 35500000:113:314159.2920353982300884955752212389380531^
930 71000000:226:314159.2920353982300884955752212389380531^
931 106500000:339:314159.2920353982300884955752212389380531^
932 1000000000:3:333333333.3333333333333333333333333333333^
937 999999999999:9:111111111111
938 999999999999:99:10101010101
939 999999999999:999:1001001001
940 999999999999:9999:100010001
941 999999999999999:99999:10000100001
942 +1111088889:99999:11111
943 -5:-3:1.666666666666666666666666666666666666667^
944 -5:3:-1.666666666666666666666666666666666666667^
945 4:3:1.333333333333333333333333333333333333333^
946 4:-3:-1.333333333333333333333333333333333333333^
947 1:3:0.3333333333333333333333333333333333333333^
948 1:-3:-0.3333333333333333333333333333333333333333^
949 -2:-3:0.6666666666666666666666666666666666666667^
950 -2:3:-0.6666666666666666666666666666666666666667^
953 14:-3:-4.666666666666666666666666666666666666667^
954 -14:3:-4.666666666666666666666666666666666666667^
955 -14:-3:4.666666666666666666666666666666666666667^
956 14:3:4.666666666666666666666666666666666666667^
957 # bug in Calc with '99999' vs $BASE-1
958 #10000000000000000000000000000000000000000000000000000000000000000000000000000000000:10000000375084540248994272022843165711074:999999962491547381984643365663244474111576
961 # inf handling, see table in doc
980 # exceptions to reminder rule
1019 999999999999999:99999:0
1033 152403346:12345:4321
1067 +281474976710656:0:0
1068 +281474976710656:1:0
1069 +281474976710656:+281474976710656:281474976710656
1076 # equal arguments are treated special, so also do some test with unequal ones
1077 0xFFFF:0xFFFF:0x0xFFFF
1078 0xFFFFFF:0xFFFFFF:0x0xFFFFFF
1079 0xFFFFFFFF:0xFFFFFFFF:0x0xFFFFFFFF
1080 0xFFFFFFFFFF:0xFFFFFFFFFF:0x0xFFFFFFFFFF
1081 0xFFFFFFFFFFFF:0xFFFFFFFFFFFF:0x0xFFFFFFFFFFFF
1082 0xF0F0:0xF0F0:0x0xF0F0
1083 0x0F0F:0x0F0F:0x0x0F0F
1084 0xF0F0F0:0xF0F0F0:0x0xF0F0F0
1085 0x0F0F0F:0x0F0F0F:0x0x0F0F0F
1086 0xF0F0F0F0:0xF0F0F0F0:0x0xF0F0F0F0
1087 0x0F0F0F0F:0x0F0F0F0F:0x0x0F0F0F0F
1088 0xF0F0F0F0F0:0xF0F0F0F0F0:0x0xF0F0F0F0F0
1089 0x0F0F0F0F0F:0x0F0F0F0F0F:0x0x0F0F0F0F0F
1090 0xF0F0F0F0F0F0:0xF0F0F0F0F0F0:0x0xF0F0F0F0F0F0
1091 0x0F0F0F0F0F0F:0x0F0F0F0F0F0F:0x0x0F0F0F0F0F0F
1092 0x1F0F0F0F0F0F:0x3F0F0F0F0F0F:0x0x1F0F0F0F0F0F
1099 +281474976710656:0:281474976710656
1100 +281474976710656:1:281474976710657
1101 +281474976710656:281474976710656:281474976710656
1107 # equal arguments are treated special, so also do some test with unequal ones
1108 0xFFFF:0xFFFF:0x0xFFFF
1109 0xFFFFFF:0xFFFFFF:0x0xFFFFFF
1110 0xFFFFFFFF:0xFFFFFFFF:0x0xFFFFFFFF
1111 0xFFFFFFFFFF:0xFFFFFFFFFF:0x0xFFFFFFFFFF
1112 0xFFFFFFFFFFFF:0xFFFFFFFFFFFF:0x0xFFFFFFFFFFFF
1114 0:0xFFFFFF:0x0xFFFFFF
1115 0:0xFFFFFFFF:0x0xFFFFFFFF
1116 0:0xFFFFFFFFFF:0x0xFFFFFFFFFF
1117 0:0xFFFFFFFFFFFF:0x0xFFFFFFFFFFFF
1119 0xFFFFFF:0:0x0xFFFFFF
1120 0xFFFFFFFF:0:0x0xFFFFFFFF
1121 0xFFFFFFFFFF:0:0x0xFFFFFFFFFF
1122 0xFFFFFFFFFFFF:0:0x0xFFFFFFFFFFFF
1123 0xF0F0:0xF0F0:0x0xF0F0
1124 0x0F0F:0x0F0F:0x0x0F0F
1125 0xF0F0:0x0F0F:0x0xFFFF
1126 0xF0F0F0:0xF0F0F0:0x0xF0F0F0
1127 0x0F0F0F:0x0F0F0F:0x0x0F0F0F
1128 0x0F0F0F:0xF0F0F0:0x0xFFFFFF
1129 0xF0F0F0F0:0xF0F0F0F0:0x0xF0F0F0F0
1130 0x0F0F0F0F:0x0F0F0F0F:0x0x0F0F0F0F
1131 0x0F0F0F0F:0xF0F0F0F0:0x0xFFFFFFFF
1132 0xF0F0F0F0F0:0xF0F0F0F0F0:0x0xF0F0F0F0F0
1133 0x0F0F0F0F0F:0x0F0F0F0F0F:0x0x0F0F0F0F0F
1134 0x0F0F0F0F0F:0xF0F0F0F0F0:0x0xFFFFFFFFFF
1135 0xF0F0F0F0F0F0:0xF0F0F0F0F0F0:0x0xF0F0F0F0F0F0
1136 0x0F0F0F0F0F0F:0x0F0F0F0F0F0F:0x0x0F0F0F0F0F0F
1137 0x0F0F0F0F0F0F:0xF0F0F0F0F0F0:0x0xFFFFFFFFFFFF
1138 0x1F0F0F0F0F0F:0xF0F0F0F0F0F0:0x0xFFFFFFFFFFFF
1145 +281474976710656:0:281474976710656
1146 +281474976710656:1:281474976710657
1147 +281474976710656:281474976710656:0
1155 # equal arguments are treated special, so also do some test with unequal ones
1158 0xFFFFFFFF:0xFFFFFFFF:0
1159 0xFFFFFFFFFF:0xFFFFFFFFFF:0
1160 0xFFFFFFFFFFFF:0xFFFFFFFFFFFF:0
1162 0:0xFFFFFF:0x0xFFFFFF
1163 0:0xFFFFFFFF:0x0xFFFFFFFF
1164 0:0xFFFFFFFFFF:0x0xFFFFFFFFFF
1165 0:0xFFFFFFFFFFFF:0x0xFFFFFFFFFFFF
1167 0xFFFFFF:0:0x0xFFFFFF
1168 0xFFFFFFFF:0:0x0xFFFFFFFF
1169 0xFFFFFFFFFF:0:0x0xFFFFFFFFFF
1170 0xFFFFFFFFFFFF:0:0x0xFFFFFFFFFFFF
1173 0xF0F0:0x0F0F:0x0xFFFF
1176 0x0F0F0F:0xF0F0F0:0x0xFFFFFF
1177 0xF0F0F0F0:0xF0F0F0F0:0
1178 0x0F0F0F0F:0x0F0F0F0F:0
1179 0x0F0F0F0F:0xF0F0F0F0:0x0xFFFFFFFF
1180 0xF0F0F0F0F0:0xF0F0F0F0F0:0
1181 0x0F0F0F0F0F:0x0F0F0F0F0F:0
1182 0x0F0F0F0F0F:0xF0F0F0F0F0:0x0xFFFFFFFFFF
1183 0xF0F0F0F0F0F0:0xF0F0F0F0F0F0:0
1184 0x0F0F0F0F0F0F:0x0F0F0F0F0F0F:0
1185 0x0F0F0F0F0F0F:0xF0F0F0F0F0F0:0x0xFFFFFFFFFFFF
1190 +281474976710656:-281474976710657
1285 -inf:1234500012:-inf
1286 +inf:-12345000123:inf
1287 -inf:-12345000123:-inf
1288 # 1 ** -x => 1 / (1 ** x)
1308 10:20:100000000000000000000
1309 123456:2:15241383936
1317 10000000000000000:17
1319 215960156869840440586892398248:30
1320 # broot always upgrades
1323 123:2:11.09053650640941716205160010260993291846^
1324 # bsqrt always upgrades
1326 145:12.04159457879229548012824103037860805243^
1328 143:11.95826074310139802112984075619561661399^
1330 170:13.03840481040529742916594311485836883306^
1332 168:12.96148139681572046193193487217599331541^
1334 3:1.732050807568877293527446341505872366943^
1335 2:1.41421356237309504880168872420969807857^
1337 12:3.464101615137754587054892683011744733886^
1340 4000000000000:2000000
1341 152399026:12345.00004050222755607815159966235881398^
1343 152399024:12344.99995949777231103967404745303741942^
1352 $round_mode('trunc')
1362 +10123456789:5:10123000000
1363 -10123456789:5:-10123000000
1364 +10123456789:9:10123456700
1365 -10123456789:9:-10123456700
1366 +101234500:6:101234000
1367 -101234500:6:-101234000
1368 #+101234500:-4:101234000
1369 #-101234500:-4:-101234000
1371 +20123456789:5:20123000000
1372 -20123456789:5:-20123000000
1373 +20123456789:9:20123456800
1374 -20123456789:9:-20123456800
1375 +201234500:6:201234000
1376 -201234500:6:-201234000
1377 #+201234500:-4:201234000
1378 #-201234500:-4:-201234000
1379 +12345000:4:12340000
1380 -12345000:4:-12340000
1382 +30123456789:5:30123000000
1383 -30123456789:5:-30123000000
1384 +30123456789:9:30123456800
1385 -30123456789:9:-30123456800
1386 +301234500:6:301235000
1387 -301234500:6:-301234000
1388 #+301234500:-4:301235000
1389 #-301234500:-4:-301234000
1390 +12345000:4:12350000
1391 -12345000:4:-12340000
1393 +40123456789:5:40123000000
1394 -40123456789:5:-40123000000
1395 +40123456789:9:40123456800
1396 -40123456789:9:-40123456800
1397 +401234500:6:401234000
1398 +401234500:6:401234000
1399 #-401234500:-4:-401235000
1400 #-401234500:-4:-401235000
1401 +12345000:4:12340000
1402 -12345000:4:-12350000
1404 +50123456789:5:50123000000
1405 -50123456789:5:-50123000000
1406 +50123456789:9:50123456800
1407 -50123456789:9:-50123456800
1408 +501234500:6:501235000
1409 -501234500:6:-501235000
1410 #+501234500:-4:501235000
1411 #-501234500:-4:-501235000
1412 +12345000:4:12350000
1413 -12345000:4:-12350000
1415 +60123456789:5:60123000000
1416 -60123456789:5:-60123000000
1417 +60123456789:9:60123456800
1418 -60123456789:9:-60123456800
1419 +601234500:6:601234000
1420 -601234500:6:-601234000
1421 #+601234500:-4:601234000
1422 #-601234500:-4:-601234000
1429 +12345000:4:12340000
1430 -12345000:4:-12340000
1448 # floor and ceil tests are pretty pointless in integer space...but play safe
1475 0x123456789123456789:0x123456789123456789
1485 0b1010111101010101010110110110110110101:0b1010111101010101010110110110110110101