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 = $class->new(1); if ($x) { ok (1,1); } else { ok($x,'to be true') }
347 $x = $class->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 whether an opp calls objectify properly or not (or at least does what
388 # it should do given non-objects, w/ or w/o objectify())
390 ok ($class->new(123)->badd(123),246);
391 ok ($class->badd(123,321),444);
392 ok ($class->badd(123,$class->new(321)),444);
394 ok ($class->new(123)->bsub(122),1);
395 ok ($class->bsub(321,123),198);
396 ok ($class->bsub(321,$class->new(123)),198);
398 ok ($class->new(123)->bmul(123),15129);
399 ok ($class->bmul(123,123),15129);
400 ok ($class->bmul(123,$class->new(123)),15129);
402 ok ($class->new(15129)->bdiv(123),123);
403 ok ($class->bdiv(15129,123),123);
404 ok ($class->bdiv(15129,$class->new(123)),123);
406 ok ($class->new(15131)->bmod(123),2);
407 ok ($class->bmod(15131,123),2);
408 ok ($class->bmod(15131,$class->new(123)),2);
410 ok ($class->new(2)->bpow(16),65536);
411 ok ($class->bpow(2,16),65536);
412 ok ($class->bpow(2,$class->new(16)),65536);
414 ok ($class->new(2**15)->brsft(1),2**14);
415 ok ($class->brsft(2**15,1),2**14);
416 ok ($class->brsft(2**15,$class->new(1)),2**14);
418 ok ($class->new(2**13)->blsft(1),2**14);
419 ok ($class->blsft(2**13,1),2**14);
420 ok ($class->blsft(2**13,$class->new(1)),2**14);
422 ###############################################################################
423 # test for floating-point input (other tests in bnorm() below)
425 $z = 1050000000000000; # may be int on systems with 64bit?
426 $x = $class->new($z); ok ($x->bsstr(),'105e+13'); # not 1.05e+15
427 $z = 1e+129; # definitely a float (may fail on UTS)
428 # don't compare to $z, since some Perl versions stringify $z into something
429 # like '1.e+129' or something equally ugly
430 $x = $class->new($z); ok ($x->bsstr(),'1e+129');
432 ###############################################################################
433 # prime number tests, also test for **= and length()
434 # found on: http://www.utm.edu/research/primes/notes/by_year.html
437 $x = $class->new(2); $x **= 148; $x++; $x = $x / 17;
438 ok ($x,"20988936657440586486151264256610222593863921");
439 ok ($x->length(),length "20988936657440586486151264256610222593863921");
442 $x = $class->new(2); $x **= 127; $x--;
443 ok ($x,"170141183460469231731687303715884105727");
445 $x = $class->new('215960156869840440586892398248');
446 ($x,$y) = $x->length();
447 ok ($x,30); ok ($y,0);
449 $x = $class->new('1_000_000_000_000');
450 ($x,$y) = $x->length();
451 ok ($x,13); ok ($y,0);
453 # I am afraid the following is not yet possible due to slowness
454 # Also, testing for 2 meg output is a bit hard ;)
455 #$x = $class->new(2); $x **= 6972593; $x--;
457 # 593573509*2^332162+1 has exactly 1,000,000 digits
458 # takes about 24 mins on 300 Mhz, so cannot be done yet ;)
459 #$x = $class->new(2); $x **= 332162; $x *= "593573509"; $x++;
460 #ok ($x->length(),1_000_000);
462 ###############################################################################
463 # inheritance and overriding of _swap
465 $x = Math::Foo->new(5);
466 $x = $x - 8; # 8 - 5 instead of 5-8
468 ok (ref($x),'Math::Foo');
470 $x = Math::Foo->new(5);
471 $x = 8 - $x; # 5 - 8 instead of 8 - 5
473 ok (ref($x),'Math::Foo');
475 ###############################################################################
476 # Test whether +inf eq inf
477 # This tried to test whether BigInt inf equals Perl inf. Unfortunately, Perl
478 # hasn't (before 5.7.3 at least) a consistent way to say inf, and some things
479 # like 1e100000 crash on some platforms. So simple test for the string 'inf'
480 $x = $class->new('+inf'); ok ($x,'inf');
482 ###############################################################################
483 ###############################################################################
484 # the followin tests only make sense with Math::BigInt::Calc or BareCalc
486 exit if $CALC !~ /^Math::BigInt::(Calc|BareCalc)$/; # for Pari et al.
488 ###############################################################################
489 # check proper length of internal arrays
491 my $bl = $CL->_base_len();
492 my $BASE = '9' x $bl;
496 $x = $class->new($MAX); is_valid($x); # f.i. 9999
497 $x += 1; ok ($x,$BASE); is_valid($x); # 10000
498 $x -= 1; ok ($x,$MAX); is_valid($x); # 9999 again
500 ###############################################################################
503 $x = $class->new($BASE-1); ok ($x->numify(),$BASE-1);
504 $x = $class->new(-($BASE-1)); ok ($x->numify(),-($BASE-1));
506 # +0 is to protect from 1e15 vs 100000000 (stupid to_string aaaarglburblll...)
507 $x = $class->new($BASE); ok ($x->numify()+0,$BASE+0);
508 $x = $class->new(-$BASE); ok ($x->numify(),-$BASE);
509 $x = $class->new( -($BASE*$BASE*1+$BASE*1+1) );
510 ok($x->numify(),-($BASE*$BASE*1+$BASE*1+1));
512 ###############################################################################
513 # test bug in _digits with length($c[-1]) where $c[-1] was "00001" instead of 1
515 $x = $class->new($BASE-2); $x++; $x++; $x++; $x++;
516 if ($x > $BASE) { ok (1,1) } else { ok ("$x < $BASE","$x > $BASE"); }
518 $x = $class->new($BASE+3); $x++;
519 if ($x > $BASE) { ok (1,1) } else { ok ("$x > $BASE","$x < $BASE"); }
521 # test for +0 instead of int():
522 $x = $class->new($MAX); ok ($x->length(), length($MAX));
524 ###############################################################################
525 # test bug that $class->digit($string) did not work
527 ok ($class->digit(123,2),1);
529 ###############################################################################
530 # bug in sub where number with at least 6 trailing zeros after any op failed
532 $x = $class->new(123456); $z = $class->new(10000); $z *= 10; $x -= $z;
536 ###############################################################################
537 # bug in shortcut in mul()
539 # construct a number with a zero-hole of BASE_LEN_SMALL
541 my @bl = $CL->_base_len(); my $bl = $bl[4];
543 $x = '1' x $bl . '0' x $bl . '1' x $bl . '0' x $bl;
545 $x = $class->new($x)->bmul($y);
546 # result is 123..$bl . $bl x (3*bl-1) . $bl...321 . '0' x $bl
548 for (my $i = 1; $i <= $bl; $i++)
550 $y .= $i; $d = $i.$d;
552 $y .= $bl x (3*$bl-1) . $d . '0' x $bl;
556 #############################################################################
557 # see if mul shortcut for small numbers works
560 $x = $class->new($x);
561 # 999 * 999 => 998 . 001, 9999*9999 => 9998 . 0001
562 ok ($x*$x, '9' x ($bl-1) . '8' . '0' x ($bl-1) . '1');
565 ###############################################################################
566 # bug with rest "-0" in div, causing further div()s to fail
568 $x = $class->new('-322056000'); ($x,$y) = $x->bdiv('-12882240');
570 ok ($y,'0'); is_valid($y); # $y not '-0'
572 ###############################################################################
573 # bug in $x->bmod($y)
575 # if $x < 0 and $y > 0
576 $x = $class->new('-629'); ok ($x->bmod(5033),4404);
578 ###############################################################################
579 # bone/binf etc as plain calls (Lite failed them)
581 ok ($class->bzero(),0);
582 ok ($class->bone(),1);
583 ok ($class->bone('+'),1);
584 ok ($class->bone('-'),-1);
585 ok ($class->bnan(),'NaN');
586 ok ($class->binf(),'inf');
587 ok ($class->binf('+'),'inf');
588 ok ($class->binf('-'),'-inf');
589 ok ($class->binf('-inf'),'-inf');
591 ###############################################################################
596 ###############################################################################
597 ###############################################################################
598 # Perl 5.005 does not like ok ($x,undef)
604 ok (1,1) and return if !defined $x;
608 ###############################################################################
609 # sub to check validity of a BigInt internally, to ensure that no op leaves a
610 # number object in an invalid state (f.i. "-0")
618 # allow the check to pass for all Lite, and all MBI and subclasses
620 $e = 'Not a reference to Math::BigInt' if ref($x) !~ /^Math::BigInt/;
622 if (ref($x) ne 'Math::BigInt::Lite')
625 $e = "Illegal sign $x->{sign} (expected: '+', '-', '-inf', '+inf' or 'NaN'"
626 if $e eq '0' && $x->{sign} !~ /^(\+|-|\+inf|-inf|NaN)$/;
628 $e = "-0 is invalid!" if $e ne '0' && $x->{sign} eq '-' && $x == 0;
629 $e = $CALC->_check($x->{value}) if $e eq '0';
632 # test done, see if error did crop up
633 ok (1,1), return if ($e eq '0');
635 ok (1,$e." after op '$f'");
715 -123456789:+987654321:-1
716 +123456789:-987654321:-1
717 +987654321:+123456789:1
718 -987654321:+123456789:1
745 -12345678\n:-12345678
746 -123456789\n:-123456789
747 -1234567890\n:-1234567890
748 -12345678901\n:-12345678901
756 123456789\n:123456789
757 1234567890\n:1234567890
758 12345678901\n:12345678901
766 \n123456789:123456789
767 \n1234567890:1234567890
768 \n12345678901:12345678901
775 \n12345678\n:12345678
776 \n123456789\n:123456789
777 \n1234567890\n:1234567890
778 \n12345678901\n:12345678901
785 \t12345678\n:12345678
786 \t123456789\n:123456789
787 \t1234567890\n:1234567890
788 \t12345678901\n:12345678901
795 \n12345678\t:12345678
796 \n123456789\t:123456789
797 \n1234567890\t:1234567890
798 \n12345678901\t:12345678901
805 12345678\n\n:12345678
806 123456789\n\n:123456789
807 1234567890\n\n:1234567890
808 12345678901\n\n:12345678901
815 \n\n12345678:12345678
816 \n\n123456789:123456789
817 \n\n1234567890:1234567890
818 \n\n12345678901:12345678901
840 0b10000000000001:8193
841 0b100000000000001:16385
842 0b1000000000000001:32769
843 0b10000000000000001:65537
844 0b100000000000000001:131073
845 0b1000000000000000001:262145
846 0b10000000000000000001:524289
847 0b100000000000000000001:1048577
848 0b1000000000000000000001:2097153
849 0b10000000000000000000001:4194305
850 0b100000000000000000000001:8388609
851 0b1000000000000000000000001:16777217
852 0b10000000000000000000000001:33554433
853 0b100000000000000000000000001:67108865
854 0b1000000000000000000000000001:134217729
855 0b10000000000000000000000000001:268435457
856 0b100000000000000000000000000001:536870913
857 0b1000000000000000000000000000001:1073741825
858 0b10000000000000000000000000000001:2147483649
859 0b100000000000000000000000000000001:4294967297
860 0b1000000000000000000000000000000001:8589934593
861 0b10000000000000000000000000000000001:17179869185
873 0x1_2_3_4_56_78:305419896
874 0xa_b_c_d_e_f:11259375
903 0x40000001:1073741825
904 0x80000001:2147483649
905 0x100000001:4294967297
906 0x200000001:8589934593
907 0x400000001:17179869185
908 0x800000001:34359738369
922 # only one underscore between two digits
940 # bug with two E's in number beeing valid
944 # bug with two '.' in number beeing valid
968 01234567891:1234567891
969 012345678912:12345678912
970 0123456789123:123456789123
971 01234567891234:1234567891234
988 -123456789:-123456789
997 # floating point input
1005 # non-integer numbers
1044 # it must be exactly /^[+-]inf$/
1051 +1:+48:281474976710656
1054 +12345:4:10:123450000
1060 1234567890123:12:10:1234567890123000000000000
1064 -102533203:1:2:-205066406
1069 +281474976710656:+48:1
1080 1230000000000:10:10:123
1081 09876123456789067890:12:10:9876123
1082 1234561234567890123:13:10:123456
1083 820265627:1:2:410132813
1084 # test shifting negative numbers in base 2
1100 -1640531254:2:2:-410132814
1101 -1640531254:1:2:-820265627
1102 -820265627:1:2:-410132814
1103 -205066405:1:2:-102533203
1117 +123456789:-123456789
1118 -123456789:123456789
1126 +123456789:123456789
1127 -123456789:123456789
1152 -123456789:987654321:-1
1153 +123456789:-987654321:1
1154 -987654321:123456789:-1
1213 +9999999:+1:10000000
1214 +99999999:+1:100000000
1215 +999999999:+1:1000000000
1216 +9999999999:+1:10000000000
1217 +99999999999:+1:100000000000
1224 +10000000:-1:9999999
1225 +100000000:-1:99999999
1226 +1000000000:-1:999999999
1227 +10000000000:-1:9999999999
1228 +123456789:987654321:1111111110
1229 -123456789:987654321:864197532
1230 -123456789:-987654321:-1111111110
1231 +123456789:-987654321:-864197532
1235 -1:10000001:10000000
1236 -1:100000001:100000000
1237 -1:1000000001:1000000000
1238 -1:10000000001:10000000000
1239 -1:100000000001:100000000000
1240 -1:1000000000001:1000000000000
1241 -1:10000000000001:10000000000000
1244 -1:-1000001:-1000002
1245 -1:-10000001:-10000002
1246 -1:-100000001:-100000002
1247 -1:-1000000001:-1000000002
1248 -1:-10000000001:-10000000002
1249 -1:-100000000001:-100000000002
1250 -1:-1000000000001:-1000000000002
1251 -1:-10000000000001:-10000000000002
1276 +99999999:+1:99999998
1277 +999999999:+1:999999998
1278 +9999999999:+1:9999999998
1279 +99999999999:+1:99999999998
1286 +10000000:-1:10000001
1287 +100000000:-1:100000001
1288 +1000000000:-1:1000000001
1289 +10000000000:-1:10000000001
1290 +123456789:+987654321:-864197532
1291 -123456789:+987654321:-1111111110
1292 -123456789:-987654321:864197532
1293 +123456789:-987654321:1111111110
1298 100000001:1:100000000
1299 1000000001:1:1000000000
1300 10000000001:1:10000000000
1301 100000000001:1:100000000000
1302 1000000000001:1:1000000000000
1303 10000000000001:1:10000000000000
1307 10000001:-1:10000002
1308 100000001:-1:100000002
1309 1000000001:-1:1000000002
1310 10000000001:-1:10000000002
1311 100000000001:-1:100000000002
1312 1000000000001:-1:1000000000002
1313 10000000000001:-1:10000000000002
1331 123456789123456789:0:0
1332 0:123456789123456789:0
1342 10101:10101:102030201
1343 1001001:1001001:1002003002001
1344 100010001:100010001:10002000300020001
1345 10000100001:10000100001:100002000030000200001
1346 11111111111:9:99999999999
1347 22222222222:9:199999999998
1348 33333333333:9:299999999997
1349 44444444444:9:399999999996
1350 55555555555:9:499999999995
1351 66666666666:9:599999999994
1352 77777777777:9:699999999993
1353 88888888888:9:799999999992
1354 99999999999:9:899999999991
1356 +12345:+12345:152399025
1357 +99999:+11111:1111088889
1359 99999:100000:9999900000
1360 999999:1000000:999999000000
1361 9999999:10000000:99999990000000
1362 99999999:100000000:9999999900000000
1363 999999999:1000000000:999999999000000000
1364 9999999999:10000000000:99999999990000000000
1365 99999999999:100000000000:9999999999900000000000
1366 999999999999:1000000000000:999999999999000000000000
1367 9999999999999:10000000000000:99999999999990000000000000
1368 99999999999999:100000000000000:9999999999999900000000000000
1369 999999999999999:1000000000000000:999999999999999000000000000000
1370 9999999999999999:10000000000000000:99999999999999990000000000000000
1371 99999999999999999:100000000000000000:9999999999999999900000000000000000
1372 999999999999999999:1000000000000000000:999999999999999999000000000000000000
1373 9999999999999999999:10000000000000000000:99999999999999999990000000000000000000
1383 # inf handling and general remainder
1389 # see table in documentation in MBI
1408 # exceptions to reminder rule
1417 # inf handling (see table in doc)
1452 1000000000:9:111111111
1453 2000000000:9:222222222
1454 3000000000:9:333333333
1455 4000000000:9:444444444
1456 5000000000:9:555555555
1457 6000000000:9:666666666
1458 7000000000:9:777777777
1459 8000000000:9:888888888
1460 9000000000:9:1000000000
1463 106500000:339:314159
1464 1000000000:3:333333333
1469 999999999999:9:111111111111
1470 999999999999:99:10101010101
1471 999999999999:999:1001001001
1472 999999999999:9999:100010001
1473 999999999999999:99999:10000100001
1474 +1111088889:99999:11111
1489 # bug in Calc with '99999' vs $BASE-1
1490 10000000000000000000000000000000000000000000000000000000000000000000000000000000000:10000000375084540248994272022843165711074:999999962491547381984643365663244474111576
1492 # format: number:modulus:result
1493 # bmodinv Data errors
1497 # bmodinv Expected Results from normal use
1502 324958749843759385732954874325984357439658735983745:2348249874968739:1741662881064902
1503 ## bmodinv Error cases / useless use of function
1510 # format: number:exponent:modulus:result
1511 # bmodpow Data errors
1519 # bmodpow Expected results
1525 98436739867439843769485798542749827593285729587325:43698764986460981048259837659386739857456983759328457:6943857329857295827698367:3104744730915914415259518
1526 # bmodpow Error cases
1532 # inf handling, see table in doc
1551 # exceptions to reminder rule
1590 999999999999999:99999:0
1604 152403346:12345:4321
1606 # test shortcuts in Calc
1607 # 1ex % 9 is always == 1, 1ex % 113 is != 1 for x = (4..9), 1ex % 10 = 0
1614 1234567891234567:9:1
1615 123456789123456789:9:0
1622 1234567891234567:10:7
1623 123456789123456789:10:9
1629 12345678912345:113:53
1630 1234567891234567:113:56
1631 123456789123456789:113:39
1632 # bug in bmod() not modifying the variable in place
1666 +281474976710656:0:0
1667 +281474976710656:1:0
1668 +281474976710656:+281474976710656:281474976710656
1675 # equal arguments are treated special, so also do some test with unequal ones
1676 0xFFFF:0xFFFF:0x0xFFFF
1677 0xFFFFFF:0xFFFFFF:0x0xFFFFFF
1678 0xFFFFFFFF:0xFFFFFFFF:0x0xFFFFFFFF
1679 0xFFFFFFFFFF:0xFFFFFFFFFF:0x0xFFFFFFFFFF
1680 0xFFFFFFFFFFFF:0xFFFFFFFFFFFF:0x0xFFFFFFFFFFFF
1681 0xF0F0:0xF0F0:0x0xF0F0
1682 0x0F0F:0x0F0F:0x0x0F0F
1683 0xF0F0F0:0xF0F0F0:0x0xF0F0F0
1684 0x0F0F0F:0x0F0F0F:0x0x0F0F0F
1685 0xF0F0F0F0:0xF0F0F0F0:0x0xF0F0F0F0
1686 0x0F0F0F0F:0x0F0F0F0F:0x0x0F0F0F0F
1687 0xF0F0F0F0F0:0xF0F0F0F0F0:0x0xF0F0F0F0F0
1688 0x0F0F0F0F0F:0x0F0F0F0F0F:0x0x0F0F0F0F0F
1689 0xF0F0F0F0F0F0:0xF0F0F0F0F0F0:0x0xF0F0F0F0F0F0
1690 0x0F0F0F0F0F0F:0x0F0F0F0F0F0F:0x0x0F0F0F0F0F0F
1691 0x1F0F0F0F0F0F:0x3F0F0F0F0F0F:0x0x1F0F0F0F0F0F
1698 +281474976710656:0:281474976710656
1699 +281474976710656:1:281474976710657
1700 +281474976710656:281474976710656:281474976710656
1706 # equal arguments are treated special, so also do some test with unequal ones
1707 0xFFFF:0xFFFF:0x0xFFFF
1708 0xFFFFFF:0xFFFFFF:0x0xFFFFFF
1709 0xFFFFFFFF:0xFFFFFFFF:0x0xFFFFFFFF
1710 0xFFFFFFFFFF:0xFFFFFFFFFF:0x0xFFFFFFFFFF
1711 0xFFFFFFFFFFFF:0xFFFFFFFFFFFF:0x0xFFFFFFFFFFFF
1713 0:0xFFFFFF:0x0xFFFFFF
1714 0:0xFFFFFFFF:0x0xFFFFFFFF
1715 0:0xFFFFFFFFFF:0x0xFFFFFFFFFF
1716 0:0xFFFFFFFFFFFF:0x0xFFFFFFFFFFFF
1718 0xFFFFFF:0:0x0xFFFFFF
1719 0xFFFFFFFF:0:0x0xFFFFFFFF
1720 0xFFFFFFFFFF:0:0x0xFFFFFFFFFF
1721 0xFFFFFFFFFFFF:0:0x0xFFFFFFFFFFFF
1722 0xF0F0:0xF0F0:0x0xF0F0
1723 0x0F0F:0x0F0F:0x0x0F0F
1724 0xF0F0:0x0F0F:0x0xFFFF
1725 0xF0F0F0:0xF0F0F0:0x0xF0F0F0
1726 0x0F0F0F:0x0F0F0F:0x0x0F0F0F
1727 0x0F0F0F:0xF0F0F0:0x0xFFFFFF
1728 0xF0F0F0F0:0xF0F0F0F0:0x0xF0F0F0F0
1729 0x0F0F0F0F:0x0F0F0F0F:0x0x0F0F0F0F
1730 0x0F0F0F0F:0xF0F0F0F0:0x0xFFFFFFFF
1731 0xF0F0F0F0F0:0xF0F0F0F0F0:0x0xF0F0F0F0F0
1732 0x0F0F0F0F0F:0x0F0F0F0F0F:0x0x0F0F0F0F0F
1733 0x0F0F0F0F0F:0xF0F0F0F0F0:0x0xFFFFFFFFFF
1734 0xF0F0F0F0F0F0:0xF0F0F0F0F0F0:0x0xF0F0F0F0F0F0
1735 0x0F0F0F0F0F0F:0x0F0F0F0F0F0F:0x0x0F0F0F0F0F0F
1736 0x0F0F0F0F0F0F:0xF0F0F0F0F0F0:0x0xFFFFFFFFFFFF
1737 0x1F0F0F0F0F0F:0xF0F0F0F0F0F0:0x0xFFFFFFFFFFFF
1744 +281474976710656:0:281474976710656
1745 +281474976710656:1:281474976710657
1746 +281474976710656:281474976710656:0
1754 # equal arguments are treated special, so also do some test with unequal ones
1757 0xFFFFFFFF:0xFFFFFFFF:0
1758 0xFFFFFFFFFF:0xFFFFFFFFFF:0
1759 0xFFFFFFFFFFFF:0xFFFFFFFFFFFF:0
1761 0:0xFFFFFF:0x0xFFFFFF
1762 0:0xFFFFFFFF:0x0xFFFFFFFF
1763 0:0xFFFFFFFFFF:0x0xFFFFFFFFFF
1764 0:0xFFFFFFFFFFFF:0x0xFFFFFFFFFFFF
1766 0xFFFFFF:0:0x0xFFFFFF
1767 0xFFFFFFFF:0:0x0xFFFFFFFF
1768 0xFFFFFFFFFF:0:0x0xFFFFFFFFFF
1769 0xFFFFFFFFFFFF:0:0x0xFFFFFFFFFFFF
1772 0xF0F0:0x0F0F:0x0xFFFF
1775 0x0F0F0F:0xF0F0F0:0x0xFFFFFF
1776 0xF0F0F0F0:0xF0F0F0F0:0
1777 0x0F0F0F0F:0x0F0F0F0F:0
1778 0x0F0F0F0F:0xF0F0F0F0:0x0xFFFFFFFF
1779 0xF0F0F0F0F0:0xF0F0F0F0F0:0
1780 0x0F0F0F0F0F:0x0F0F0F0F0F:0
1781 0x0F0F0F0F0F:0xF0F0F0F0F0:0x0xFFFFFFFFFF
1782 0xF0F0F0F0F0F0:0xF0F0F0F0F0F0:0
1783 0x0F0F0F0F0F0F:0x0F0F0F0F0F0F:0
1784 0x0F0F0F0F0F0F:0xF0F0F0F0F0F0:0x0xFFFFFFFFFFFF
1789 +281474976710656:-281474976710657
1884 -inf:1234500012:-inf
1885 +inf:-12345000123:inf
1886 -inf:-12345000123:-inf
1887 # 1 ** -x => 1 / (1 ** x)
1907 10:20:100000000000000000000
1908 123456:2:15241383936
1915 10000000000000000:17
1917 215960156869840440586892398248:30
1933 4000000000000:2000000
1944 $round_mode('trunc')
1954 +10123456789:5:10123000000
1955 -10123456789:5:-10123000000
1956 +10123456789:9:10123456700
1957 -10123456789:9:-10123456700
1958 +101234500:6:101234000
1959 -101234500:6:-101234000
1960 #+101234500:-4:101234000
1961 #-101234500:-4:-101234000
1963 +20123456789:5:20123000000
1964 -20123456789:5:-20123000000
1965 +20123456789:9:20123456800
1966 -20123456789:9:-20123456800
1967 +201234500:6:201234000
1968 -201234500:6:-201234000
1969 #+201234500:-4:201234000
1970 #-201234500:-4:-201234000
1971 +12345000:4:12340000
1972 -12345000:4:-12340000
1974 +30123456789:5:30123000000
1975 -30123456789:5:-30123000000
1976 +30123456789:9:30123456800
1977 -30123456789:9:-30123456800
1978 +301234500:6:301235000
1979 -301234500:6:-301234000
1980 #+301234500:-4:301235000
1981 #-301234500:-4:-301234000
1982 +12345000:4:12350000
1983 -12345000:4:-12340000
1985 +40123456789:5:40123000000
1986 -40123456789:5:-40123000000
1987 +40123456789:9:40123456800
1988 -40123456789:9:-40123456800
1989 +401234500:6:401234000
1990 +401234500:6:401234000
1991 #-401234500:-4:-401235000
1992 #-401234500:-4:-401235000
1993 +12345000:4:12340000
1994 -12345000:4:-12350000
1996 +50123456789:5:50123000000
1997 -50123456789:5:-50123000000
1998 +50123456789:9:50123456800
1999 -50123456789:9:-50123456800
2000 +501234500:6:501235000
2001 -501234500:6:-501235000
2002 #+501234500:-4:501235000
2003 #-501234500:-4:-501235000
2004 +12345000:4:12350000
2005 -12345000:4:-12350000
2007 +60123456789:5:60123000000
2008 -60123456789:5:-60123000000
2009 +60123456789:9:60123456800
2010 -60123456789:9:-60123456800
2011 +601234500:6:601234000
2012 -601234500:6:-601234000
2013 #+601234500:-4:601234000
2014 #-601234500:-4:-601234000
2021 +12345000:4:12340000
2022 -12345000:4:-12340000
2040 # floor and ceil tests are pretty pointless in integer space...but play safe
2067 0x123456789123456789:0x123456789123456789
2077 0b1010111101010101010110110110110110101:0b1010111101010101010110110110110110101
2078 0x123456789123456789:0b100100011010001010110011110001001000100100011010001010110011110001001