1 #include this file into another for subclass testing
3 my $version = ${"$class\::VERSION"};
5 ##############################################################################
6 # for testing inheritance of _swap
10 use Math::BigInt lib => $main::CL;
12 @ISA = (qw/Math::BigInt/);
15 # customized overload for sub, since original does not use swap there
16 '-' => sub { my @a = ref($_[0])->_swap(@_);
21 # a fake _swap, which reverses the params
22 my $self = shift; # for override in subclass
25 my $c = ref ($_[0] ) || 'Math::Foo';
26 return ( $_[0]->copy(), $_[1] );
30 return ( Math::Foo->new($_[1]), $_[0] );
34 ##############################################################################
37 my $CALC = $class->config()->{lib}; ok ($CALC,$CL);
39 my ($f,$z,$a,$exp,@a,$m,$e,$round_mode,$expected_class);
44 next if /^#/; # skip comments
51 $round_mode = $_; $round_mode =~ s/^\$/$class\->/; next;
54 @args = split(/:/,$_,99); $ans = pop(@args);
55 $expected_class = $class;
56 if ($ans =~ /(.*?)=(.*)/)
58 $expected_class = $2; $ans = $1;
60 $try = "\$x = $class->new(\"$args[0]\");";
63 $try = "\$x = $class->bnorm(\"$args[0]\");";
65 } elsif ($f =~ /^is_(zero|one|odd|even|negative|positive|nan|int)$/) {
67 } elsif ($f eq "as_hex") {
68 $try .= '$x->as_hex();';
69 } elsif ($f eq "as_bin") {
70 $try .= '$x->as_bin();';
71 } elsif ($f eq "is_inf") {
72 $try .= "\$x->is_inf('$args[1]');";
73 } elsif ($f eq "binf") {
74 $try .= "\$x->binf('$args[1]');";
75 } elsif ($f eq "bone") {
76 $try .= "\$x->bone('$args[1]');";
78 } elsif ($f =~ /^b(nan|floor|ceil|sstr|neg|abs|inc|dec|not|sqrt|fac)$/) {
80 } elsif ($f eq "length") {
81 $try .= '$x->length();';
82 } elsif ($f eq "exponent"){
83 # ->bstr() to see if an object is returned
84 $try .= '$x = $x->exponent()->bstr();';
85 } elsif ($f eq "mantissa"){
86 # ->bstr() to see if an object is returned
87 $try .= '$x = $x->mantissa()->bstr();';
88 } elsif ($f eq "parts"){
89 $try .= '($m,$e) = $x->parts();';
90 # ->bstr() to see if an object is returned
91 $try .= '$m = $m->bstr(); $m = "NaN" if !defined $m;';
92 $try .= '$e = $e->bstr(); $e = "NaN" if !defined $e;';
95 $try .= "\$y = $class->new('$args[1]');";
99 } elsif ($f eq "bround") {
100 $try .= "$round_mode; \$x->bround(\$y);";
101 } elsif ($f eq "bacmp"){
102 $try .= '$x->bacmp($y);';
103 } elsif ($f eq "badd"){
105 } elsif ($f eq "bsub"){
107 } elsif ($f eq "bmul"){
109 } elsif ($f eq "bdiv"){
111 } elsif ($f eq "bdiv-list"){
112 $try .= 'join (",",$x->bdiv($y));';
114 } elsif ($f =~ /^.=$/){
115 $try .= "\$x $f \$y;";
117 } elsif ($f =~ /^.$/){
118 $try .= "\$x $f \$y;";
119 } elsif ($f eq "bmod"){
121 } elsif ($f eq "bgcd")
123 if (defined $args[2])
125 $try .= " \$z = $class->new('$args[2]'); ";
127 $try .= "$class\::bgcd(\$x, \$y";
128 $try .= ", \$z" if (defined $args[2]);
133 if (defined $args[2])
135 $try .= " \$z = $class->new('$args[2]'); ";
137 $try .= "$class\::blcm(\$x, \$y";
138 $try .= ", \$z" if (defined $args[2]);
140 }elsif ($f eq "blsft"){
141 if (defined $args[2])
143 $try .= "\$x->blsft(\$y,$args[2]);";
147 $try .= "\$x << \$y;";
149 }elsif ($f eq "brsft"){
150 if (defined $args[2])
152 $try .= "\$x->brsft(\$y,$args[2]);";
156 $try .= "\$x >> \$y;";
158 }elsif ($f eq "band"){
159 $try .= "\$x & \$y;";
160 }elsif ($f eq "bior"){
161 $try .= "\$x | \$y;";
162 }elsif ($f eq "bxor"){
163 $try .= "\$x ^ \$y;";
164 }elsif ($f eq "bpow"){
165 $try .= "\$x ** \$y;";
166 } elsif( $f eq "bmodinv") {
167 $try .= "\$x->bmodinv(\$y);";
168 }elsif ($f eq "digit"){
169 $try .= "\$x->digit(\$y);";
171 $try .= "\$z = $class->new(\"$args[2]\");";
173 # Functions with three arguments
174 if( $f eq "bmodpow") {
175 $try .= "\$x->bmodpow(\$y,\$z);";
176 } 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 ok (ref($ans),$expected_class) if $expected_class ne $class;
196 # check internal state of number objects
197 is_valid($ans1,$f) if ref $ans1;
198 } # endwhile data tests
203 for (my $i = 1; $i < 10; $i++)
207 ok "@a", "1 2 3 4 5 6 7 8 9";
209 # test whether self-multiplication works correctly (result is 2**64)
210 $try = "\$x = $class->new('4294967296');";
211 $try .= '$a = $x->bmul($x);';
213 print "# Tried: '$try'\n" if !ok ($ans1, $class->new(2) ** 64);
215 $try = "\$x = $class->new(10);";
216 $try .= '$a = $x->bpow($x);';
218 print "# Tried: '$try'\n" if !ok ($ans1, $class->new(10) ** 10);
220 ###############################################################################
221 # test whether op destroys args or not (should better not)
247 $x = $class->new(-5); $y = -$x;
250 $x = $class->new(-5); $y = abs($x);
254 $y = $class->new(-1);
255 $z = $class->new(5033);
256 my $u = $x->copy()->bmodpow($y,$z);
261 $x = $class->new(-5); $y = -$x; ok ($x,-5); ok ($y,5);
262 $x = $class->new(-5); $y = $x->copy()->bneg(); ok ($x,-5); ok ($y,5);
264 $x = $class->new(-5); $y = $class->new(3); $x->bmul($y); ok ($x,-15); ok ($y,3);
265 $x = $class->new(-5); $y = $class->new(3); $x->badd($y); ok ($x,-2); ok ($y,3);
266 $x = $class->new(-5); $y = $class->new(3); $x->bsub($y); ok ($x,-8); ok ($y,3);
267 $x = $class->new(-15); $y = $class->new(3); $x->bdiv($y); ok ($x,-5); ok ($y,3);
268 $x = $class->new(-5); $y = $class->new(3); $x->bmod($y); ok ($x,1); ok ($y,3);
270 $x = $class->new(5); $y = $class->new(3); $x->bmul($y); ok ($x,15); ok ($y,3);
271 $x = $class->new(5); $y = $class->new(3); $x->badd($y); ok ($x,8); ok ($y,3);
272 $x = $class->new(5); $y = $class->new(3); $x->bsub($y); ok ($x,2); ok ($y,3);
273 $x = $class->new(15); $y = $class->new(3); $x->bdiv($y); ok ($x,5); ok ($y,3);
274 $x = $class->new(5); $y = $class->new(3); $x->bmod($y); ok ($x,2); ok ($y,3);
276 $x = $class->new(5); $y = $class->new(-3); $x->bmul($y); ok ($x,-15); ok($y,-3);
277 $x = $class->new(5); $y = $class->new(-3); $x->badd($y); ok ($x,2); ok($y,-3);
278 $x = $class->new(5); $y = $class->new(-3); $x->bsub($y); ok ($x,8); ok($y,-3);
279 $x = $class->new(15); $y = $class->new(-3); $x->bdiv($y); ok ($x,-5); ok($y,-3);
280 $x = $class->new(5); $y = $class->new(-3); $x->bmod($y); ok ($x,-1); ok($y,-3);
282 ###############################################################################
283 # check whether overloading cmp works
284 $try = "\$x = $class->new(0);";
286 $try .= "'false' if \$x ne \$y;";
288 print "# For '$try'\n" if (!ok "$ans" , "false" );
290 # we cant test for working cmpt with other objects here, we would need a dummy
291 # object with stringify overload for this. see Math::String tests as example
293 ###############################################################################
294 # check reversed order of arguments
296 $try = "\$x = $class->new(10); \$x = 2 ** \$x;";
297 $try .= "'ok' if \$x == 1024;"; $ans = eval $try;
298 print "# For '$try'\n" if (!ok "$ans" , "ok" );
300 $try = "\$x = $class->new(10); \$x = 2 * \$x;";
301 $try .= "'ok' if \$x == 20;"; $ans = eval $try;
302 print "# For '$try'\n" if (!ok "$ans" , "ok" );
304 $try = "\$x = $class->new(10); \$x = 2 + \$x;";
305 $try .= "'ok' if \$x == 12;"; $ans = eval $try;
306 print "# For '$try'\n" if (!ok "$ans" , "ok" );
308 $try = "\$x = $class\->new(10); \$x = 2 - \$x;";
309 $try .= "'ok' if \$x == -8;"; $ans = eval $try;
310 print "# For '$try'\n" if (!ok "$ans" , "ok" );
312 $try = "\$x = $class\->new(10); \$x = 20 / \$x;";
313 $try .= "'ok' if \$x == 2;"; $ans = eval $try;
314 print "# For '$try'\n" if (!ok "$ans" , "ok" );
316 $try = "\$x = $class\->new(3); \$x = 20 % \$x;";
317 $try .= "'ok' if \$x == 2;"; $ans = eval $try;
318 print "# For '$try'\n" if (!ok "$ans" , "ok" );
320 $try = "\$x = $class\->new(7); \$x = 20 & \$x;";
321 $try .= "'ok' if \$x == 4;"; $ans = eval $try;
322 print "# For '$try'\n" if (!ok "$ans" , "ok" );
324 $try = "\$x = $class\->new(7); \$x = 0x20 | \$x;";
325 $try .= "'ok' if \$x == 0x27;"; $ans = eval $try;
326 print "# For '$try'\n" if (!ok "$ans" , "ok" );
328 $try = "\$x = $class\->new(7); \$x = 0x20 ^ \$x;";
329 $try .= "'ok' if \$x == 0x27;"; $ans = eval $try;
330 print "# For '$try'\n" if (!ok "$ans" , "ok" );
332 ###############################################################################
333 # check badd(4,5) form
335 $try = "\$x = $class\->badd(4,5);";
336 $try .= "'ok' if \$x == 9;";
338 print "# For '$try'\n" if (!ok "$ans" , "ok" );
340 ###############################################################################
341 # check undefs: NOT DONE YET
343 ###############################################################################
346 $x = Math::BigInt->new(1); if ($x) { ok (1,1); } else { ok($x,'to be true') }
347 $x = Math::BigInt->new(0); if (!$x) { ok (1,1); } else { ok($x,'to be false') }
349 ###############################################################################
352 @args = Math::BigInt::objectify(2,4,5);
353 ok (scalar @args,3); # $class, 4, 5
354 ok ($args[0] =~ /^Math::BigInt/);
358 @args = Math::BigInt::objectify(0,4,5);
359 ok (scalar @args,3); # $class, 4, 5
360 ok ($args[0] =~ /^Math::BigInt/);
364 @args = Math::BigInt::objectify(2,4,5);
365 ok (scalar @args,3); # $class, 4, 5
366 ok ($args[0] =~ /^Math::BigInt/);
370 @args = Math::BigInt::objectify(2,4,5,6,7);
371 ok (scalar @args,5); # $class, 4, 5, 6, 7
372 ok ($args[0] =~ /^Math::BigInt/);
373 ok ($args[1],4); ok (ref($args[1]),$args[0]);
374 ok ($args[2],5); ok (ref($args[2]),$args[0]);
375 ok ($args[3],6); ok (ref($args[3]),'');
376 ok ($args[4],7); ok (ref($args[4]),'');
378 @args = Math::BigInt::objectify(2,$class,4,5,6,7);
379 ok (scalar @args,5); # $class, 4, 5, 6, 7
380 ok ($args[0],$class);
381 ok ($args[1],4); ok (ref($args[1]),$args[0]);
382 ok ($args[2],5); ok (ref($args[2]),$args[0]);
383 ok ($args[3],6); ok (ref($args[3]),'');
384 ok ($args[4],7); ok (ref($args[4]),'');
386 ###############################################################################
387 # test for floating-point input (other tests in bnorm() below)
389 $z = 1050000000000000; # may be int on systems with 64bit?
390 $x = $class->new($z); ok ($x->bsstr(),'105e+13'); # not 1.05e+15
391 $z = 1e+129; # definitely a float (may fail on UTS)
392 # don't compare to $z, since some Perl versions stringify $z into something
393 # like '1.e+129' or something equally ugly
394 $x = $class->new($z); ok ($x->bsstr(),'1e+129');
396 ###############################################################################
397 # prime number tests, also test for **= and length()
398 # found on: http://www.utm.edu/research/primes/notes/by_year.html
401 $x = $class->new(2); $x **= 148; $x++; $x = $x / 17;
402 ok ($x,"20988936657440586486151264256610222593863921");
403 ok ($x->length(),length "20988936657440586486151264256610222593863921");
406 $x = $class->new(2); $x **= 127; $x--;
407 ok ($x,"170141183460469231731687303715884105727");
409 $x = $class->new('215960156869840440586892398248');
410 ($x,$y) = $x->length();
411 ok ($x,30); ok ($y,0);
413 $x = $class->new('1_000_000_000_000');
414 ($x,$y) = $x->length();
415 ok ($x,13); ok ($y,0);
417 # I am afraid the following is not yet possible due to slowness
418 # Also, testing for 2 meg output is a bit hard ;)
419 #$x = $class->new(2); $x **= 6972593; $x--;
421 # 593573509*2^332162+1 has exactly 1,000,000 digits
422 # takes about 24 mins on 300 Mhz, so cannot be done yet ;)
423 #$x = $class->new(2); $x **= 332162; $x *= "593573509"; $x++;
424 #ok ($x->length(),1_000_000);
426 ###############################################################################
427 # inheritance and overriding of _swap
429 $x = Math::Foo->new(5);
430 $x = $x - 8; # 8 - 5 instead of 5-8
432 ok (ref($x),'Math::Foo');
434 $x = Math::Foo->new(5);
435 $x = 8 - $x; # 5 - 8 instead of 8 - 5
437 ok (ref($x),'Math::Foo');
439 ###############################################################################
440 # Test whether +inf eq inf
441 # This tried to test whether BigInt inf equals Perl inf. Unfortunately, Perl
442 # hasn't (before 5.7.3 at least) a consistent way to say inf, and some things
443 # like 1e100000 crash on some platforms. So simple test for the string 'inf'
444 $x = $class->new('+inf'); ok ($x,'inf');
446 ###############################################################################
447 ###############################################################################
448 # the followin tests only make sense with Math::BigInt::Calc or BareCalc
450 exit if $CALC !~ /^Math::BigInt::(Calc|BareCalc)$/; # for Pari et al.
452 ###############################################################################
453 # check proper length of internal arrays
455 my $bl = $CL->_base_len();
456 my $BASE = '9' x $bl;
460 $x = $class->new($MAX); is_valid($x); # f.i. 9999
461 $x += 1; ok ($x,$BASE); is_valid($x); # 10000
462 $x -= 1; ok ($x,$MAX); is_valid($x); # 9999 again
464 ###############################################################################
467 $x = $class->new($BASE-1); ok ($x->numify(),$BASE-1);
468 $x = $class->new(-($BASE-1)); ok ($x->numify(),-($BASE-1));
470 # +0 is to protect from 1e15 vs 100000000 (stupid to_string aaaarglburblll...)
471 $x = $class->new($BASE); ok ($x->numify()+0,$BASE+0);
472 $x = $class->new(-$BASE); ok ($x->numify(),-$BASE);
473 $x = $class->new( -($BASE*$BASE*1+$BASE*1+1) );
474 ok($x->numify(),-($BASE*$BASE*1+$BASE*1+1));
476 ###############################################################################
477 # test bug in _digits with length($c[-1]) where $c[-1] was "00001" instead of 1
479 $x = $class->new($BASE-2); $x++; $x++; $x++; $x++;
480 if ($x > $BASE) { ok (1,1) } else { ok ("$x < $BASE","$x > $BASE"); }
482 $x = $class->new($BASE+3); $x++;
483 if ($x > $BASE) { ok (1,1) } else { ok ("$x > $BASE","$x < $BASE"); }
485 # test for +0 instead of int():
486 $x = $class->new($MAX); ok ($x->length(), length($MAX));
488 ###############################################################################
489 # test bug that $class->digit($string) did not work
491 ok ($class->digit(123,2),1);
493 ###############################################################################
494 # bug in sub where number with at least 6 trailing zeros after any op failed
496 $x = $class->new(123456); $z = $class->new(10000); $z *= 10; $x -= $z;
500 ###############################################################################
501 # bug in shortcut in mul()
503 # construct a number with a zero-hole of BASE_LEN_SMALL
505 my @bl = $CL->_base_len(); my $bl = $bl[4];
507 $x = '1' x $bl . '0' x $bl . '1' x $bl . '0' x $bl;
509 $x = $class->new($x)->bmul($y);
510 # result is 123..$bl . $bl x (3*bl-1) . $bl...321 . '0' x $bl
512 for (my $i = 1; $i <= $bl; $i++)
514 $y .= $i; $d = $i.$d;
516 $y .= $bl x (3*$bl-1) . $d . '0' x $bl;
520 ###############################################################################
521 # see if mul shortcut for small numbers works
524 $x = $class->new($x);
525 # 999 * 999 => 998 . 001, 9999*9999 => 9998 . 0001
526 ok ($x*$x, '9' x ($bl-1) . '8' . '0' x ($bl-1) . '1');
530 ###############################################################################
531 # bug with rest "-0" in div, causing further div()s to fail
533 $x = $class->new('-322056000'); ($x,$y) = $x->bdiv('-12882240');
535 ok ($y,'0'); is_valid($y); # $y not '-0'
537 ###############################################################################
538 # bug in $x->bmod($y) if $x < 0 and $y > 0
540 $x = $class->new('-629'); ok ($x->bmod(5033),4404);
542 ###############################################################################
543 # bone/binf etc as plain calls (Lite failed them)
545 ok ($class->bzero(),0);
546 ok ($class->bone(),1);
547 ok ($class->bone('+'),1);
548 ok ($class->bone('-'),-1);
549 ok ($class->bnan(),'NaN');
550 ok ($class->binf(),'inf');
551 ok ($class->binf('+'),'inf');
552 ok ($class->binf('-'),'-inf');
553 ok ($class->binf('-inf'),'-inf');
555 ###############################################################################
560 ###############################################################################
561 ###############################################################################
562 # Perl 5.005 does not like ok ($x,undef)
568 ok (1,1) and return if !defined $x;
572 ###############################################################################
573 # sub to check validity of a BigInt internally, to ensure that no op leaves a
574 # number object in an invalid state (f.i. "-0")
582 # allow the check to pass for all Lite, and all MBI and subclasses
584 $e = 'Not a reference to Math::BigInt' if ref($x) !~ /^Math::BigInt/;
586 if (ref($x) ne 'Math::BigInt::Lite')
589 $e = "Illegal sign $x->{sign} (expected: '+', '-', '-inf', '+inf' or 'NaN'"
590 if $e eq '0' && $x->{sign} !~ /^(\+|-|\+inf|-inf|NaN)$/;
592 $e = "-0 is invalid!" if $e ne '0' && $x->{sign} eq '-' && $x == 0;
593 $e = $CALC->_check($x->{value}) if $e eq '0';
596 # test done, see if error did crop up
597 ok (1,1), return if ($e eq '0');
599 ok (1,$e." after op '$f'");
679 -123456789:+987654321:-1
680 +123456789:-987654321:-1
681 +987654321:+123456789:1
682 -987654321:+123456789:1
724 0b10000000000001:8193
725 0b100000000000001:16385
726 0b1000000000000001:32769
727 0b10000000000000001:65537
728 0b100000000000000001:131073
729 0b1000000000000000001:262145
730 0b10000000000000000001:524289
731 0b100000000000000000001:1048577
732 0b1000000000000000000001:2097153
733 0b10000000000000000000001:4194305
734 0b100000000000000000000001:8388609
735 0b1000000000000000000000001:16777217
736 0b10000000000000000000000001:33554433
737 0b100000000000000000000000001:67108865
738 0b1000000000000000000000000001:134217729
739 0b10000000000000000000000000001:268435457
740 0b100000000000000000000000000001:536870913
741 0b1000000000000000000000000000001:1073741825
742 0b10000000000000000000000000000001:2147483649
743 0b100000000000000000000000000000001:4294967297
744 0b1000000000000000000000000000000001:8589934593
745 0b10000000000000000000000000000000001:17179869185
757 0x1_2_3_4_56_78:305419896
758 0xa_b_c_d_e_f:11259375
787 0x40000001:1073741825
788 0x80000001:2147483649
789 0x100000001:4294967297
790 0x200000001:8589934593
791 0x400000001:17179869185
792 0x800000001:34359738369
806 # only one underscore between two digits
824 # bug with two E's in number beeing valid
828 # bug with two '.' in number beeing valid
852 01234567891:1234567891
853 012345678912:12345678912
854 0123456789123:123456789123
855 01234567891234:1234567891234
872 -123456789:-123456789
881 # floating point input
889 # non-integer numbers
928 # it must be exactly /^[+-]inf$/
935 +1:+48:281474976710656
938 +12345:4:10:123450000
944 1234567890123:12:10:1234567890123000000000000
948 -102533203:1:2:-205066406
953 +281474976710656:+48:1
964 1230000000000:10:10:123
965 09876123456789067890:12:10:9876123
966 1234561234567890123:13:10:123456
967 820265627:1:2:410132813
968 # test shifting negative numbers in base 2
984 -1640531254:2:2:-410132814
985 -1640531254:1:2:-820265627
986 -820265627:1:2:-410132814
987 -205066405:1:2:-102533203
1001 +123456789:-123456789
1002 -123456789:123456789
1010 +123456789:123456789
1011 -123456789:123456789
1036 -123456789:987654321:-1
1037 +123456789:-987654321:1
1038 -987654321:123456789:-1
1097 +9999999:+1:10000000
1098 +99999999:+1:100000000
1099 +999999999:+1:1000000000
1100 +9999999999:+1:10000000000
1101 +99999999999:+1:100000000000
1108 +10000000:-1:9999999
1109 +100000000:-1:99999999
1110 +1000000000:-1:999999999
1111 +10000000000:-1:9999999999
1112 +123456789:987654321:1111111110
1113 -123456789:987654321:864197532
1114 -123456789:-987654321:-1111111110
1115 +123456789:-987654321:-864197532
1119 -1:10000001:10000000
1120 -1:100000001:100000000
1121 -1:1000000001:1000000000
1122 -1:10000000001:10000000000
1123 -1:100000000001:100000000000
1124 -1:1000000000001:1000000000000
1125 -1:10000000000001:10000000000000
1128 -1:-1000001:-1000002
1129 -1:-10000001:-10000002
1130 -1:-100000001:-100000002
1131 -1:-1000000001:-1000000002
1132 -1:-10000000001:-10000000002
1133 -1:-100000000001:-100000000002
1134 -1:-1000000000001:-1000000000002
1135 -1:-10000000000001:-10000000000002
1160 +99999999:+1:99999998
1161 +999999999:+1:999999998
1162 +9999999999:+1:9999999998
1163 +99999999999:+1:99999999998
1170 +10000000:-1:10000001
1171 +100000000:-1:100000001
1172 +1000000000:-1:1000000001
1173 +10000000000:-1:10000000001
1174 +123456789:+987654321:-864197532
1175 -123456789:+987654321:-1111111110
1176 -123456789:-987654321:864197532
1177 +123456789:-987654321:1111111110
1182 100000001:1:100000000
1183 1000000001:1:1000000000
1184 10000000001:1:10000000000
1185 100000000001:1:100000000000
1186 1000000000001:1:1000000000000
1187 10000000000001:1:10000000000000
1191 10000001:-1:10000002
1192 100000001:-1:100000002
1193 1000000001:-1:1000000002
1194 10000000001:-1:10000000002
1195 100000000001:-1:100000000002
1196 1000000000001:-1:1000000000002
1197 10000000000001:-1:10000000000002
1215 123456789123456789:0:0
1216 0:123456789123456789:0
1226 10101:10101:102030201
1227 1001001:1001001:1002003002001
1228 100010001:100010001:10002000300020001
1229 10000100001:10000100001:100002000030000200001
1230 11111111111:9:99999999999
1231 22222222222:9:199999999998
1232 33333333333:9:299999999997
1233 44444444444:9:399999999996
1234 55555555555:9:499999999995
1235 66666666666:9:599999999994
1236 77777777777:9:699999999993
1237 88888888888:9:799999999992
1238 99999999999:9:899999999991
1240 +12345:+12345:152399025
1241 +99999:+11111:1111088889
1243 99999:100000:9999900000
1244 999999:1000000:999999000000
1245 9999999:10000000:99999990000000
1246 99999999:100000000:9999999900000000
1247 999999999:1000000000:999999999000000000
1248 9999999999:10000000000:99999999990000000000
1249 99999999999:100000000000:9999999999900000000000
1250 999999999999:1000000000000:999999999999000000000000
1251 9999999999999:10000000000000:99999999999990000000000000
1252 99999999999999:100000000000000:9999999999999900000000000000
1253 999999999999999:1000000000000000:999999999999999000000000000000
1254 9999999999999999:10000000000000000:99999999999999990000000000000000
1255 99999999999999999:100000000000000000:9999999999999999900000000000000000
1256 999999999999999999:1000000000000000000:999999999999999999000000000000000000
1257 9999999999999999999:10000000000000000000:99999999999999999990000000000000000000
1267 # inf handling and general remainder
1273 # see table in documentation in MBI
1292 # exceptions to reminder rule
1301 # inf handling (see table in doc)
1336 1000000000:9:111111111
1337 2000000000:9:222222222
1338 3000000000:9:333333333
1339 4000000000:9:444444444
1340 5000000000:9:555555555
1341 6000000000:9:666666666
1342 7000000000:9:777777777
1343 8000000000:9:888888888
1344 9000000000:9:1000000000
1347 106500000:339:314159
1348 1000000000:3:333333333
1353 999999999999:9:111111111111
1354 999999999999:99:10101010101
1355 999999999999:999:1001001001
1356 999999999999:9999:100010001
1357 999999999999999:99999:10000100001
1358 +1111088889:99999:11111
1373 # bug in Calc with '99999' vs $BASE-1
1374 10000000000000000000000000000000000000000000000000000000000000000000000000000000000:10000000375084540248994272022843165711074:999999962491547381984643365663244474111576
1376 # format: number:modulus:result
1377 # bmodinv Data errors
1381 # bmodinv Expected Results from normal use
1386 324958749843759385732954874325984357439658735983745:2348249874968739:1741662881064902
1387 ## bmodinv Error cases / useless use of function
1394 # format: number:exponent:modulus:result
1395 # bmodpow Data errors
1403 # bmodpow Expected results
1409 98436739867439843769485798542749827593285729587325:43698764986460981048259837659386739857456983759328457:6943857329857295827698367:3104744730915914415259518
1410 # bmodpow Error cases
1416 # inf handling, see table in doc
1435 # exceptions to reminder rule
1474 999999999999999:99999:0
1488 152403346:12345:4321
1490 # test shortcuts in Calc
1491 # 1ex % 9 is always == 1, 1ex % 113 is != 1 for x = (4..9), 1ex % 10 = 0
1498 1234567891234567:9:1
1499 123456789123456789:9:0
1506 1234567891234567:10:7
1507 123456789123456789:10:9
1513 12345678912345:113:53
1514 1234567891234567:113:56
1515 123456789123456789:113:39
1516 # bug in bmod() not modifying the variable in place
1550 +281474976710656:0:0
1551 +281474976710656:1:0
1552 +281474976710656:+281474976710656:281474976710656
1559 # equal arguments are treated special, so also do some test with unequal ones
1560 0xFFFF:0xFFFF:0x0xFFFF
1561 0xFFFFFF:0xFFFFFF:0x0xFFFFFF
1562 0xFFFFFFFF:0xFFFFFFFF:0x0xFFFFFFFF
1563 0xFFFFFFFFFF:0xFFFFFFFFFF:0x0xFFFFFFFFFF
1564 0xFFFFFFFFFFFF:0xFFFFFFFFFFFF:0x0xFFFFFFFFFFFF
1565 0xF0F0:0xF0F0:0x0xF0F0
1566 0x0F0F:0x0F0F:0x0x0F0F
1567 0xF0F0F0:0xF0F0F0:0x0xF0F0F0
1568 0x0F0F0F:0x0F0F0F:0x0x0F0F0F
1569 0xF0F0F0F0:0xF0F0F0F0:0x0xF0F0F0F0
1570 0x0F0F0F0F:0x0F0F0F0F:0x0x0F0F0F0F
1571 0xF0F0F0F0F0:0xF0F0F0F0F0:0x0xF0F0F0F0F0
1572 0x0F0F0F0F0F:0x0F0F0F0F0F:0x0x0F0F0F0F0F
1573 0xF0F0F0F0F0F0:0xF0F0F0F0F0F0:0x0xF0F0F0F0F0F0
1574 0x0F0F0F0F0F0F:0x0F0F0F0F0F0F:0x0x0F0F0F0F0F0F
1575 0x1F0F0F0F0F0F:0x3F0F0F0F0F0F:0x0x1F0F0F0F0F0F
1582 +281474976710656:0:281474976710656
1583 +281474976710656:1:281474976710657
1584 +281474976710656:281474976710656:281474976710656
1590 # equal arguments are treated special, so also do some test with unequal ones
1591 0xFFFF:0xFFFF:0x0xFFFF
1592 0xFFFFFF:0xFFFFFF:0x0xFFFFFF
1593 0xFFFFFFFF:0xFFFFFFFF:0x0xFFFFFFFF
1594 0xFFFFFFFFFF:0xFFFFFFFFFF:0x0xFFFFFFFFFF
1595 0xFFFFFFFFFFFF:0xFFFFFFFFFFFF:0x0xFFFFFFFFFFFF
1597 0:0xFFFFFF:0x0xFFFFFF
1598 0:0xFFFFFFFF:0x0xFFFFFFFF
1599 0:0xFFFFFFFFFF:0x0xFFFFFFFFFF
1600 0:0xFFFFFFFFFFFF:0x0xFFFFFFFFFFFF
1602 0xFFFFFF:0:0x0xFFFFFF
1603 0xFFFFFFFF:0:0x0xFFFFFFFF
1604 0xFFFFFFFFFF:0:0x0xFFFFFFFFFF
1605 0xFFFFFFFFFFFF:0:0x0xFFFFFFFFFFFF
1606 0xF0F0:0xF0F0:0x0xF0F0
1607 0x0F0F:0x0F0F:0x0x0F0F
1608 0xF0F0:0x0F0F:0x0xFFFF
1609 0xF0F0F0:0xF0F0F0:0x0xF0F0F0
1610 0x0F0F0F:0x0F0F0F:0x0x0F0F0F
1611 0x0F0F0F:0xF0F0F0:0x0xFFFFFF
1612 0xF0F0F0F0:0xF0F0F0F0:0x0xF0F0F0F0
1613 0x0F0F0F0F:0x0F0F0F0F:0x0x0F0F0F0F
1614 0x0F0F0F0F:0xF0F0F0F0:0x0xFFFFFFFF
1615 0xF0F0F0F0F0:0xF0F0F0F0F0:0x0xF0F0F0F0F0
1616 0x0F0F0F0F0F:0x0F0F0F0F0F:0x0x0F0F0F0F0F
1617 0x0F0F0F0F0F:0xF0F0F0F0F0:0x0xFFFFFFFFFF
1618 0xF0F0F0F0F0F0:0xF0F0F0F0F0F0:0x0xF0F0F0F0F0F0
1619 0x0F0F0F0F0F0F:0x0F0F0F0F0F0F:0x0x0F0F0F0F0F0F
1620 0x0F0F0F0F0F0F:0xF0F0F0F0F0F0:0x0xFFFFFFFFFFFF
1621 0x1F0F0F0F0F0F:0xF0F0F0F0F0F0:0x0xFFFFFFFFFFFF
1628 +281474976710656:0:281474976710656
1629 +281474976710656:1:281474976710657
1630 +281474976710656:281474976710656:0
1638 # equal arguments are treated special, so also do some test with unequal ones
1641 0xFFFFFFFF:0xFFFFFFFF:0
1642 0xFFFFFFFFFF:0xFFFFFFFFFF:0
1643 0xFFFFFFFFFFFF:0xFFFFFFFFFFFF:0
1645 0:0xFFFFFF:0x0xFFFFFF
1646 0:0xFFFFFFFF:0x0xFFFFFFFF
1647 0:0xFFFFFFFFFF:0x0xFFFFFFFFFF
1648 0:0xFFFFFFFFFFFF:0x0xFFFFFFFFFFFF
1650 0xFFFFFF:0:0x0xFFFFFF
1651 0xFFFFFFFF:0:0x0xFFFFFFFF
1652 0xFFFFFFFFFF:0:0x0xFFFFFFFFFF
1653 0xFFFFFFFFFFFF:0:0x0xFFFFFFFFFFFF
1656 0xF0F0:0x0F0F:0x0xFFFF
1659 0x0F0F0F:0xF0F0F0:0x0xFFFFFF
1660 0xF0F0F0F0:0xF0F0F0F0:0
1661 0x0F0F0F0F:0x0F0F0F0F:0
1662 0x0F0F0F0F:0xF0F0F0F0:0x0xFFFFFFFF
1663 0xF0F0F0F0F0:0xF0F0F0F0F0:0
1664 0x0F0F0F0F0F:0x0F0F0F0F0F:0
1665 0x0F0F0F0F0F:0xF0F0F0F0F0:0x0xFFFFFFFFFF
1666 0xF0F0F0F0F0F0:0xF0F0F0F0F0F0:0
1667 0x0F0F0F0F0F0F:0x0F0F0F0F0F0F:0
1668 0x0F0F0F0F0F0F:0xF0F0F0F0F0F0:0x0xFFFFFFFFFFFF
1673 +281474976710656:-281474976710657
1768 -inf:1234500012:-inf
1769 +inf:-12345000123:inf
1770 -inf:-12345000123:-inf
1771 # 1 ** -x => 1 / (1 ** x)
1791 10:20:100000000000000000000
1792 123456:2:15241383936
1799 10000000000000000:17
1801 215960156869840440586892398248:30
1817 4000000000000:2000000
1828 $round_mode('trunc')
1838 +10123456789:5:10123000000
1839 -10123456789:5:-10123000000
1840 +10123456789:9:10123456700
1841 -10123456789:9:-10123456700
1842 +101234500:6:101234000
1843 -101234500:6:-101234000
1844 #+101234500:-4:101234000
1845 #-101234500:-4:-101234000
1847 +20123456789:5:20123000000
1848 -20123456789:5:-20123000000
1849 +20123456789:9:20123456800
1850 -20123456789:9:-20123456800
1851 +201234500:6:201234000
1852 -201234500:6:-201234000
1853 #+201234500:-4:201234000
1854 #-201234500:-4:-201234000
1855 +12345000:4:12340000
1856 -12345000:4:-12340000
1858 +30123456789:5:30123000000
1859 -30123456789:5:-30123000000
1860 +30123456789:9:30123456800
1861 -30123456789:9:-30123456800
1862 +301234500:6:301235000
1863 -301234500:6:-301234000
1864 #+301234500:-4:301235000
1865 #-301234500:-4:-301234000
1866 +12345000:4:12350000
1867 -12345000:4:-12340000
1869 +40123456789:5:40123000000
1870 -40123456789:5:-40123000000
1871 +40123456789:9:40123456800
1872 -40123456789:9:-40123456800
1873 +401234500:6:401234000
1874 +401234500:6:401234000
1875 #-401234500:-4:-401235000
1876 #-401234500:-4:-401235000
1877 +12345000:4:12340000
1878 -12345000:4:-12350000
1880 +50123456789:5:50123000000
1881 -50123456789:5:-50123000000
1882 +50123456789:9:50123456800
1883 -50123456789:9:-50123456800
1884 +501234500:6:501235000
1885 -501234500:6:-501235000
1886 #+501234500:-4:501235000
1887 #-501234500:-4:-501235000
1888 +12345000:4:12350000
1889 -12345000:4:-12350000
1891 +60123456789:5:60123000000
1892 -60123456789:5:-60123000000
1893 +60123456789:9:60123456800
1894 -60123456789:9:-60123456800
1895 +601234500:6:601234000
1896 -601234500:6:-601234000
1897 #+601234500:-4:601234000
1898 #-601234500:-4:-601234000
1905 +12345000:4:12340000
1906 -12345000:4:-12340000
1924 # floor and ceil tests are pretty pointless in integer space...but play safe
1951 0x123456789123456789:0x123456789123456789
1961 0b1010111101010101010110110110110110101:0b1010111101010101010110110110110110101
1962 0x123456789123456789:0b100100011010001010110011110001001000100100011010001010110011110001001