This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
Upgrade Math::BigInt from 1.999701 to 1.999704
[perl5.git] / cpan / Math-BigInt / t / bigintpm.inc
1 #include this file into another for subclass testing
2
3 my $version = ${"$class\::VERSION"};
4
5 use strict;
6
7 ##############################################################################
8 # for testing inheritance of _swap
9
10 package Math::Foo;
11
12 use Math::BigInt lib => $main::CL;
13 use vars qw/@ISA/;
14 @ISA = (qw/Math::BigInt/);
15
16 use overload
17 # customized overload for sub, since original does not use swap there
18 '-'     =>      sub { my @a = ref($_[0])->_swap(@_);
19                    $a[0]->bsub($a[1])};
20
21 sub _swap
22   {
23   # a fake _swap, which reverses the params
24   my $self = shift;                     # for override in subclass
25   if ($_[2])
26     {
27     my $c = ref ($_[0] ) || 'Math::Foo';
28     return ( $_[0]->copy(), $_[1] );
29     }
30   else
31     {
32     return ( Math::Foo->new($_[1]), $_[0] );
33     }
34   }
35
36 ##############################################################################
37 package main;
38
39 my $CALC = $class->config()->{lib}; is ($CALC,$CL);
40
41 my ($f,$z,$a,$exp,@a,$m,$e,$round_mode,$expected_class);
42
43 while (<DATA>) 
44   {
45   $_ =~ s/[\n\r]//g;    # remove newlines
46   next if /^#/; # skip comments
47   if (s/^&//) 
48     {
49     $f = $_; next;
50     }
51   elsif (/^\$/) 
52     {
53     $round_mode = $_; $round_mode =~ s/^\$/$class\->/; next;
54     }
55
56   @args = split(/:/,$_,99); $ans = pop(@args);
57   $expected_class = $class;
58   if ($ans =~ /(.*?)=(.*)/)
59     {
60     $expected_class = $2; $ans = $1;
61     }
62   $try = "\$x = $class->new(\"$args[0]\");";
63   if ($f eq "bnorm")
64     {
65     $try = "\$x = $class->bnorm(\"$args[0]\");";
66   # some is_xxx tests
67    } elsif ($f =~ /^is_(zero|one|odd|even|negative|positive|nan|int)$/) {
68     $try .= "\$x->$f() || 0;";
69    } elsif ($f eq "is_inf") {
70     $try .= "\$x->is_inf('$args[1]');";
71    } elsif ($f eq "binf") {
72     $try .= "\$x->binf('$args[1]');";
73    } elsif ($f eq "bone") {
74     $try .= "\$x->bone('$args[1]');";
75   # some unary ops
76    } elsif ($f =~ /^b(nan|floor|ceil|int|sstr|neg|abs|sgn|inc|dec|not|sqrt|fac)$/) {
77     $try .= "\$x->$f();";
78   # overloaded functions
79    } elsif ($f =~ /^(log|exp|sin|cos|atan2|int|neg|abs|sqrt)$/) {
80     $try .= "\$x = $f(\$x);";
81    } elsif ($f =~ /^(numify|length|stringify|as_hex|as_bin)$/) {
82     $try .= "\$x->$f();";
83    } elsif ($f eq "exponent"){
84     # ->bstr() to see if an object is returned
85     $try .= '$x = $x->exponent()->bstr();';
86    } elsif ($f eq "mantissa"){
87     # ->bstr() to see if an object is returned
88     $try .= '$x = $x->mantissa()->bstr();';
89    } elsif ($f eq "parts"){
90     $try .= '($m,$e) = $x->parts();'; 
91     # ->bstr() to see if an object is returned
92     $try .= '$m = $m->bstr(); $m = "NaN" if !defined $m;';
93     $try .= '$e = $e->bstr(); $e = "NaN" if !defined $e;';
94     $try .= '"$m,$e";';
95    }elsif ($f eq "bexp"){
96     $try .= "\$x->bexp();";
97    } elsif ($f eq "bpi"){
98     $try .= "$class\->bpi(\$x);";
99    } else {
100     # binary ops
101     $try .= "\$y = $class->new('$args[1]');";
102     if ($f eq "bcmp")
103       {
104       $try .= '$x->bcmp($y);';
105       } elsif ($f eq "bround") {
106       $try .= "$round_mode; \$x->bround(\$y);";
107       } elsif ($f eq "bacmp"){
108       $try .= '$x->bacmp($y);';
109       } elsif ($f eq "badd"){
110       $try .= '$x + $y;';
111       } elsif ($f eq "bsub"){
112       $try .= '$x - $y;';
113       } elsif ($f eq "bmul"){
114       $try .= '$x * $y;';
115       } elsif ($f eq "bdiv"){
116       $try .= '$x / $y;';
117       } elsif ($f eq "bdiv-list"){
118       $try .= 'join (",",$x->bdiv($y));';
119       # overload via x=
120       } elsif ($f =~ /^.=$/){
121       $try .= "\$x $f \$y;";
122       # overload via x
123       } elsif ($f =~ /^.$/){
124       $try .= "\$x $f \$y;";
125       } elsif ($f eq "bmod"){
126       $try .= '$x % $y;';
127       } elsif ($f eq "bgcd")
128         {
129         if (defined $args[2])
130           {
131           $try .= " \$z = $class->new('$args[2]'); ";
132           }
133         $try .= "$class\::bgcd(\$x, \$y";
134         $try .= ", \$z" if (defined $args[2]);
135         $try .= " );";
136         }
137       elsif ($f eq "blcm")
138         {
139         if (defined $args[2])
140           {
141           $try .= " \$z = $class->new('$args[2]'); ";
142           }
143         $try .= "$class\::blcm(\$x, \$y";
144         $try .= ", \$z" if (defined $args[2]);
145         $try .= " );";
146       }elsif ($f eq "blsft"){
147         if (defined $args[2])
148           {
149           $try .= "\$x->blsft(\$y,$args[2]);";
150           }
151         else
152           {
153           $try .= "\$x << \$y;";
154           }
155       }elsif ($f eq "brsft"){
156         if (defined $args[2])
157           {
158           $try .= "\$x->brsft(\$y,$args[2]);";
159           }
160         else
161           {
162           $try .= "\$x >> \$y;";
163           }
164       }elsif ($f eq "bnok"){
165         $try .= "\$x->bnok(\$y);";
166       }elsif ($f eq "broot"){
167         $try .= "\$x->broot(\$y);";
168       }elsif ($f eq "blog"){
169         $try .= "\$x->blog(\$y);";
170       }elsif ($f eq "band"){
171         $try .= "\$x & \$y;";
172       }elsif ($f eq "bior"){
173         $try .= "\$x | \$y;";
174       }elsif ($f eq "bxor"){
175         $try .= "\$x ^ \$y;";
176       }elsif ($f eq "bpow"){
177         $try .= "\$x ** \$y;";
178       } elsif( $f eq "bmodinv") {
179        $try .= "\$x->bmodinv(\$y);";
180       }elsif ($f eq "digit"){
181         $try .= "\$x->digit(\$y);";
182       }elsif ($f eq "batan2"){
183         $try .= "\$x->batan2(\$y);";
184       } else {
185        # Functions with three arguments
186        $try .= "\$z = $class->new(\"$args[2]\");";
187
188        if( $f eq "bmodpow") {
189          $try .= "\$x->bmodpow(\$y,\$z);";
190       } elsif ($f eq "bmuladd"){
191          $try .= "\$x->bmuladd(\$y,\$z);";
192        } else { warn "Unknown op '$f'"; }
193       }
194     } # end else all other ops
195
196   $ans1 = eval $try;
197   # convert hex/binary targets to decimal       
198   if ($ans =~ /^(0x0x|0b0b)/)
199     {
200     $ans =~ s/^0[xb]//; $ans = Math::BigInt->new($ans)->bstr();
201     }
202   if ($ans eq "")
203     {
204       is ($ans1, undef); 
205     }
206   else
207     {
208     # print "try: $try ans: $ans1 $ans\n";
209     print "# Tried: '$try'\n" if !is ($ans1, $ans);
210     is (ref($ans),$expected_class) if $expected_class ne $class;
211     }
212   # check internal state of number objects
213   is_valid($ans1,$f) if ref $ans1; 
214   } # endwhile data tests
215 close DATA;
216
217 # test some more
218 @a = ();
219 for (my $i = 1; $i < 10; $i++) 
220   {
221   push @a, $i;
222   }
223 is("@a", "1 2 3 4 5 6 7 8 9");
224
225 # test whether self-multiplication works correctly (result is 2**64)
226 $try = "\$x = $class->new('4294967296');";
227 $try .= '$a = $x->bmul($x);';
228 $ans1 = eval $try;
229 print "# Tried: '$try'\n" if !is ($ans1, $class->new(2) ** 64);
230 # test self-pow
231 $try = "\$x = $class->new(10);";
232 $try .= '$a = $x->bpow($x);';
233 $ans1 = eval $try;
234 print "# Tried: '$try'\n" if !is ($ans1, $class->new(10) ** 10);
235
236 ###############################################################################
237 # test whether op destroys args or not (should better not)
238
239 $x = $class->new(3);
240 $y = $class->new(4);
241 $z = $x & $y;
242 is ($x,3);
243 is ($y,4);
244 is ($z,0);
245 $z = $x | $y;
246 is ($x,3);
247 is ($y,4);
248 is ($z,7);
249 $x = $class->new(1);
250 $y = $class->new(2);
251 $z = $x | $y;
252 is ($x,1);
253 is ($y,2);
254 is ($z,3);
255
256 $x = $class->new(5);
257 $y = $class->new(4);
258 $z = $x ^ $y;
259 is ($x,5);
260 is ($y,4);
261 is ($z,1);
262
263 $x = $class->new(-5); $y = -$x;
264 is ($x, -5);
265
266 $x = $class->new(-5); $y = abs($x);
267 is ($x, -5);
268
269 $x = $class->new(8);
270 $y = $class->new(-1);
271 $z = $class->new(5033);
272 my $u = $x->copy()->bmodpow($y,$z);
273 is ($u,4404);
274 is ($y,-1);
275 is ($z,5033);
276
277 $x = $class->new(-5); $y = -$x; is ($x,-5); is ($y,5);
278 $x = $class->new(-5); $y = $x->copy()->bneg(); is ($x,-5); is ($y,5);
279
280 $x = $class->new(-5); $y = $class->new(3); $x->bmul($y); is ($x,-15); is ($y,3);
281 $x = $class->new(-5); $y = $class->new(3); $x->badd($y); is ($x,-2); is ($y,3);
282 $x = $class->new(-5); $y = $class->new(3); $x->bsub($y); is ($x,-8); is ($y,3);
283 $x = $class->new(-15); $y = $class->new(3); $x->bdiv($y); is ($x,-5); is ($y,3);
284 $x = $class->new(-5); $y = $class->new(3); $x->bmod($y); is ($x,1); is ($y,3);
285
286 $x = $class->new(5); $y = $class->new(3); $x->bmul($y); is ($x,15); is ($y,3);
287 $x = $class->new(5); $y = $class->new(3); $x->badd($y); is ($x,8); is ($y,3);
288 $x = $class->new(5); $y = $class->new(3); $x->bsub($y); is ($x,2); is ($y,3);
289 $x = $class->new(15); $y = $class->new(3); $x->bdiv($y); is ($x,5); is ($y,3);
290 $x = $class->new(5); $y = $class->new(3); $x->bmod($y); is ($x,2); is ($y,3);
291
292 $x = $class->new(5); $y = $class->new(-3); $x->bmul($y); is ($x,-15); is ($y,-3);
293 $x = $class->new(5); $y = $class->new(-3); $x->badd($y); is ($x,2); is ($y,-3);
294 $x = $class->new(5); $y = $class->new(-3); $x->bsub($y); is ($x,8); is ($y,-3);
295 $x = $class->new(15); $y = $class->new(-3); $x->bdiv($y); is ($x,-5); is ($y,-3);
296 $x = $class->new(5); $y = $class->new(-3); $x->bmod($y); is ($x,-1); is ($y,-3);
297
298 ###############################################################################
299 # check whether overloading cmp works
300 $try = "\$x = $class->new(0);";
301 $try .= "\$y = 10;";
302 $try .= "'false' if \$x ne \$y;";
303 $ans = eval $try;
304 print "# For '$try'\n" if (!is ("$ans" , "false") );
305
306 # we cant test for working cmpt with other objects here, we would need a dummy
307 # object with stringify overload for this. see Math::String tests as example
308
309 ###############################################################################
310 # check reversed order of arguments
311
312 $try = "\$x = $class->new(10); \$x = 2 ** \$x;";
313 $try .= "'ok' if \$x == 1024;"; $ans = eval $try;
314 print "# For '$try'\n" if (!ok "$ans" , "ok" ); 
315
316 $try = "\$x = $class->new(10); \$x = 2 * \$x;";
317 $try .= "'ok' if \$x == 20;"; $ans = eval $try;
318 print "# For '$try'\n" if (!ok "$ans" , "ok" ); 
319
320 $try = "\$x = $class->new(10); \$x = 2 + \$x;";
321 $try .= "'ok' if \$x == 12;"; $ans = eval $try;
322 print "# For '$try'\n" if (!ok "$ans" , "ok" ); 
323
324 $try = "\$x = $class\->new(10); \$x = 2 - \$x;";
325 $try .= "'ok' if \$x == -8;"; $ans = eval $try;
326 print "# For '$try'\n" if (!ok "$ans" , "ok" ); 
327
328 $try = "\$x = $class\->new(10); \$x = 20 / \$x;";
329 $try .= "'ok' if \$x == 2;"; $ans = eval $try;
330 print "# For '$try'\n" if (!ok "$ans" , "ok" ); 
331
332 $try = "\$x = $class\->new(3); \$x = 20 % \$x;";
333 $try .= "'ok' if \$x == 2;"; $ans = eval $try;
334 print "# For '$try'\n" if (!ok "$ans" , "ok" ); 
335
336 $try = "\$x = $class\->new(7); \$x = 20 & \$x;";
337 $try .= "'ok' if \$x == 4;"; $ans = eval $try;
338 print "# For '$try'\n" if (!ok "$ans" , "ok" ); 
339
340 $try = "\$x = $class\->new(7); \$x = 0x20 | \$x;";
341 $try .= "'ok' if \$x == 0x27;"; $ans = eval $try;
342 print "# For '$try'\n" if (!ok "$ans" , "ok" ); 
343
344 $try = "\$x = $class\->new(7); \$x = 0x20 ^ \$x;";
345 $try .= "'ok' if \$x == 0x27;"; $ans = eval $try;
346 print "# For '$try'\n" if (!ok "$ans" , "ok" ); 
347
348 ###############################################################################
349 # check badd(4,5) form
350
351 $try = "\$x = $class\->badd(4,5);";
352 $try .= "'ok' if \$x == 9;";
353 $ans = eval $try;
354 print "# For '$try'\n" if (!ok "$ans" , "ok" ); 
355
356 ###############################################################################
357 # check undefs: NOT DONE YET
358
359 ###############################################################################
360 # bool
361
362 $x = $class->new(1); if ($x) { is (1,1); } else { is ($x,'to be true') }
363 $x = $class->new(0); if (!$x) { is (1,1); } else { is ($x,'to be false') }
364
365 ###############################################################################
366 # objectify()
367
368 @args = Math::BigInt::objectify(2,4,5);
369 is (scalar @args,3);            # $class, 4, 5
370 like ($args[0], qr/^Math::BigInt/);
371 is ($args[1],4);
372 is ($args[2],5);
373
374 @args = Math::BigInt::objectify(0,4,5);
375 is (scalar @args,3);            # $class, 4, 5
376 like ($args[0], qr/^Math::BigInt/);
377 is ($args[1],4);
378 is ($args[2],5);
379
380 @args = Math::BigInt::objectify(2,4,5);
381 is (scalar @args,3);            # $class, 4, 5
382 like ($args[0], qr/^Math::BigInt/);
383 is ($args[1],4);
384 is ($args[2],5);
385
386 @args = Math::BigInt::objectify(2,4,5,6,7);
387 is (scalar @args,5);            # $class, 4, 5, 6, 7
388 like ($args[0], qr/^Math::BigInt/);
389 is ($args[1],4); is (ref($args[1]),$args[0]);
390 is ($args[2],5); is (ref($args[2]),$args[0]);
391 is ($args[3],6); is (ref($args[3]),'');
392 is ($args[4],7); is (ref($args[4]),'');
393
394 @args = Math::BigInt::objectify(2,$class,4,5,6,7);
395 is (scalar @args,5);            # $class, 4, 5, 6, 7
396 is ($args[0],$class);
397 is ($args[1],4); is (ref($args[1]),$args[0]);
398 is ($args[2],5); is (ref($args[2]),$args[0]);
399 is ($args[3],6); is (ref($args[3]),'');
400 is ($args[4],7); is (ref($args[4]),'');
401
402 ###############################################################################
403 # test whether an opp calls objectify properly or not (or at least does what
404 # it should do given non-objects, w/ or w/o objectify())
405
406 is ($class->new(123)->badd(123),246);
407 is ($class->badd(123,321),444);
408 is ($class->badd(123,$class->new(321)),444);
409
410 is ($class->new(123)->bsub(122),1);
411 is ($class->bsub(321,123),198);
412 is ($class->bsub(321,$class->new(123)),198);
413
414 is ($class->new(123)->bmul(123),15129);
415 is ($class->bmul(123,123),15129);
416 is ($class->bmul(123,$class->new(123)),15129);
417
418 is ($class->new(15129)->bdiv(123),123);
419 is ($class->bdiv(15129,123),123);
420 is ($class->bdiv(15129,$class->new(123)),123);
421
422 is ($class->new(15131)->bmod(123),2);
423 is ($class->bmod(15131,123),2);
424 is ($class->bmod(15131,$class->new(123)),2);
425
426 is ($class->new(2)->bpow(16),65536);
427 is ($class->bpow(2,16),65536);
428 is ($class->bpow(2,$class->new(16)),65536);
429
430 is ($class->new(2**15)->brsft(1),2**14);
431 is ($class->brsft(2**15,1),2**14);
432 is ($class->brsft(2**15,$class->new(1)),2**14);
433
434 is ($class->new(2**13)->blsft(1),2**14);
435 is ($class->blsft(2**13,1),2**14);
436 is ($class->blsft(2**13,$class->new(1)),2**14);
437
438 ###############################################################################
439 # test for floating-point input (other tests in bnorm() below)
440
441 $z = 1050000000000000;          # may be int on systems with 64bit?
442 $x = $class->new($z); is ($x->bsstr(),'105e+13');       # not 1.05e+15
443 $z = 1e+129;                    # definitely a float (may fail on UTS)
444 # don't compare to $z, since some Perl versions stringify $z into something
445 # like '1.e+129' or something equally ugly
446 $x = $class->new($z); is ($x->bsstr(),'1e+129');
447
448 ###############################################################################
449 # test for whitespace including newlines to be handled correctly
450
451 # is ($Math::BigInt::strict,1);         # the default
452
453 foreach my $c (
454   qw/1 12 123 1234 12345 123456 1234567 12345678 123456789 1234567890/)
455   {
456   my $m = $class->new($c);
457   is ($class->new("$c"),$m);
458   is ($class->new(" $c"),$m);
459   is ($class->new("$c "),$m);
460   is ($class->new(" $c "),$m);
461   is ($class->new("\n$c"),$m);
462   is ($class->new("$c\n"),$m);
463   is ($class->new("\n$c\n"),$m);
464   is ($class->new(" \n$c\n"),$m);
465   is ($class->new(" \n$c \n"),$m);
466   is ($class->new(" \n$c\n "),$m);
467   is ($class->new(" \n$c\n1"),'NaN');
468   is ($class->new("1 \n$c\n1"),'NaN');
469   }
470
471 ###############################################################################
472 # prime number tests, also test for **= and length()
473 # found on: http://www.utm.edu/research/primes/notes/by_year.html
474
475 # ((2^148)-1)/17
476 $x = $class->new(2); $x **= 148; $x++; $x = $x / 17;
477 is ($x,"20988936657440586486151264256610222593863921");
478 is ($x->length(),length "20988936657440586486151264256610222593863921");
479
480 # MM7 = 2^127-1
481 $x = $class->new(2); $x **= 127; $x--;
482 is ($x,"170141183460469231731687303715884105727");
483
484 $x = $class->new('215960156869840440586892398248');
485 ($x,$y) = $x->length();
486 is ($x,30); is ($y,0);
487
488 $x = $class->new('1_000_000_000_000');
489 ($x,$y) = $x->length();
490 is ($x,13); is ($y,0);
491
492 # test <<=, >>=
493 $x = $class->new('2');
494 my $y = $class->new('18');
495 is ($x <<= $y, 2 << 18);
496 is ($x, 2 << 18);
497 is ($x >>= $y, 2);
498 is ($x, 2);
499
500 # I am afraid the following is not yet possible due to slowness
501 # Also, testing for 2 meg output is a bit hard ;)
502 #$x = $class->new(2); $x **= 6972593; $x--;
503
504 # 593573509*2^332162+1 has exactly 1,000,000 digits
505 # takes about 24 mins on 300 Mhz, so cannot be done yet ;)
506 #$x = $class->new(2); $x **= 332162; $x *= "593573509"; $x++;
507 #is ($x->length(),1_000_000);
508
509 ###############################################################################
510 # inheritance and overriding of _swap
511
512 $x = Math::Foo->new(5);
513 $x = $x - 8;            # 8 - 5 instead of 5-8
514 is ($x,3);
515 is (ref($x),'Math::Foo');
516
517 $x = Math::Foo->new(5);
518 $x = 8 - $x;            # 5 - 8 instead of 8 - 5
519 is ($x,-3);
520 is (ref($x),'Math::Foo');
521
522 ###############################################################################
523 # Test whether +inf eq inf
524 # This tried to test whether BigInt inf equals Perl inf. Unfortunately, Perl
525 # hasn't (before 5.7.3 at least) a consistent way to say inf, and some things
526 # like 1e100000 crash on some platforms. So simple test for the string 'inf'
527 $x = $class->new('+inf'); is ($x,'inf');
528
529 ###############################################################################
530 # numify() and 64 bit integer support
531
532 require Config;
533 SKIP: {
534     skip("no 64 bit integer support", 4)
535       unless $Config::Config{use64bitint} || $Config::Config{use64bitall};
536
537     # The following should not give "1.84467440737096e+19".
538
539     $x = $class -> new(2) -> bpow(64) -> bdec();
540     is($x -> bstr(),   "18446744073709551615", "bigint 2**64-1 as string");
541     is($x -> numify(), "18446744073709551615", "bigint 2**64-1 as number");
542
543     # The following should not give "-9.22337203685478e+18".
544
545     $x = $class -> new(2) -> bpow(63) -> bneg();
546     is($x -> bstr(),   "-9223372036854775808", "bigint -2**63 as string");
547     is($x -> numify(), "-9223372036854775808", "bigint -2**63 as number");
548 };
549
550 ###############################################################################
551 ###############################################################################
552 # the following tests only make sense with Math::BigInt::Calc or BareCalc or
553 # FastCalc
554
555 SKIP: {
556     # skip GMP, Pari et al.
557     skip("skipping tests not intended for the backend $CALC", 50)
558       unless $CALC =~ /^Math::BigInt::(Bare|Fast)?Calc$/;
559
560     ###########################################################################
561     # check proper length of internal arrays
562
563     my $bl = $CL->_base_len();
564     my $BASE = '9' x $bl;
565     my $MAX = $BASE;
566     $BASE++;
567
568     $x = $class->new($MAX); is_valid($x);       # f.i. 9999
569     $x += 1; is ($x,$BASE); is_valid($x);       # 10000
570     $x -= 1; is ($x,$MAX); is_valid($x);        # 9999 again
571
572     ###########################################################################
573     # check numify
574
575     $x = $class->new($BASE-1);     is ($x->numify(),$BASE-1); 
576     $x = $class->new(-($BASE-1));  is ($x->numify(),-($BASE-1)); 
577
578     # +0 is to protect from 1e15 vs 100000000 (stupid to_string aaaarglburblll...)
579     $x = $class->new($BASE);       is ($x->numify()+0,$BASE+0);         
580     $x = $class->new(-$BASE);      is ($x->numify(),-$BASE);
581     $x = $class->new( -($BASE*$BASE*1+$BASE*1+1) ); 
582     is ($x->numify(),-($BASE*$BASE*1+$BASE*1+1));
583
584     ###########################################################################
585     # test bug in _digits with length($c[-1]) where $c[-1] was "00001" instead of 1
586
587     $x = $class->new($BASE-2); $x++; $x++; $x++; $x++;
588     if ($x > $BASE) { is (1,1) } else { is ("$x < $BASE","$x > $BASE"); }
589
590     $x = $class->new($BASE+3); $x++;
591     if ($x > $BASE) { is (1,1) } else { is ("$x > $BASE","$x < $BASE"); }
592
593     # test for +0 instead of int(): 
594     $x = $class->new($MAX); is ($x->length(), length($MAX));
595
596     ###########################################################################
597     # test bug that $class->digit($string) did not work
598
599     is ($class->digit(123,2),1);
600
601     ###########################################################################
602     # bug in sub where number with at least 6 trailing zeros after any op failed
603
604     $x = $class->new(123456); $z = $class->new(10000); $z *= 10; $x -= $z;
605     is ($z, 100000);
606     is ($x, 23456);
607
608     ###########################################################################
609     # bug in shortcut in mul()
610
611     # construct a number with a zero-hole of BASE_LEN_SMALL
612     {
613      my @bl = $CL->_base_len(); my $bl = $bl[5];
614
615      $x = '1' x $bl . '0' x $bl . '1' x $bl . '0' x $bl;
616      $y = '1' x (2*$bl);
617      $x = $class->new($x)->bmul($y);
618      # result is 123..$bl .  $bl x (3*bl-1) . $bl...321 . '0' x $bl
619      $y = ''; my $d = '';
620      for (my $i = 1; $i <= $bl; $i++)
621        {
622        $y .= $i; $d = $i.$d;
623        }
624      $y .= $bl x (3*$bl-1) . $d . '0' x $bl;
625      is ($x,$y);
626
627
628       #########################################################################
629       # see if mul shortcut for small numbers works
630
631       $x = '9' x $bl;
632       $x = $class->new($x); 
633       # 999 * 999 => 998 . 001, 9999*9999 => 9998 . 0001
634       is ($x*$x, '9' x ($bl-1) . '8' . '0' x ($bl-1) . '1');
635     }
636
637     ###########################################################################
638     # bug with rest "-0" in div, causing further div()s to fail
639
640     $x = $class->new('-322056000'); ($x,$y) = $x->bdiv('-12882240');
641
642     is ($y,'0'); is_valid($y);  # $y not '-0'
643
644     ###########################################################################
645     # bug in $x->bmod($y)
646
647     # if $x < 0 and $y > 0
648     $x = $class->new('-629'); is ($x->bmod(5033),4404);
649
650     ###########################################################################
651     # bone/binf etc as plain calls (Lite failed them)
652
653     is ($class->bzero(),0);
654     is ($class->bone(),1);
655     is ($class->bone('+'),1);
656     is ($class->bone('-'),-1);
657     is ($class->bnan(),'NaN');
658     is ($class->binf(),'inf');
659     is ($class->binf('+'),'inf');
660     is ($class->binf('-'),'-inf');
661     is ($class->binf('-inf'),'-inf');
662
663     ###########################################################################
664     # is_one('-')
665
666     is ($class->new(1)->is_one('-'),0);
667     is ($class->new(-1)->is_one('-'),1);
668     is ($class->new(1)->is_one(),1);
669     is ($class->new(-1)->is_one(),0);
670
671     ###########################################################################
672     # [perl #30609] bug with $x -= $x not being 0, but 2*$x
673
674     $x = $class->new(3);  $x -= $x; is ($x, 0);
675     $x = $class->new(-3); $x -= $x; is ($x, 0);
676     $x = $class->new('NaN'); $x -= $x; is ($x->is_nan(), 1);
677     $x = $class->new('inf'); $x -= $x; is ($x->is_nan(), 1);
678     $x = $class->new('-inf'); $x -= $x; is ($x->is_nan(), 1);
679
680     $x = $class->new('NaN'); $x += $x; is ($x->is_nan(), 1);
681     $x = $class->new('inf'); $x += $x; is ($x->is_inf(), 1);
682     $x = $class->new('-inf'); $x += $x; is ($x->is_inf('-'), 1);
683     $x = $class->new(3);  $x += $x; is ($x, 6);
684     $x = $class->new(-3); $x += $x; is ($x, -6);
685
686     $x = $class->new(3);  $x *= $x; is ($x, 9);
687     $x = $class->new(-3); $x *= $x; is ($x, 9);
688     $x = $class->new(3);  $x /= $x; is ($x, 1);
689     $x = $class->new(-3); $x /= $x; is ($x, 1);
690     $x = $class->new(3);  $x %= $x; is ($x, 0);
691     $x = $class->new(-3); $x %= $x; is ($x, 0);
692 }
693
694 ###############################################################################
695 # all tests done
696
697 1;
698
699 ###############################################################################
700 # sub to check validity of a BigInt internally, to ensure that no op leaves a
701 # number object in an invalid state (f.i. "-0")
702
703 sub is_valid
704   {
705   my ($x,$f) = @_;
706
707   my $e = 0;                    # error?
708
709   # allow the check to pass for all Lite, and all MBI and subclasses
710   # ok as reference? 
711   $e = 'Not a reference to Math::BigInt' if ref($x) !~ /^Math::BigInt/;
712
713   if (ref($x) ne 'Math::BigInt::Lite')
714     {
715     # has ok sign?
716     $e = "Illegal sign $x->{sign} (expected: '+', '-', '-inf', '+inf' or 'NaN'"
717      if $e eq '0' && $x->{sign} !~ /^(\+|-|\+inf|-inf|NaN)$/;
718   
719     $e = "-0 is invalid!" if $e ne '0' && $x->{sign} eq '-' && $x == 0;
720     $e = $CALC->_check($x->{value}) if $e eq '0';
721     }
722
723   # test done, see if error did crop up
724   is (1,1), return if ($e eq '0');
725
726   is (1,$e." after op '$f'");
727   }
728
729 __DATA__
730 &.=
731 1234:-345:1234-345
732 &+=
733 1:2:3
734 -1:-2:-3
735 &-=
736 1:2:-1
737 -1:-2:1
738 &*=
739 2:3:6
740 -1:5:-5
741 &%=
742 100:3:1
743 8:9:8
744 -629:5033:4404
745 &/=
746 100:3:33
747 -8:2:-4
748 &|=
749 2:1:3
750 &&=
751 5:7:5
752 &^=
753 5:7:2
754 &blog
755 #
756 NaNlog:2:NaN
757 122:NaNlog:NaN
758 NaNlog1:NaNlog:NaN
759 #
760 122:inf:0
761 inf:122:inf
762 122:-inf:0
763 -inf:122:inf
764 -inf:-inf:NaN
765 0:4:-inf
766 -21:4:NaN
767 21:-21:NaN
768 #
769 0:-inf:NaN
770 0:-1:NaN
771 0:0:NaN
772 0:1:NaN
773 0:inf:NaN
774 #
775 1:-inf:0
776 1:-1:0
777 1:0:0
778 1:1:NaN
779 1:4:0
780 1:inf:0
781 #
782 inf:-inf:NaN
783 inf:-1:NaN
784 inf:0:NaN
785 inf:1:NaN
786 inf:4:inf
787 inf:inf:NaN
788 #
789 # normal results
790 1024:2:10
791 81:3:4
792 # 3.01.. truncate
793 82:3:4
794 # 3.9... truncate
795 80:3:3
796 4096:2:12
797 15625:5:6
798 15626:5:6
799 15624:5:5
800 1000:10:3
801 10000:10:4
802 100000:10:5
803 1000000:10:6
804 10000000:10:7
805 100000000:10:8
806 8916100448256:12:12
807 8916100448257:12:12
808 8916100448255:12:11
809 2251799813685248:8:17
810 72057594037927936:2:56
811 144115188075855872:2:57
812 288230376151711744:2:58
813 576460752303423488:2:59
814 1329227995784915872903807060280344576:2:120
815 # $x == $base => result 1
816 3:3:1
817 # $x < $base => result 0 ($base ** 0 <= $x)
818 3:4:0
819 # $x == 1 => result 0
820 1:5:0
821 &is_negative
822 0:0
823 -1:1
824 1:0
825 +inf:0
826 -inf:1
827 NaNneg:0
828 &is_positive
829 0:0
830 -1:0
831 1:1
832 +inf:1
833 -inf:0
834 NaNneg:0
835 &is_int
836 -inf:0
837 +inf:0
838 NaNis_int:0
839 1:1
840 0:1
841 123e12:1
842 &is_odd
843 abc:0
844 0:0
845 1:1
846 3:1
847 -1:1
848 -3:1
849 10000001:1
850 10000002:0
851 2:0
852 120:0
853 121:1
854 &is_even
855 abc:0
856 0:1
857 1:0
858 3:0
859 -1:0
860 -3:0
861 10000001:0
862 10000002:1
863 2:1
864 120:1
865 121:0
866 &bacmp
867 +0:-0:0
868 +0:+1:-1
869 -1:+1:0
870 +1:-1:0
871 -1:+2:-1
872 +2:-1:1
873 -123456789:+987654321:-1
874 +123456789:-987654321:-1
875 +987654321:+123456789:1
876 -987654321:+123456789:1
877 -123:+4567889:-1
878 # NaNs
879 acmpNaN:123:
880 123:acmpNaN:
881 acmpNaN:acmpNaN:
882 # infinity
883 +inf:+inf:0
884 -inf:-inf:0
885 +inf:-inf:0
886 -inf:+inf:0
887 +inf:123:1
888 -inf:123:1
889 +inf:-123:1
890 -inf:-123:1
891 123:-inf:-1
892 -123:inf:-1
893 -123:-inf:-1
894 123:inf:-1
895 # return undef
896 +inf:NaN:
897 NaN:inf:
898 -inf:NaN:
899 NaN:-inf:
900 &bnorm
901 0e999:0
902 0e-999:0
903 -0e999:0
904 -0e-999:0
905 123:123
906 # binary input
907 0babc:NaN
908 0b123:NaN
909 0b0:0
910 -0b0:0
911 -0b1:-1
912 0b0001:1
913 0b001:1
914 0b011:3
915 0b101:5
916 0b1001:9
917 0b10001:17
918 0b100001:33
919 0b1000001:65
920 0b10000001:129
921 0b100000001:257
922 0b1000000001:513
923 0b10000000001:1025
924 0b100000000001:2049
925 0b1000000000001:4097
926 0b10000000000001:8193
927 0b100000000000001:16385
928 0b1000000000000001:32769
929 0b10000000000000001:65537
930 0b100000000000000001:131073
931 0b1000000000000000001:262145
932 0b10000000000000000001:524289
933 0b100000000000000000001:1048577
934 0b1000000000000000000001:2097153
935 0b10000000000000000000001:4194305
936 0b100000000000000000000001:8388609
937 0b1000000000000000000000001:16777217
938 0b10000000000000000000000001:33554433
939 0b100000000000000000000000001:67108865
940 0b1000000000000000000000000001:134217729
941 0b10000000000000000000000000001:268435457
942 0b100000000000000000000000000001:536870913
943 0b1000000000000000000000000000001:1073741825
944 0b10000000000000000000000000000001:2147483649
945 0b100000000000000000000000000000001:4294967297
946 0b1000000000000000000000000000000001:8589934593
947 0b10000000000000000000000000000000001:17179869185
948 0b__101:NaN
949 0b1_0_1:5
950 0b0_0_0_1:1
951 # hex input
952 -0x0:0
953 0xabcdefgh:NaN
954 0x1234:4660
955 0xabcdef:11259375
956 -0xABCDEF:-11259375
957 -0x1234:-4660
958 0x12345678:305419896
959 0x1_2_3_4_56_78:305419896
960 0xa_b_c_d_e_f:11259375
961 0x__123:NaN
962 0x9:9
963 0x11:17
964 0x21:33
965 0x41:65
966 0x81:129
967 0x101:257
968 0x201:513
969 0x401:1025
970 0x801:2049
971 0x1001:4097
972 0x2001:8193
973 0x4001:16385
974 0x8001:32769
975 0x10001:65537
976 0x20001:131073
977 0x40001:262145
978 0x80001:524289
979 0x100001:1048577
980 0x200001:2097153
981 0x400001:4194305
982 0x800001:8388609
983 0x1000001:16777217
984 0x2000001:33554433
985 0x4000001:67108865
986 0x8000001:134217729
987 0x10000001:268435457
988 0x20000001:536870913
989 0x40000001:1073741825
990 0x80000001:2147483649
991 0x100000001:4294967297
992 0x200000001:8589934593
993 0x400000001:17179869185
994 0x800000001:34359738369
995 # bug found by Mark Lakata in Calc.pm creating too big one-element numbers in _from_hex()
996 0x2dd59e18a125dbed30a6ab1d93e9c855569f44f75806f0645dc9a2e98b808c3:1295719234436071846486578237372801883390756472611551858964079371952886122691
997 # inf input
998 inf:inf
999 +inf:inf
1000 -inf:-inf
1001 0inf:NaN
1002 # abnormal input
1003 :NaN
1004 abc:NaN
1005    1 a:NaN
1006 1bcd2:NaN
1007 11111b:NaN
1008 +1z:NaN
1009 -1z:NaN
1010 # only one underscore between two digits
1011 _123:NaN
1012 _123_:NaN
1013 123_:NaN
1014 1__23:NaN
1015 1E1__2:NaN
1016 1_E12:NaN
1017 1E_12:NaN
1018 1_E_12:NaN
1019 +_1E12:NaN
1020 +0_1E2:100
1021 +0_0_1E2:100
1022 -0_0_1E2:-100
1023 -0_0_1E+0_0_2:-100
1024 E1:NaN
1025 E23:NaN
1026 1.23E1:NaN
1027 1.23E-1:NaN
1028 # bug with two E's in number being valid
1029 1e2e3:NaN
1030 1e2r:NaN
1031 1e2.0:NaN
1032 # bug with two '.' in number being valid
1033 1.2.2:NaN
1034 1.2.3e1:NaN
1035 -1.2.3:NaN
1036 -1.2.3e-4:NaN
1037 1.2e3.4:NaN
1038 1.2e-3.4:NaN
1039 1.2.3.4:NaN
1040 1.2.t:NaN
1041 1..2:NaN
1042 1..2e1:NaN
1043 1..2e1..1:NaN
1044 12e1..1:NaN
1045 ..2:NaN
1046 .-2:NaN
1047 # leading zeros
1048 012:12
1049 0123:123
1050 01234:1234
1051 012345:12345
1052 0123456:123456
1053 01234567:1234567
1054 012345678:12345678
1055 0123456789:123456789
1056 01234567891:1234567891
1057 012345678912:12345678912
1058 0123456789123:123456789123
1059 01234567891234:1234567891234
1060 # some inputs that result in zero
1061 0e0:0
1062 +0e0:0
1063 +0e+0:0
1064 -0e+0:0
1065 0e-0:0
1066 -0e-0:0
1067 +0e-0:0
1068 000:0
1069 00e2:0
1070 00e02:0
1071 000e002:0
1072 000e1230:0
1073 00e-3:0
1074 00e+3:0
1075 00e-03:0
1076 00e+03:0
1077 -000:0
1078 -00e2:0
1079 -00e02:0
1080 -000e002:0
1081 -000e1230:0
1082 -00e-3:0
1083 -00e+3:0
1084 -00e-03:0
1085 -00e+03:0
1086 # normal input
1087 0:0
1088 +0:0
1089 +00:0
1090 +000:0
1091 000000000000000000:0
1092 -0:0
1093 -0000:0
1094 +1:1
1095 +01:1
1096 +001:1
1097 +00000100000:100000
1098 123456789:123456789
1099 -1:-1
1100 -01:-1
1101 -001:-1
1102 -123456789:-123456789
1103 -00000100000:-100000
1104 1_2_3:123
1105 10000000000E-1_0:1
1106 1E2:100
1107 1E1:10
1108 1E0:1
1109 1.23E2:123
1110 100E-1:10
1111 # floating point input
1112 # .2e2:20
1113 1.E3:1000
1114 1.01E2:101
1115 1010E-1:101
1116 -1010E0:-1010
1117 -1010E1:-10100
1118 1234.00:1234
1119 # non-integer numbers
1120 -1010E-2:NaN
1121 -1.01E+1:NaN
1122 -1.01E-1:NaN
1123 1E-999999:NaN
1124 0.5:NaN
1125 &bnan
1126 1:NaN
1127 2:NaN
1128 abc:NaN
1129 &bone
1130 2:+:1
1131 2:-:-1
1132 boneNaN:-:-1
1133 boneNaN:+:1
1134 2:abc:1
1135 3::1
1136 &binf
1137 1:+:inf
1138 2:-:-inf
1139 3:abc:inf
1140 &is_nan
1141 123:0
1142 abc:1
1143 NaN:1
1144 -123:0
1145 &is_inf
1146 +inf::1
1147 -inf::1
1148 abc::0
1149 1::0
1150 NaN::0
1151 -1::0
1152 +inf:-:0
1153 +inf:+:1
1154 -inf:-:1
1155 -inf:+:0
1156 -inf:-inf:1
1157 -inf:+inf:0
1158 +inf:-inf:0
1159 +inf:+inf:1
1160 # it must be exactly /^[+-]inf$/
1161 +infinity::0
1162 -infinity::0
1163 &blsft
1164 abc:abc:NaN
1165 +2:+2:8
1166 +1:+32:4294967296
1167 +1:+48:281474976710656
1168 +8:-2:NaN
1169 # exercise base 10
1170 +12345:4:10:123450000
1171 -1234:0:10:-1234
1172 +1234:0:10:1234
1173 +2:2:10:200
1174 +12:2:10:1200
1175 +1234:-3:10:NaN
1176 1234567890123:12:10:1234567890123000000000000
1177 -3:1:2:-6
1178 -5:1:2:-10
1179 -2:1:2:-4
1180 -102533203:1:2:-205066406
1181 &brsft
1182 abc:abc:NaN
1183 +8:+2:2
1184 +4294967296:+32:1
1185 +281474976710656:+48:1
1186 +2:-2:NaN
1187 # exercise base 10
1188 -1234:0:10:-1234
1189 +1234:0:10:1234
1190 +200:2:10:2
1191 +1234:3:10:1
1192 +1234:2:10:12
1193 +1234:-3:10:NaN
1194 310000:4:10:31
1195 12300000:5:10:123
1196 1230000000000:10:10:123
1197 09876123456789067890:12:10:9876123
1198 1234561234567890123:13:10:123456
1199 820265627:1:2:410132813
1200 # test shifting negative numbers in base 2
1201 -15:1:2:-8
1202 -14:1:2:-7
1203 -13:1:2:-7
1204 -12:1:2:-6
1205 -11:1:2:-6
1206 -10:1:2:-5
1207 -9:1:2:-5
1208 -8:1:2:-4
1209 -7:1:2:-4
1210 -6:1:2:-3
1211 -5:1:2:-3
1212 -4:1:2:-2
1213 -3:1:2:-2
1214 -2:1:2:-1
1215 -1:1:2:-1
1216 -1640531254:2:2:-410132814
1217 -1640531254:1:2:-820265627
1218 -820265627:1:2:-410132814
1219 -205066405:1:2:-102533203
1220 &bsstr
1221 +inf:inf
1222 -inf:-inf
1223 1e+34:1e+34
1224 123.456E3:123456e+0
1225 100:1e+2
1226 bsstrabc:NaN
1227 -5:-5e+0
1228 -100:-1e+2
1229 &numify
1230 numifyabc:NaN
1231 +inf:inf
1232 -inf:-inf
1233 5:5
1234 -5:-5
1235 100:100
1236 -100:-100
1237 &bneg
1238 bnegNaN:NaN
1239 +inf:-inf
1240 -inf:inf
1241 abd:NaN
1242 0:0
1243 1:-1
1244 -1:1
1245 +123456789:-123456789
1246 -123456789:123456789
1247 &babs
1248 babsNaN:NaN
1249 +inf:inf
1250 -inf:inf
1251 0:0
1252 1:1
1253 -1:1
1254 +123456789:123456789
1255 -123456789:123456789
1256 &bsgn
1257 NaN:NaN
1258 +inf:1
1259 -inf:-1
1260 0:0
1261 +123456789:1
1262 -123456789:-1
1263 &bcmp
1264 bcmpNaN:bcmpNaN:
1265 bcmpNaN:0:
1266 0:bcmpNaN:
1267 0:0:0
1268 -1:0:-1
1269 0:-1:1
1270 1:0:1
1271 0:1:-1
1272 -1:1:-1
1273 1:-1:1
1274 -1:-1:0
1275 1:1:0
1276 123:123:0
1277 123:12:1
1278 12:123:-1
1279 -123:-123:0
1280 -123:-12:-1
1281 -12:-123:1
1282 123:124:-1
1283 124:123:1
1284 -123:-124:1
1285 -124:-123:-1
1286 100:5:1
1287 -123456789:987654321:-1
1288 +123456789:-987654321:1
1289 -987654321:123456789:-1
1290 -inf:5432112345:-1
1291 +inf:5432112345:1
1292 -inf:-5432112345:-1
1293 +inf:-5432112345:1
1294 +inf:+inf:0
1295 -inf:-inf:0
1296 +inf:-inf:1
1297 -inf:+inf:-1
1298 5:inf:-1
1299 5:inf:-1
1300 -5:-inf:1
1301 -5:-inf:1
1302 # return undef
1303 +inf:NaN:
1304 NaN:inf:
1305 -inf:NaN:
1306 NaN:-inf:
1307 &binc
1308 abc:NaN
1309 +inf:inf
1310 -inf:-inf
1311 +0:1
1312 +1:2
1313 -1:0
1314 &bdec
1315 abc:NaN
1316 +inf:inf
1317 -inf:-inf
1318 +0:-1
1319 +1:0
1320 -1:-2
1321 &badd
1322 abc:abc:NaN
1323 abc:0:NaN
1324 +0:abc:NaN
1325 +inf:-inf:NaN
1326 -inf:+inf:NaN
1327 +inf:+inf:inf
1328 -inf:-inf:-inf
1329 baddNaN:+inf:NaN
1330 baddNaN:+inf:NaN
1331 +inf:baddNaN:NaN
1332 -inf:baddNaN:NaN
1333 0:0:0
1334 1:0:1
1335 0:1:1
1336 1:1:2
1337 -1:0:-1
1338 0:-1:-1
1339 -1:-1:-2
1340 -1:+1:0
1341 +1:-1:0
1342 +9:+1:10
1343 +99:+1:100
1344 +999:+1:1000
1345 +9999:+1:10000
1346 +99999:+1:100000
1347 +999999:+1:1000000
1348 +9999999:+1:10000000
1349 +99999999:+1:100000000
1350 +999999999:+1:1000000000
1351 +9999999999:+1:10000000000
1352 +99999999999:+1:100000000000
1353 +10:-1:9
1354 +100:-1:99
1355 +1000:-1:999
1356 +10000:-1:9999
1357 +100000:-1:99999
1358 +1000000:-1:999999
1359 +10000000:-1:9999999
1360 +100000000:-1:99999999
1361 +1000000000:-1:999999999
1362 +10000000000:-1:9999999999
1363 +123456789:987654321:1111111110
1364 -123456789:987654321:864197532
1365 -123456789:-987654321:-1111111110
1366 +123456789:-987654321:-864197532
1367 -1:10001:10000
1368 -1:100001:100000
1369 -1:1000001:1000000
1370 -1:10000001:10000000
1371 -1:100000001:100000000
1372 -1:1000000001:1000000000
1373 -1:10000000001:10000000000
1374 -1:100000000001:100000000000
1375 -1:1000000000001:1000000000000
1376 -1:10000000000001:10000000000000
1377 -1:-10001:-10002
1378 -1:-100001:-100002
1379 -1:-1000001:-1000002
1380 -1:-10000001:-10000002
1381 -1:-100000001:-100000002
1382 -1:-1000000001:-1000000002
1383 -1:-10000000001:-10000000002
1384 -1:-100000000001:-100000000002
1385 -1:-1000000000001:-1000000000002
1386 -1:-10000000000001:-10000000000002
1387 &bsub
1388 abc:abc:NaN
1389 abc:+0:NaN
1390 +0:abc:NaN
1391 +inf:-inf:inf
1392 -inf:+inf:-inf
1393 +inf:+inf:NaN
1394 -inf:-inf:NaN
1395 +0:+0:0
1396 +1:+0:1
1397 +0:+1:-1
1398 +1:+1:0
1399 -1:+0:-1
1400 +0:-1:1
1401 -1:-1:0
1402 -1:+1:-2
1403 +1:-1:2
1404 +9:+1:8
1405 +99:+1:98
1406 +999:+1:998
1407 +9999:+1:9998
1408 +99999:+1:99998
1409 +999999:+1:999998
1410 +9999999:+1:9999998
1411 +99999999:+1:99999998
1412 +999999999:+1:999999998
1413 +9999999999:+1:9999999998
1414 +99999999999:+1:99999999998
1415 +10:-1:11
1416 +100:-1:101
1417 +1000:-1:1001
1418 +10000:-1:10001
1419 +100000:-1:100001
1420 +1000000:-1:1000001
1421 +10000000:-1:10000001
1422 +100000000:-1:100000001
1423 +1000000000:-1:1000000001
1424 +10000000000:-1:10000000001
1425 +123456789:+987654321:-864197532
1426 -123456789:+987654321:-1111111110
1427 -123456789:-987654321:864197532
1428 +123456789:-987654321:1111111110
1429 10001:1:10000
1430 100001:1:100000
1431 1000001:1:1000000
1432 10000001:1:10000000
1433 100000001:1:100000000
1434 1000000001:1:1000000000
1435 10000000001:1:10000000000
1436 100000000001:1:100000000000
1437 1000000000001:1:1000000000000
1438 10000000000001:1:10000000000000
1439 10001:-1:10002
1440 100001:-1:100002
1441 1000001:-1:1000002
1442 10000001:-1:10000002
1443 100000001:-1:100000002
1444 1000000001:-1:1000000002
1445 10000000001:-1:10000000002
1446 100000000001:-1:100000000002
1447 1000000000001:-1:1000000000002
1448 10000000000001:-1:10000000000002
1449 &bmuladd
1450 abc:abc:0:NaN
1451 abc:+0:0:NaN
1452 +0:abc:0:NaN
1453 +0:0:abc:NaN
1454 NaNmul:+inf:0:NaN
1455 NaNmul:-inf:0:NaN
1456 -inf:NaNmul:0:NaN
1457 +inf:NaNmul:0:NaN
1458 +inf:+inf:0:inf
1459 +inf:-inf:0:-inf
1460 -inf:+inf:0:-inf
1461 -inf:-inf:0:inf
1462 +0:+0:0:0
1463 +0:+1:0:0
1464 +1:+0:0:0
1465 +0:-1:0:0
1466 -1:+0:0:0
1467 123456789123456789:0:0:0
1468 0:123456789123456789:0:0
1469 -1:-1:0:1
1470 -1:-1:0:1
1471 -1:+1:0:-1
1472 +1:-1:0:-1
1473 +1:+1:0:1
1474 +2:+3:0:6
1475 -2:+3:0:-6
1476 +2:-3:0:-6
1477 -2:-3:0:6
1478 111:111:0:12321
1479 10101:10101:0:102030201
1480 1001001:1001001:0:1002003002001
1481 100010001:100010001:0:10002000300020001
1482 10000100001:10000100001:0:100002000030000200001
1483 11111111111:9:0:99999999999
1484 22222222222:9:0:199999999998
1485 33333333333:9:0:299999999997
1486 44444444444:9:0:399999999996
1487 55555555555:9:0:499999999995
1488 66666666666:9:0:599999999994
1489 77777777777:9:0:699999999993
1490 88888888888:9:0:799999999992
1491 99999999999:9:0:899999999991
1492 11111111111:9:1:100000000000
1493 22222222222:9:1:199999999999
1494 33333333333:9:1:299999999998
1495 44444444444:9:1:399999999997
1496 55555555555:9:1:499999999996
1497 66666666666:9:1:599999999995
1498 77777777777:9:1:699999999994
1499 88888888888:9:1:799999999993
1500 99999999999:9:1:899999999992
1501 -3:-4:-5:7
1502 3:-4:-5:-17
1503 -3:4:-5:-17
1504 3:4:-5:7
1505 -3:4:5:-7
1506 3:-4:5:-7
1507 9999999999999999999:10000000000000000000:1234567890:99999999999999999990000000001234567890
1508 2:3:12345678901234567890:12345678901234567896
1509 &bmul
1510 abc:abc:NaN
1511 abc:+0:NaN
1512 +0:abc:NaN
1513 NaNmul:+inf:NaN
1514 NaNmul:-inf:NaN
1515 -inf:NaNmul:NaN
1516 +inf:NaNmul:NaN
1517 +inf:+inf:inf
1518 +inf:-inf:-inf
1519 -inf:+inf:-inf
1520 -inf:-inf:inf
1521 +0:+0:0
1522 +0:+1:0
1523 +1:+0:0
1524 +0:-1:0
1525 -1:+0:0
1526 123456789123456789:0:0
1527 0:123456789123456789:0
1528 -1:-1:1
1529 -1:+1:-1
1530 +1:-1:-1
1531 +1:+1:1
1532 +2:+3:6
1533 -2:+3:-6
1534 +2:-3:-6
1535 -2:-3:6
1536 111:111:12321
1537 10101:10101:102030201
1538 1001001:1001001:1002003002001
1539 100010001:100010001:10002000300020001
1540 10000100001:10000100001:100002000030000200001
1541 11111111111:9:99999999999
1542 22222222222:9:199999999998
1543 33333333333:9:299999999997
1544 44444444444:9:399999999996
1545 55555555555:9:499999999995
1546 66666666666:9:599999999994
1547 77777777777:9:699999999993
1548 88888888888:9:799999999992
1549 99999999999:9:899999999991
1550 +25:+25:625
1551 +12345:+12345:152399025
1552 +99999:+11111:1111088889
1553 9999:10000:99990000
1554 99999:100000:9999900000
1555 999999:1000000:999999000000
1556 9999999:10000000:99999990000000
1557 99999999:100000000:9999999900000000
1558 999999999:1000000000:999999999000000000
1559 9999999999:10000000000:99999999990000000000
1560 99999999999:100000000000:9999999999900000000000
1561 999999999999:1000000000000:999999999999000000000000
1562 9999999999999:10000000000000:99999999999990000000000000
1563 99999999999999:100000000000000:9999999999999900000000000000
1564 999999999999999:1000000000000000:999999999999999000000000000000
1565 9999999999999999:10000000000000000:99999999999999990000000000000000
1566 99999999999999999:100000000000000000:9999999999999999900000000000000000
1567 999999999999999999:1000000000000000000:999999999999999999000000000000000000
1568 9999999999999999999:10000000000000000000:99999999999999999990000000000000000000
1569 &bdiv-list
1570 100:20:5,0
1571 4095:4095:1,0
1572 -4095:-4095:1,0
1573 4095:-4095:-1,0
1574 -4095:4095:-1,0
1575 123:2:61,1
1576 9:5:1,4
1577 9:4:2,1
1578 # inf handling and general remainder
1579 5:8:0,5
1580 0:8:0,0
1581 11:2:5,1
1582 11:-2:-6,-1
1583 -11:2:-6,1
1584 # see table in documentation in MBI
1585 0:inf:0,0
1586 0:-inf:0,0
1587 5:inf:0,5
1588 5:-inf:-1,-inf
1589 -5:inf:-1,inf
1590 -5:-inf:0,-5
1591 inf:5:inf,NaN
1592 -inf:5:-inf,NaN
1593 inf:-5:-inf,NaN
1594 -inf:-5:inf,NaN
1595 5:5:1,0
1596 -5:-5:1,0
1597 inf:inf:NaN,NaN
1598 -inf:-inf:NaN,NaN
1599 -inf:inf:NaN,NaN
1600 inf:-inf:NaN,NaN
1601 8:0:inf,8
1602 inf:0:inf,inf
1603 # exceptions to remainder rule
1604 -8:0:-inf,-8
1605 -inf:0:-inf,-inf
1606 0:0:NaN,0
1607 # test the shortcut in Calc if @$x == @$yorg
1608 1234567812345678:123456712345678:10,688888898
1609 12345671234567:1234561234567:10,58888897
1610 123456123456:12345123456:10,4888896
1611 1234512345:123412345:10,388895
1612 1234567890999999999:1234567890:1000000000,999999999
1613 1234567890000000000:1234567890:1000000000,0
1614 1234567890999999999:9876543210:124999998,9503086419
1615 1234567890000000000:9876543210:124999998,8503086420
1616 96969696969696969696969696969678787878626262626262626262626262:484848484848484848484848486666666666666689898989898989898989:199,484848484848484848484848123012121211954972727272727272727451
1617 # bug in v1.76
1618 1267650600228229401496703205375:1267650600228229401496703205376:0,1267650600228229401496703205375
1619 # exercise shortcut for numbers of the same length in div
1620 999999999999999999999999999999999:999999999999999999999999999999999:1,0
1621 999999999999999999999999999999999:888888888888888888888888888888888:1,111111111111111111111111111111111
1622 999999999999999999999999999999999:777777777777777777777777777777777:1,222222222222222222222222222222222
1623 999999999999999999999999999999999:666666666666666666666666666666666:1,333333333333333333333333333333333
1624 999999999999999999999999999999999:555555555555555555555555555555555:1,444444444444444444444444444444444
1625 999999999999999999999999999999999:444444444444444444444444444444444:2,111111111111111111111111111111111
1626 999999999999999999999999999999999:333333333333333333333333333333333:3,0
1627 999999999999999999999999999999999:222222222222222222222222222222222:4,111111111111111111111111111111111
1628 999999999999999999999999999999999:111111111111111111111111111111111:9,0
1629 9999999_9999999_9999999_9999999:3333333_3333333_3333333_3333333:3,0
1630 9999999_9999999_9999999_9999999:3333333_0000000_0000000_0000000:3,999999999999999999999
1631 9999999_9999999_9999999_9999999:3000000_0000000_0000000_0000000:3,999999999999999999999999999
1632 9999999_9999999_9999999_9999999:2000000_0000000_0000000_0000000:4,1999999999999999999999999999
1633 9999999_9999999_9999999_9999999:1000000_0000000_0000000_0000000:9,999999999999999999999999999
1634 9999999_9999999_9999999_9999999:100000_0000000_0000000_0000000:99,99999999999999999999999999
1635 9999999_9999999_9999999_9999999:10000_0000000_0000000_0000000:999,9999999999999999999999999
1636 9999999_9999999_9999999_9999999:1000_0000000_0000000_0000000:9999,999999999999999999999999
1637 9999999_9999999_9999999_9999999:100_0000000_0000000_0000000:99999,99999999999999999999999
1638 9999999_9999999_9999999_9999999:10_0000000_0000000_0000000:999999,9999999999999999999999
1639 9999999_9999999_9999999_9999999:1_0000000_0000000_0000000:9999999,999999999999999999999
1640 &bdiv
1641 abc:abc:NaN
1642 abc:1:NaN
1643 1:abc:NaN
1644 0:0:NaN
1645 # inf handling (see table in doc)
1646 0:inf:0
1647 0:-inf:0
1648 5:inf:0
1649 5:-inf:-1
1650 -5:inf:-1
1651 -5:-inf:0
1652 inf:5:inf
1653 -inf:5:-inf
1654 inf:-5:-inf
1655 -inf:-5:inf
1656 5:5:1
1657 -5:-5:1
1658 inf:inf:NaN
1659 -inf:-inf:NaN
1660 -inf:inf:NaN
1661 inf:-inf:NaN
1662 8:0:inf
1663 inf:0:inf
1664 -8:0:-inf
1665 -inf:0:-inf
1666 0:0:NaN
1667 11:2:5
1668 -11:-2:5
1669 -11:2:-6
1670 11:-2:-6
1671 0:1:0
1672 0:-1:0
1673 1:1:1
1674 -1:-1:1
1675 1:-1:-1
1676 -1:1:-1
1677 1:2:0
1678 2:1:2
1679 1:26:0
1680 1000000000:9:111111111
1681 2000000000:9:222222222
1682 3000000000:9:333333333
1683 4000000000:9:444444444
1684 5000000000:9:555555555
1685 6000000000:9:666666666
1686 7000000000:9:777777777
1687 8000000000:9:888888888
1688 9000000000:9:1000000000
1689 35500000:113:314159
1690 71000000:226:314159
1691 106500000:339:314159
1692 1000000000:3:333333333
1693 +10:+5:2
1694 +100:+4:25
1695 +1000:+8:125
1696 +10000:+16:625
1697 999999999999:9:111111111111
1698 999999999999:99:10101010101
1699 999999999999:999:1001001001
1700 999999999999:9999:100010001
1701 999999999999999:99999:10000100001
1702 +1111088889:99999:11111
1703 -5:-3:1
1704 -5:3:-2
1705 4:3:1
1706 4:-3:-2
1707 1:3:0
1708 1:-3:-1
1709 -2:-3:0
1710 -2:3:-1
1711 8:3:2
1712 -8:3:-3
1713 14:-3:-5
1714 -14:3:-5
1715 -14:-3:4
1716 14:3:4
1717 # bug in Calc with '99999' vs $BASE-1
1718 10000000000000000000000000000000000000000000000000000000000000000000000000000000000:10000000375084540248994272022843165711074:999999962491547381984643365663244474111576
1719 # test the shortcut in Calc if @$x == @$yorg
1720 1234567812345678:123456712345678:10
1721 12345671234567:1234561234567:10
1722 123456123456:12345123456:10
1723 1234512345:123412345:10
1724 1234567890999999999:1234567890:1000000000
1725 1234567890000000000:1234567890:1000000000
1726 1234567890999999999:9876543210:124999998
1727 1234567890000000000:9876543210:124999998
1728 96969696969696969696969696969678787878626262626262626262626262:484848484848484848484848486666666666666689898989898989898989:199
1729 # bug up to v0.35 in Calc (--$q one too many)
1730 84696969696969696956565656566184292929292929292847474747436308080808080808086765396464646464646465:13131313131313131313131313131394949494949494949494949494943535353535353535353535:6449999999999999999
1731 84696969696969696943434343434871161616161616161452525252486813131313131313143230042929292929292930:13131313131313131313131313131394949494949494949494949494943535353535353535353535:6449999999999999998
1732 84696969696969696969696969697497424242424242424242424242385803030303030303030300750000000000000000:13131313131313131313131313131394949494949494949494949494943535353535353535353535:6450000000000000000
1733 84696969696969696930303030303558030303030303030057575757537318181818181818199694689393939393939395:13131313131313131313131313131394949494949494949494949494943535353535353535353535:6449999999999999997
1734 # exercise shortcut for numbers of the same length in div
1735 999999999999999999999999999999999:999999999999999999999999999999999:1
1736 999999999999999999999999999999999:888888888888888888888888888888888:1
1737 999999999999999999999999999999999:777777777777777777777777777777777:1
1738 999999999999999999999999999999999:666666666666666666666666666666666:1
1739 999999999999999999999999999999999:555555555555555555555555555555555:1
1740 999999999999999999999999999999999:444444444444444444444444444444444:2
1741 999999999999999999999999999999999:333333333333333333333333333333333:3
1742 999999999999999999999999999999999:222222222222222222222222222222222:4
1743 999999999999999999999999999999999:111111111111111111111111111111111:9
1744 9999999_9999999_9999999_9999999:3333333_3333333_3333333_3333333:3
1745 9999999_9999999_9999999_9999999:3333333_0000000_0000000_0000000:3
1746 9999999_9999999_9999999_9999999:3000000_0000000_0000000_0000000:3
1747 9999999_9999999_9999999_9999999:2000000_0000000_0000000_0000000:4
1748 9999999_9999999_9999999_9999999:1000000_0000000_0000000_0000000:9
1749 9999999_9999999_9999999_9999999:100000_0000000_0000000_0000000:99
1750 9999999_9999999_9999999_9999999:10000_0000000_0000000_0000000:999
1751 9999999_9999999_9999999_9999999:1000_0000000_0000000_0000000:9999
1752 9999999_9999999_9999999_9999999:100_0000000_0000000_0000000:99999
1753 9999999_9999999_9999999_9999999:10_0000000_0000000_0000000:999999
1754 9999999_9999999_9999999_9999999:1_0000000_0000000_0000000:9999999
1755 # bug with shortcut in Calc 0.44
1756 949418181818187070707070707070707070:181818181853535353535353535353535353:5
1757 &bmodinv
1758 # format: number:modulus:result
1759 # bmodinv Data errors
1760 abc:abc:NaN
1761 abc:5:NaN
1762 5:abc:NaN
1763 # bmodinv Expected Results from normal use
1764 1:5:1
1765 3:5:2
1766 3:-5:-3
1767 -2:5:2
1768 8:5033:4404
1769 1234567891:13:6
1770 -1234567891:13:7
1771 324958749843759385732954874325984357439658735983745:2348249874968739:1741662881064902
1772 -2:1:0
1773 -1:1:0
1774 0:1:0
1775 1:1:0
1776 2:1:0
1777 3:1:0
1778 4:1:0
1779 -2:3:1
1780 -1:3:2
1781 0:3:NaN
1782 1:3:1
1783 2:3:2
1784 3:3:NaN
1785 4:3:1
1786 -2:4:NaN
1787 -1:4:3
1788 0:4:NaN
1789 1:4:1
1790 2:4:NaN
1791 3:4:3
1792 4:4:NaN
1793 ## bmodinv Error cases / useless use of function
1794 inf:5:NaN
1795 5:inf:NaN
1796 -inf:5:NaN
1797 5:-inf:NaN
1798 &bmodpow
1799 # format: number:exponent:modulus:result
1800 # bmodpow Data errors
1801 abc:abc:abc:NaN
1802 5:abc:abc:NaN
1803 abc:5:abc:NaN
1804 abc:abc:5:NaN
1805 5:5:abc:NaN
1806 5:abc:5:NaN
1807 abc:5:5:NaN
1808 3:5:0:3
1809 # bmodpow Expected results
1810 0:0:2:1
1811 1:0:2:1
1812 0:3:5:0
1813 -2:-2:1:0
1814 -1:-2:1:0
1815 0:-2:1:0
1816 1:-2:1:0
1817 2:-2:1:0
1818 3:-2:1:0
1819 4:-2:1:0
1820 -2:-1:1:0
1821 -1:-1:1:0
1822 0:-1:1:0
1823 1:-1:1:0
1824 2:-1:1:0
1825 3:-1:1:0
1826 4:-1:1:0
1827 -2:0:1:0
1828 -1:0:1:0
1829 0:0:1:0
1830 1:0:1:0
1831 2:0:1:0
1832 3:0:1:0
1833 4:0:1:0
1834 -2:1:1:0
1835 -1:1:1:0
1836 0:1:1:0
1837 1:1:1:0
1838 2:1:1:0
1839 3:1:1:0
1840 4:1:1:0
1841 -2:2:1:0
1842 -1:2:1:0
1843 0:2:1:0
1844 1:2:1:0
1845 2:2:1:0
1846 3:2:1:0
1847 4:2:1:0
1848 -2:3:1:0
1849 -1:3:1:0
1850 0:3:1:0
1851 1:3:1:0
1852 2:3:1:0
1853 3:3:1:0
1854 4:3:1:0
1855 -2:4:1:0
1856 -1:4:1:0
1857 0:4:1:0
1858 1:4:1:0
1859 2:4:1:0
1860 3:4:1:0
1861 4:4:1:0
1862 -2:-2:3:1
1863 -1:-2:3:1
1864 0:-2:3:NaN
1865 1:-2:3:1
1866 2:-2:3:1
1867 3:-2:3:NaN
1868 4:-2:3:1
1869 -2:-1:3:1
1870 -1:-1:3:2
1871 0:-1:3:NaN
1872 1:-1:3:1
1873 2:-1:3:2
1874 3:-1:3:NaN
1875 4:-1:3:1
1876 -2:0:3:1
1877 -1:0:3:1
1878 0:0:3:1
1879 1:0:3:1
1880 2:0:3:1
1881 3:0:3:1
1882 4:0:3:1
1883 -2:1:3:1
1884 -1:1:3:2
1885 0:1:3:0
1886 1:1:3:1
1887 2:1:3:2
1888 3:1:3:0
1889 4:1:3:1
1890 -2:2:3:1
1891 -1:2:3:1
1892 0:2:3:0
1893 1:2:3:1
1894 2:2:3:1
1895 3:2:3:0
1896 4:2:3:1
1897 -2:3:3:1
1898 -1:3:3:2
1899 0:3:3:0
1900 1:3:3:1
1901 2:3:3:2
1902 3:3:3:0
1903 4:3:3:1
1904 -2:4:3:1
1905 -1:4:3:1
1906 0:4:3:0
1907 1:4:3:1
1908 2:4:3:1
1909 3:4:3:0
1910 4:4:3:1
1911 -2:-2:4:NaN
1912 -1:-2:4:1
1913 0:-2:4:NaN
1914 1:-2:4:1
1915 2:-2:4:NaN
1916 3:-2:4:1
1917 4:-2:4:NaN
1918 -2:-1:4:NaN
1919 -1:-1:4:3
1920 0:-1:4:NaN
1921 1:-1:4:1
1922 2:-1:4:NaN
1923 3:-1:4:3
1924 4:-1:4:NaN
1925 -2:0:4:1
1926 -1:0:4:1
1927 0:0:4:1
1928 1:0:4:1
1929 2:0:4:1
1930 3:0:4:1
1931 4:0:4:1
1932 -2:1:4:2
1933 -1:1:4:3
1934 0:1:4:0
1935 1:1:4:1
1936 2:1:4:2
1937 3:1:4:3
1938 4:1:4:0
1939 -2:2:4:0
1940 -1:2:4:1
1941 0:2:4:0
1942 1:2:4:1
1943 2:2:4:0
1944 3:2:4:1
1945 4:2:4:0
1946 -2:3:4:0
1947 -1:3:4:3
1948 0:3:4:0
1949 1:3:4:1
1950 2:3:4:0
1951 3:3:4:3
1952 4:3:4:0
1953 -2:4:4:0
1954 -1:4:4:1
1955 0:4:4:0
1956 1:4:4:1
1957 2:4:4:0
1958 3:4:4:1
1959 4:4:4:0
1960 8:-1:16:NaN
1961 8:-1:5033:4404
1962 8:7:5032:3840
1963 8:8:-5:-4
1964 1e50:1:1:0
1965 98436739867439843769485798542749827593285729587325:43698764986460981048259837659386739857456983759328457:6943857329857295827698367:3104744730915914415259518
1966 # bmodpow Error cases
1967 inf:5:13:NaN
1968 5:inf:13:NaN
1969 &bmod
1970 # inf handling, see table in doc
1971 0:inf:0
1972 0:-inf:0
1973 5:inf:5
1974 5:-inf:-inf
1975 -5:inf:inf
1976 -5:-inf:-5
1977 inf:5:NaN
1978 -inf:5:NaN
1979 inf:-5:NaN
1980 -inf:-5:NaN
1981 5:5:0
1982 -5:-5:0
1983 inf:inf:NaN
1984 -inf:-inf:NaN
1985 -inf:inf:NaN
1986 inf:-inf:NaN
1987 8:0:8
1988 inf:0:inf
1989 -inf:0:-inf
1990 -8:0:-8
1991 0:0:0
1992 abc:abc:NaN
1993 abc:1:abc:NaN
1994 1:abc:NaN
1995 0:1:0
1996 1:0:1
1997 0:-1:0
1998 -1:0:-1
1999 1:1:0
2000 -1:-1:0
2001 1:-1:0
2002 -1:1:0
2003 1:2:1
2004 2:1:0
2005 1000000000:9:1
2006 2000000000:9:2
2007 3000000000:9:3
2008 4000000000:9:4
2009 5000000000:9:5
2010 6000000000:9:6
2011 7000000000:9:7
2012 8000000000:9:8
2013 9000000000:9:0
2014 35500000:113:33
2015 71000000:226:66
2016 106500000:339:99
2017 1000000000:3:1
2018 10:5:0
2019 100:4:0
2020 1000:8:0
2021 10000:16:0
2022 999999999999:9:0
2023 999999999999:99:0
2024 999999999999:999:0
2025 999999999999:9999:0
2026 999999999999999:99999:0
2027 -9:+5:1
2028 +9:-5:-1
2029 -9:-5:-4
2030 -5:3:1
2031 -2:3:1
2032 4:3:1
2033 1:3:1
2034 -5:-3:-2
2035 -2:-3:-2
2036 4:-3:-2
2037 1:-3:-2
2038 4095:4095:0
2039 100041000510123:3:0
2040 152403346:12345:4321
2041 9:5:4
2042 # test shortcuts in Calc
2043 # 1ex % 9 is always == 1, 1ex % 113 is != 1 for x = (4..9), 1ex % 10 = 0
2044 1234:9:1
2045 123456:9:3
2046 12345678:9:0
2047 1234567891:9:1
2048 123456789123:9:6
2049 12345678912345:9:6
2050 1234567891234567:9:1
2051 123456789123456789:9:0
2052 1234:10:4
2053 123456:10:6
2054 12345678:10:8
2055 1234567891:10:1
2056 123456789123:10:3
2057 12345678912345:10:5
2058 1234567891234567:10:7
2059 123456789123456789:10:9
2060 1234:113:104
2061 123456:113:60
2062 12345678:113:89
2063 1234567891:113:64
2064 123456789123:113:95
2065 12345678912345:113:53
2066 1234567891234567:113:56
2067 123456789123456789:113:39
2068 # bug in bmod() not modifying the variable in place
2069 -629:5033:4404
2070 # bug in bmod() in Calc in the _div_use_div() shortcut code path,
2071 # when X == X and X was big 
2072 111111111111111111111111111111:111111111111111111111111111111:0
2073 12345678901234567890:12345678901234567890:0
2074 &bgcd
2075 inf:12:NaN
2076 -inf:12:NaN
2077 12:inf:NaN
2078 12:-inf:NaN
2079 inf:inf:NaN
2080 inf:-inf:NaN
2081 -inf:-inf:NaN
2082 abc:abc:NaN
2083 abc:+0:NaN
2084 +0:abc:NaN
2085 +0:+0:0
2086 +0:+1:1
2087 +1:+0:1
2088 +1:+1:1
2089 +2:+3:1
2090 +3:+2:1
2091 -3:+2:1
2092 -3:-2:1
2093 -144:-60:12
2094 144:-60:12
2095 144:60:12
2096 100:625:25
2097 4096:81:1
2098 1034:804:2
2099 27:90:56:1
2100 27:90:54:9
2101 &blcm
2102 abc:abc:NaN
2103 abc:+0:NaN
2104 +0:abc:NaN
2105 +0:+0:NaN
2106 +1:+0:0
2107 +0:+1:0
2108 +27:+90:270
2109 +1034:+804:415668
2110 &band
2111 abc:abc:NaN
2112 abc:0:NaN
2113 0:abc:NaN
2114 1:2:0
2115 3:2:2
2116 +8:+2:0
2117 +281474976710656:0:0
2118 +281474976710656:1:0
2119 +281474976710656:+281474976710656:281474976710656
2120 281474976710656:-1:281474976710656
2121 -2:-3:-4
2122 -1:-1:-1
2123 -6:-6:-6
2124 -7:-4:-8
2125 -7:4:0
2126 -4:7:4
2127 # negative argument is bitwise shorter than positive [perl #26559]
2128 30:-3:28
2129 123:-1:123
2130 # equal arguments are treated special, so also do some test with unequal ones
2131 0xFFFF:0xFFFF:0x0xFFFF
2132 0xFFFFFF:0xFFFFFF:0x0xFFFFFF
2133 0xFFFFFFFF:0xFFFFFFFF:0x0xFFFFFFFF
2134 0xFFFFFFFFFF:0xFFFFFFFFFF:0x0xFFFFFFFFFF
2135 0xFFFFFFFFFFFF:0xFFFFFFFFFFFF:0x0xFFFFFFFFFFFF
2136 0xF0F0:0xF0F0:0x0xF0F0
2137 0x0F0F:0x0F0F:0x0x0F0F
2138 0xF0F0F0:0xF0F0F0:0x0xF0F0F0
2139 0x0F0F0F:0x0F0F0F:0x0x0F0F0F
2140 0xF0F0F0F0:0xF0F0F0F0:0x0xF0F0F0F0
2141 0x0F0F0F0F:0x0F0F0F0F:0x0x0F0F0F0F
2142 0xF0F0F0F0F0:0xF0F0F0F0F0:0x0xF0F0F0F0F0
2143 0x0F0F0F0F0F:0x0F0F0F0F0F:0x0x0F0F0F0F0F
2144 0xF0F0F0F0F0F0:0xF0F0F0F0F0F0:0x0xF0F0F0F0F0F0
2145 0x0F0F0F0F0F0F:0x0F0F0F0F0F0F:0x0x0F0F0F0F0F0F
2146 0x1F0F0F0F0F0F:0x3F0F0F0F0F0F:0x0x1F0F0F0F0F0F
2147 &bior
2148 abc:abc:NaN
2149 abc:0:NaN
2150 0:abc:NaN
2151 1:2:3
2152 +8:+2:10
2153 +281474976710656:0:281474976710656
2154 +281474976710656:1:281474976710657
2155 +281474976710656:281474976710656:281474976710656
2156 -2:-3:-1
2157 -1:-1:-1
2158 -6:-6:-6
2159 -7:4:-3
2160 -4:7:-1
2161 +281474976710656:-1:-1
2162 30:-3:-1
2163 30:-4:-2
2164 300:-76:-68
2165 -76:300:-68
2166 # equal arguments are treated special, so also do some test with unequal ones
2167 0xFFFF:0xFFFF:0x0xFFFF
2168 0xFFFFFF:0xFFFFFF:0x0xFFFFFF
2169 0xFFFFFFFF:0xFFFFFFFF:0x0xFFFFFFFF
2170 0xFFFFFFFFFF:0xFFFFFFFFFF:0x0xFFFFFFFFFF
2171 0xFFFFFFFFFFFF:0xFFFFFFFFFFFF:0x0xFFFFFFFFFFFF
2172 0:0xFFFF:0x0xFFFF
2173 0:0xFFFFFF:0x0xFFFFFF
2174 0:0xFFFFFFFF:0x0xFFFFFFFF
2175 0:0xFFFFFFFFFF:0x0xFFFFFFFFFF
2176 0:0xFFFFFFFFFFFF:0x0xFFFFFFFFFFFF
2177 0xFFFF:0:0x0xFFFF
2178 0xFFFFFF:0:0x0xFFFFFF
2179 0xFFFFFFFF:0:0x0xFFFFFFFF
2180 0xFFFFFFFFFF:0:0x0xFFFFFFFFFF
2181 0xFFFFFFFFFFFF:0:0x0xFFFFFFFFFFFF
2182 0xF0F0:0xF0F0:0x0xF0F0
2183 0x0F0F:0x0F0F:0x0x0F0F
2184 0xF0F0:0x0F0F:0x0xFFFF
2185 0xF0F0F0:0xF0F0F0:0x0xF0F0F0
2186 0x0F0F0F:0x0F0F0F:0x0x0F0F0F
2187 0x0F0F0F:0xF0F0F0:0x0xFFFFFF
2188 0xF0F0F0F0:0xF0F0F0F0:0x0xF0F0F0F0
2189 0x0F0F0F0F:0x0F0F0F0F:0x0x0F0F0F0F
2190 0x0F0F0F0F:0xF0F0F0F0:0x0xFFFFFFFF
2191 0xF0F0F0F0F0:0xF0F0F0F0F0:0x0xF0F0F0F0F0
2192 0x0F0F0F0F0F:0x0F0F0F0F0F:0x0x0F0F0F0F0F
2193 0x0F0F0F0F0F:0xF0F0F0F0F0:0x0xFFFFFFFFFF
2194 0xF0F0F0F0F0F0:0xF0F0F0F0F0F0:0x0xF0F0F0F0F0F0
2195 0x0F0F0F0F0F0F:0x0F0F0F0F0F0F:0x0x0F0F0F0F0F0F
2196 0x0F0F0F0F0F0F:0xF0F0F0F0F0F0:0x0xFFFFFFFFFFFF
2197 0x1F0F0F0F0F0F:0xF0F0F0F0F0F0:0x0xFFFFFFFFFFFF
2198 &bxor
2199 abc:abc:NaN
2200 abc:0:NaN
2201 0:abc:NaN
2202 1:2:3
2203 +8:+2:10
2204 +281474976710656:0:281474976710656
2205 +281474976710656:1:281474976710657
2206 +281474976710656:281474976710656:0
2207 -2:-3:3
2208 -1:-1:0
2209 -6:-6:0
2210 -7:4:-3
2211 -4:7:-5
2212 4:-7:-3
2213 -4:-7:5
2214 30:-3:-29
2215 30:-4:-30
2216 300:-76:-360
2217 -76:300:-360
2218 # equal arguments are treated special, so also do some test with unequal ones
2219 0xFFFF:0xFFFF:0
2220 0xFFFFFF:0xFFFFFF:0
2221 0xFFFFFFFF:0xFFFFFFFF:0
2222 0xFFFFFFFFFF:0xFFFFFFFFFF:0
2223 0xFFFFFFFFFFFF:0xFFFFFFFFFFFF:0
2224 0:0xFFFF:0x0xFFFF
2225 0:0xFFFFFF:0x0xFFFFFF
2226 0:0xFFFFFFFF:0x0xFFFFFFFF
2227 0:0xFFFFFFFFFF:0x0xFFFFFFFFFF
2228 0:0xFFFFFFFFFFFF:0x0xFFFFFFFFFFFF
2229 0xFFFF:0:0x0xFFFF
2230 0xFFFFFF:0:0x0xFFFFFF
2231 0xFFFFFFFF:0:0x0xFFFFFFFF
2232 0xFFFFFFFFFF:0:0x0xFFFFFFFFFF
2233 0xFFFFFFFFFFFF:0:0x0xFFFFFFFFFFFF
2234 0xF0F0:0xF0F0:0
2235 0x0F0F:0x0F0F:0
2236 0xF0F0:0x0F0F:0x0xFFFF
2237 0xF0F0F0:0xF0F0F0:0
2238 0x0F0F0F:0x0F0F0F:0
2239 0x0F0F0F:0xF0F0F0:0x0xFFFFFF
2240 0xF0F0F0F0:0xF0F0F0F0:0
2241 0x0F0F0F0F:0x0F0F0F0F:0
2242 0x0F0F0F0F:0xF0F0F0F0:0x0xFFFFFFFF
2243 0xF0F0F0F0F0:0xF0F0F0F0F0:0
2244 0x0F0F0F0F0F:0x0F0F0F0F0F:0
2245 0x0F0F0F0F0F:0xF0F0F0F0F0:0x0xFFFFFFFFFF
2246 0xF0F0F0F0F0F0:0xF0F0F0F0F0F0:0
2247 0x0F0F0F0F0F0F:0x0F0F0F0F0F0F:0
2248 0x0F0F0F0F0F0F:0xF0F0F0F0F0F0:0x0xFFFFFFFFFFFF
2249 &bnot
2250 abc:NaN
2251 +0:-1
2252 +8:-9
2253 +281474976710656:-281474976710657
2254 -1:0
2255 -2:1
2256 -12:11
2257 &digit
2258 0:0:0
2259 12:0:2
2260 12:1:1
2261 123:0:3
2262 123:1:2
2263 123:2:1
2264 123:-1:1
2265 123:-2:2
2266 123:-3:3
2267 123456:0:6
2268 123456:1:5
2269 123456:2:4
2270 123456:3:3
2271 123456:4:2
2272 123456:5:1
2273 123456:-1:1
2274 123456:-2:2
2275 123456:-3:3
2276 100000:-3:0
2277 100000:0:0
2278 100000:1:0
2279 &mantissa
2280 abc:NaN
2281 1e4:1
2282 2e0:2
2283 123:123
2284 -1:-1
2285 -2:-2
2286 +inf:inf
2287 -inf:-inf
2288 &exponent
2289 abc:NaN
2290 1e4:4
2291 2e0:0
2292 123:0
2293 -1:0
2294 -2:0
2295 0:1
2296 +inf:inf
2297 -inf:inf
2298 &parts
2299 abc:NaN,NaN
2300 1e4:1,4
2301 2e0:2,0
2302 123:123,0
2303 -1:-1,0
2304 -2:-2,0
2305 0:0,1
2306 +inf:inf,inf
2307 -inf:-inf,inf
2308 &bfac
2309 -1:NaN
2310 NaNfac:NaN
2311 +inf:inf
2312 -inf:NaN
2313 0:1
2314 1:1
2315 2:2
2316 3:6
2317 4:24
2318 5:120
2319 6:720
2320 7:5040
2321 8:40320
2322 9:362880
2323 10:3628800
2324 11:39916800
2325 12:479001600
2326 20:2432902008176640000
2327 22:1124000727777607680000
2328 69:171122452428141311372468338881272839092270544893520369393648040923257279754140647424000000000000000
2329 &bpow
2330 abc:12:NaN
2331 12:abc:NaN
2332 0:0:1
2333 0:1:0
2334 0:2:0
2335 0:-1:inf
2336 0:-2:inf
2337 1:0:1
2338 1:1:1
2339 1:2:1
2340 1:3:1
2341 1:-1:1
2342 1:-2:1
2343 1:-3:1
2344 2:0:1
2345 2:1:2
2346 2:2:4
2347 2:3:8
2348 3:3:27
2349 -2:2:4
2350 -2:3:-8
2351 -2:4:16
2352 -2:5:-32
2353 2:-1:NaN
2354 -2:-1:NaN
2355 2:-2:NaN
2356 -2:-2:NaN
2357 # inf tests
2358 +inf:1234500012:inf
2359 -inf:1234500012:inf
2360 -inf:1234500013:-inf
2361 +inf:-12345000123:inf
2362 -inf:-12345000123:-inf
2363 #  -inf * -inf = inf
2364 -inf:2:inf
2365 -inf:0:NaN
2366 -inf:-1:0
2367 -inf:inf:NaN
2368 2:inf:inf
2369 2:-inf:0
2370 0:inf:0
2371 0:-inf:inf
2372 -1:-inf:NaN
2373 -1:inf:NaN
2374 -2:inf:NaN
2375 -2:-inf:0
2376 NaN:inf:NaN
2377 NaN:-inf:NaN
2378 -inf:NaN:NaN
2379 inf:NaN:NaN
2380 inf:-inf:NaN
2381 1:inf:1
2382 1:-inf:1
2383 # 1 ** -x => 1 / (1 ** x)
2384 -1:0:1
2385 -2:0:1
2386 -1:1:-1
2387 -1:2:1
2388 -1:3:-1
2389 -1:4:1
2390 -1:5:-1
2391 -1:-1:-1
2392 -1:-2:1
2393 -1:-3:-1
2394 -1:-4:1
2395 10:2:100
2396 10:3:1000
2397 10:4:10000
2398 10:5:100000
2399 10:6:1000000
2400 10:7:10000000
2401 10:8:100000000
2402 10:9:1000000000
2403 10:20:100000000000000000000
2404 123456:2:15241383936
2405 -2:2:4
2406 -2:3:-8
2407 -2:4:16
2408 -2:5:-32
2409 -3:2:9
2410 -3:3:-27
2411 -3:4:81
2412 -3:5:-243
2413 &length
2414 100:3
2415 10:2
2416 1:1
2417 0:1
2418 12345:5
2419 10000000000000000:17
2420 -123:3
2421 215960156869840440586892398248:30
2422 &broot
2423 # sqrt()
2424 +0:2:0
2425 +1:2:1
2426 -1:2:NaN
2427 # -$x ** (1/2) => -$y, but not in froot()
2428 -123:2:NaN
2429 +inf:2:inf
2430 -inf:2:NaN
2431 2:2:1
2432 -2:2:NaN
2433 4:2:2
2434 9:2:3
2435 16:2:4
2436 100:2:10
2437 123:2:11
2438 15241:2:123
2439 144:2:12
2440 12:2:3
2441 # invalid ones
2442 1:NaN:NaN
2443 -1:NaN:NaN
2444 0:NaN:NaN
2445 -inf:NaN:NaN
2446 +inf:NaN:NaN
2447 NaN:0:NaN
2448 NaN:2:NaN
2449 NaN:inf:NaN
2450 NaN:inf:NaN
2451 12:-inf:NaN
2452 12:inf:NaN
2453 +0:0:NaN
2454 +1:0:NaN
2455 -1:0:NaN
2456 -2:0:NaN
2457 -123.45:0:NaN
2458 +inf:0:NaN
2459 12:1:12
2460 -12:1:NaN
2461 8:-1:NaN
2462 -8:-1:NaN
2463 # cubic root
2464 8:3:2
2465 -8:3:NaN
2466 # fourths root
2467 16:4:2
2468 81:4:3
2469 # 2 ** 64
2470 18446744073709551616:4:65536
2471 18446744073709551616:8:256
2472 18446744073709551616:16:16
2473 18446744073709551616:32:4
2474 18446744073709551616:64:2
2475 18446744073709551616:128:1
2476 # 213 ** 15
2477 84274086103068221283760416414557757:15:213
2478 # see t/bigroot.t for more tests
2479 &bsqrt
2480 145:12
2481 144:12
2482 143:11
2483 16:4
2484 170:13
2485 169:13
2486 168:12
2487 4:2
2488 3:1
2489 2:1
2490 9:3
2491 12:3
2492 256:16
2493 100000000:10000
2494 4000000000000:2000000
2495 152399026:12345
2496 152399025:12345
2497 152399024:12344
2498 # 2 ** 64 => 2 ** 32
2499 18446744073709551616:4294967296
2500 84274086103068221283760416414557757:290299993288095377
2501 1:1
2502 0:0
2503 -2:NaN
2504 -123:NaN
2505 Nan:NaN
2506 +inf:inf
2507 -inf:NaN
2508 # see t/biglog.t for more tests
2509 &bexp
2510 NaN:NaN
2511 inf:inf
2512 1:2
2513 2:7
2514 &batan2
2515 NaN:1:10:NaN
2516 NaN:NaN:10:NaN
2517 1:NaN:10:NaN
2518 inf:1:14:1
2519 -inf:1:14:-1
2520 0:-inf:14:3
2521 -1:-inf:14:-3
2522 1:-inf:14:3
2523 0:inf:14:0
2524 inf:-inf:14:2
2525 -inf:-inf:14:-2
2526 # +- 0.78....
2527 inf:+inf:14:0
2528 -inf:+inf:14:0
2529 1:5:13:0
2530 1:5:14:0
2531 0:0:10:0
2532 0:1:14:0
2533 0:2:14:0
2534 1:0:14:1
2535 5:0:14:1
2536 -1:0:11:-1
2537 -2:0:77:-1
2538 2:0:77:1
2539 -1:5:14:0
2540 1:5:14:0
2541 -1:8:14:0
2542 1:8:14:0
2543 -1:1:14:0
2544 &bpi
2545 77:3
2546 +0:3
2547 11:3
2548 # see t/bignok.t for more tests
2549 &bnok
2550 +inf:10:inf
2551 NaN:NaN:NaN
2552 NaN:1:NaN
2553 1:NaN:NaN
2554 1:1:1
2555 # k > n
2556 1:2:0
2557 2:3:0
2558 # k < 0
2559 1:-2:0
2560 # 7 over 3 = 35
2561 7:3:35
2562 7:6:7
2563 100:90:17310309456440
2564 100:95:75287520
2565 2:0:1
2566 7:0:1
2567 2:1:2
2568 &bround
2569 $round_mode('trunc')
2570 0:12:0
2571 NaNbround:12:NaN
2572 +inf:12:inf
2573 -inf:12:-inf
2574 1234:0:1234
2575 1234:2:1200
2576 123456:4:123400
2577 123456:5:123450
2578 123456:6:123456
2579 +10123456789:5:10123000000
2580 -10123456789:5:-10123000000
2581 +10123456789:9:10123456700
2582 -10123456789:9:-10123456700
2583 +101234500:6:101234000
2584 -101234500:6:-101234000
2585 #+101234500:-4:101234000
2586 #-101234500:-4:-101234000
2587 $round_mode('zero')
2588 +20123456789:5:20123000000
2589 -20123456789:5:-20123000000
2590 +20123456789:9:20123456800
2591 -20123456789:9:-20123456800
2592 +201234500:6:201234000
2593 -201234500:6:-201234000
2594 #+201234500:-4:201234000
2595 #-201234500:-4:-201234000
2596 +12345000:4:12340000
2597 -12345000:4:-12340000
2598 $round_mode('+inf')
2599 +30123456789:5:30123000000
2600 -30123456789:5:-30123000000
2601 +30123456789:9:30123456800
2602 -30123456789:9:-30123456800
2603 +301234500:6:301235000
2604 -301234500:6:-301234000
2605 #+301234500:-4:301235000
2606 #-301234500:-4:-301234000
2607 +12345000:4:12350000
2608 -12345000:4:-12340000
2609 $round_mode('-inf')
2610 +40123456789:5:40123000000
2611 -40123456789:5:-40123000000
2612 +40123456789:9:40123456800
2613 -40123456789:9:-40123456800
2614 +401234500:6:401234000
2615 +401234500:6:401234000
2616 #-401234500:-4:-401235000
2617 #-401234500:-4:-401235000
2618 +12345000:4:12340000
2619 -12345000:4:-12350000
2620 $round_mode('odd')
2621 +50123456789:5:50123000000
2622 -50123456789:5:-50123000000
2623 +50123456789:9:50123456800
2624 -50123456789:9:-50123456800
2625 +501234500:6:501235000
2626 -501234500:6:-501235000
2627 #+501234500:-4:501235000
2628 #-501234500:-4:-501235000
2629 +12345000:4:12350000
2630 -12345000:4:-12350000
2631 $round_mode('even')
2632 +60123456789:5:60123000000
2633 -60123456789:5:-60123000000
2634 +60123456789:9:60123456800
2635 -60123456789:9:-60123456800
2636 +601234500:6:601234000
2637 -601234500:6:-601234000
2638 #+601234500:-4:601234000
2639 #-601234500:-4:-601234000
2640 #-601234500:-9:0
2641 #-501234500:-9:0
2642 #-601234500:-8:0
2643 #-501234500:-8:0
2644 +1234567:7:1234567
2645 +1234567:6:1234570
2646 +12345000:4:12340000
2647 -12345000:4:-12340000
2648 $round_mode('common')
2649 +60123456789:5:60123000000
2650 +60123199999:5:60123000000
2651 +60123299999:5:60123000000
2652 +60123399999:5:60123000000
2653 +60123499999:5:60123000000
2654 +60123500000:5:60124000000
2655 +60123600000:5:60124000000
2656 +60123700000:5:60124000000
2657 +60123800000:5:60124000000
2658 +60123900000:5:60124000000
2659 -60123456789:5:-60123000000
2660 -60123199999:5:-60123000000
2661 -60123299999:5:-60123000000
2662 -60123399999:5:-60123000000
2663 -60123499999:5:-60123000000
2664 -60123500000:5:-60124000000
2665 -60123600000:5:-60124000000
2666 -60123700000:5:-60124000000
2667 -60123800000:5:-60124000000
2668 -60123900000:5:-60124000000
2669 &is_zero
2670 0:1
2671 NaNzero:0
2672 +inf:0
2673 -inf:0
2674 123:0
2675 -1:0
2676 1:0
2677 &is_one
2678 0:0
2679 NaNone:0
2680 +inf:0
2681 -inf:0
2682 1:1
2683 2:0
2684 -1:0
2685 -2:0
2686 # floor, ceil, and int are pretty pointless in integer space, but play safe
2687 &bfloor
2688 0:0
2689 NaNfloor:NaN
2690 +inf:inf
2691 -inf:-inf
2692 -1:-1
2693 -2:-2
2694 2:2
2695 3:3
2696 abc:NaN
2697 &bceil
2698 NaNceil:NaN
2699 +inf:inf
2700 -inf:-inf
2701 0:0
2702 -1:-1
2703 -2:-2
2704 2:2
2705 3:3
2706 abc:NaN
2707 &bint
2708 NaN:NaN
2709 +inf:inf
2710 -inf:-inf
2711 0:0
2712 -1:-1
2713 -2:-2
2714 2:2
2715 3:3
2716 &as_hex
2717 128:0x80
2718 -128:-0x80
2719 0:0x0
2720 -0:0x0
2721 1:0x1
2722 0x123456789123456789:0x123456789123456789
2723 +inf:inf
2724 -inf:-inf
2725 NaNas_hex:NaN
2726 &as_bin
2727 128:0b10000000
2728 -128:-0b10000000
2729 0:0b0
2730 -0:0b0
2731 1:0b1
2732 0b1010111101010101010110110110110110101:0b1010111101010101010110110110110110101
2733 0x123456789123456789:0b100100011010001010110011110001001000100100011010001010110011110001001
2734 +inf:inf
2735 -inf:-inf
2736 NaNas_bin:NaN
2737 # overloaded functions
2738 &log
2739 -1:NaN
2740 0:-inf
2741 1:0
2742 2:0
2743 3:1
2744 123456789:18
2745 1234567890987654321:41
2746 -inf:inf
2747 inf:inf
2748 NaN:NaN
2749 &exp
2750 &sin
2751 &cos
2752 &atan2
2753 &int
2754 &neg
2755 &abs
2756 &sqrt