This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
Upgrade to Math::BigInt 1.42.
[perl5.git] / lib / Math / BigInt / t / bigintpm.t
1 #!/usr/bin/perl -w
2
3 use strict;
4 use Test;
5
6 BEGIN 
7   {
8   $| = 1;
9   # chdir 't' if -d 't';
10   unshift @INC, '../lib'; # for running manually
11   plan tests => 1447;
12   }
13 my $version = '1.42';   # for $VERSION tests, match current release (by hand!)
14
15 ##############################################################################
16 # for testing inheritance of _swap
17
18 package Math::Foo;
19
20 use Math::BigInt;
21 #use Math::BigInt lib => 'BitVect';     # for testing
22 use vars qw/@ISA/;
23 @ISA = (qw/Math::BigInt/);
24
25 use overload
26 # customized overload for sub, since original does not use swap there
27 '-'     =>      sub { my @a = ref($_[0])->_swap(@_);
28                    $a[0]->bsub($a[1])};
29
30 sub _swap
31   {
32   # a fake _swap, which reverses the params
33   my $self = shift;                     # for override in subclass
34   if ($_[2])
35     {
36     my $c = ref ($_[0] ) || 'Math::Foo';
37     return ( $_[0]->copy(), $_[1] );
38     }
39   else
40     {
41     return ( Math::Foo->new($_[1]), $_[0] );
42     }
43   }
44
45 ##############################################################################
46 package main;
47
48 use Math::BigInt;
49 #use Math::BigInt lib => 'BitVect';     # for testing
50
51 my $CALC = Math::BigInt::_core_lib(); ok ($CALC,'Math::BigInt::Calc');
52
53 my (@args,$f,$try,$x,$y,$z,$a,$exp,$ans,$ans1,@a,$m,$e,$round_mode);
54
55 while (<DATA>) 
56   {
57   chop;
58   next if /^#/; # skip comments
59   if (s/^&//) 
60     {
61     $f = $_;
62     }
63   elsif (/^\$/) 
64     {
65     $round_mode = $_;
66     $round_mode =~ s/^\$/Math::BigInt->/;
67     # print "$round_mode\n";
68     }
69   else 
70     {
71     @args = split(/:/,$_,99);
72     $ans = pop(@args);
73     $try = "\$x = Math::BigInt->new(\"$args[0]\");";
74     if ($f eq "bnorm"){
75       # $try .= '$x+0;';
76     } elsif ($f eq "is_zero") {
77       $try .= '$x->is_zero()+0;';
78     } elsif ($f eq "is_one") {
79       $try .= '$x->is_one()+0;';
80     } elsif ($f eq "is_odd") {
81       $try .= '$x->is_odd()+0;';
82     } elsif ($f eq "is_even") {
83       $try .= '$x->is_even()+0;';
84     } elsif ($f eq "is_negative") {
85       $try .= '$x->is_negative()+0;';
86     } elsif ($f eq "is_positive") {
87       $try .= '$x->is_positive()+0;';
88     } elsif ($f eq "as_hex") {
89       $try .= '$x->as_hex();';
90     } elsif ($f eq "as_bin") {
91       $try .= '$x->as_bin();';
92     } elsif ($f eq "is_inf") {
93       $try .= "\$x->is_inf('$args[1]')+0;";
94     } elsif ($f eq "binf") {
95       $try .= "\$x->binf('$args[1]');";
96     } elsif ($f eq "bone") {
97       $try .= "\$x->bone('$args[1]');";
98     } elsif ($f eq "bnan") {
99       $try .= "\$x->bnan();";
100     } elsif ($f eq "bfloor") {
101       $try .= '$x->bfloor();';
102     } elsif ($f eq "bceil") {
103       $try .= '$x->bceil();';
104     } elsif ($f eq "bsstr") {
105       $try .= '$x->bsstr();';
106     } elsif ($f eq "bneg") {
107       $try .= '$x->bneg();';
108     } elsif ($f eq "babs") {
109       $try .= '$x->babs();';
110     } elsif ($f eq "binc") {
111       $try .= '++$x;'; 
112     } elsif ($f eq "bdec") {
113       $try .= '--$x;'; 
114     }elsif ($f eq "bnot") {
115       $try .= '~$x;';
116     }elsif ($f eq "bsqrt") {
117       $try .= '$x->bsqrt();';
118     }elsif ($f eq "length") {
119       $try .= "\$x->length();";
120     }elsif ($f eq "exponent"){
121       $try .= '$x = $x->exponent()->bstr();';
122     }elsif ($f eq "mantissa"){
123       $try .= '$x = $x->mantissa()->bstr();';
124     }elsif ($f eq "parts"){
125       $try .= "(\$m,\$e) = \$x->parts();"; 
126       $try .= '$m = $m->bstr(); $m = "NaN" if !defined $m;';
127       $try .= '$e = $e->bstr(); $e = "NaN" if !defined $e;';
128       $try .= '"$m,$e";';
129     } else {
130       $try .= "\$y = new Math::BigInt ('$args[1]');";
131       if ($f eq "bcmp"){
132         $try .= '$x <=> $y;';
133       }elsif ($f eq "bround") {
134       $try .= "$round_mode; \$x->bround(\$y);";
135       }elsif ($f eq "bacmp"){
136         $try .= "\$x->bacmp(\$y);";
137       }elsif ($f eq "badd"){
138         $try .= "\$x + \$y;";
139       }elsif ($f eq "bsub"){
140         $try .= "\$x - \$y;";
141       }elsif ($f eq "bmul"){
142         $try .= "\$x * \$y;";
143       }elsif ($f eq "bdiv"){
144         $try .= "\$x / \$y;";
145       }elsif ($f eq "bdiv-list"){
146         $try .= 'join (",",$x->bdiv($y));';
147       }elsif ($f eq "bmod"){
148         $try .= "\$x % \$y;";
149       }elsif ($f eq "bgcd")
150         {
151         if (defined $args[2])
152           {
153           $try .= " \$z = new Math::BigInt \"$args[2]\"; ";
154           }
155         $try .= "Math::BigInt::bgcd(\$x, \$y";
156         $try .= ", \$z" if (defined $args[2]);
157         $try .= " );";
158         }
159       elsif ($f eq "blcm")
160         {
161         if (defined $args[2])
162           {
163           $try .= " \$z = new Math::BigInt \"$args[2]\"; ";
164           }
165         $try .= "Math::BigInt::blcm(\$x, \$y";
166         $try .= ", \$z" if (defined $args[2]);
167         $try .= " );";
168       }elsif ($f eq "blsft"){
169         if (defined $args[2])
170           {
171           $try .= "\$x->blsft(\$y,$args[2]);";
172           }
173         else
174           {
175           $try .= "\$x << \$y;";
176           }
177       }elsif ($f eq "brsft"){
178         if (defined $args[2])
179           {
180           $try .= "\$x->brsft(\$y,$args[2]);";
181           }
182         else
183           {
184           $try .= "\$x >> \$y;";
185           }
186       }elsif ($f eq "band"){
187         $try .= "\$x & \$y;";
188       }elsif ($f eq "bior"){
189         $try .= "\$x | \$y;";
190       }elsif ($f eq "bxor"){
191         $try .= "\$x ^ \$y;";
192       }elsif ($f eq "bpow"){
193         $try .= "\$x ** \$y;";
194       }elsif ($f eq "digit"){
195         $try = "\$x = Math::BigInt->new(\"$args[0]\"); \$x->digit($args[1]);";
196       } else { warn "Unknown op '$f'"; }
197     }
198     # print "trying $try\n";
199     $ans1 = eval $try;
200     $ans =~ s/^[+]([0-9])/$1/;          # remove leading '+' 
201     if ($ans eq "")
202       {
203       ok_undef ($ans1); 
204       }
205     else
206       {
207       #print "try: $try ans: $ans1 $ans\n";
208       print "# Tried: '$try'\n" if !ok ($ans1, $ans);
209       }
210     # check internal state of number objects
211     is_valid($ans1,$f) if ref $ans1; 
212     }
213   } # endwhile data tests
214 close DATA;
215
216 # XXX Tels 06/29/2001 following tests never fail or do not work :( !?
217
218 # test whether use Math::BigInt qw/version/ works
219 $try = "use Math::BigInt ($version.'1');";
220 $try .= ' $x = Math::BigInt->new(123); $x = "$x";';
221 $ans1 = eval $try;
222 ok_undef ( $_ );                # should result in error!
223
224 # test whether constant works or not, also test for qw($version)
225 $try = "use Math::BigInt ($version,'babs',':constant');";
226 $try .= ' $x = 2**150; babs($x); $x = "$x";';
227 $ans1 = eval $try;
228 ok ( $ans1, "1427247692705959881058285969449495136382746624");
229
230 # test wether Math::BigInt::Small via use works (w/ dff. spellings of calc)
231 #$try = "use Math::BigInt ($version,'lib','Small');";
232 #$try .= ' $x = 2**10; $x = "$x";';
233 #$ans1 = eval $try;
234 #ok ( $ans1, "1024");
235 #$try = "use Math::BigInt ($version,'LiB','Math::BigInt::Small');";
236 #$try .= ' $x = 2**10; $x = "$x";';
237 #$ans1 = eval $try;
238 #ok ( $ans1, "1024");
239 # test wether calc => undef (array element not existing) works
240 #$try = "use Math::BigInt ($version,'LIB');";
241 #$try = "require Math::BigInt; Math::BigInt::import($version,'CALC');";
242 #$try .= ' $x = Math::BigInt->new(2)**10; $x = "$x";';
243 #$ans1 = eval $try;
244 #ok ( $ans1, 1024);
245
246 # test whether fallback to calc works
247 $try = "use Math::BigInt ($version,'lib','foo, bar , ');";
248 $try .= ' Math::BigInt::_core_lib();';
249 $ans1 = eval $try;
250 ok ( $ans1, "Math::BigInt::Calc");
251
252 # test some more
253 @a = ();
254 for (my $i = 1; $i < 10; $i++) 
255   {
256   push @a, $i;
257   }
258 ok "@a", "1 2 3 4 5 6 7 8 9";
259
260 # test whether self-multiplication works correctly (result is 2**64)
261 $try = '$x = new Math::BigInt "+4294967296";';
262 $try .= '$a = $x->bmul($x);';
263 $ans1 = eval $try;
264 print "# Tried: '$try'\n" if !ok ($ans1, Math::BigInt->new(2) ** 64);
265 # test self-pow
266 $try = '$x = Math::BigInt->new(10);';
267 $try .= '$a = $x->bpow($x);';
268 $ans1 = eval $try;
269 print "# Tried: '$try'\n" if !ok ($ans1, Math::BigInt->new(10) ** 10);
270
271 # test whether op destroys args or not (should better not)
272
273 $x = new Math::BigInt (3);
274 $y = new Math::BigInt (4);
275 $z = $x & $y;
276 ok ($x,3);
277 ok ($y,4);
278 ok ($z,0);
279 $z = $x | $y;
280 ok ($x,3);
281 ok ($y,4);
282 ok ($z,7);
283 $x = new Math::BigInt (1);
284 $y = new Math::BigInt (2);
285 $z = $x | $y;
286 ok ($x,1);
287 ok ($y,2);
288 ok ($z,3);
289
290 $x = new Math::BigInt (5);
291 $y = new Math::BigInt (4);
292 $z = $x ^ $y;
293 ok ($x,5);
294 ok ($y,4);
295 ok ($z,1);
296
297 $x = new Math::BigInt (-5); $y = -$x;
298 ok ($x, -5);
299
300 $x = new Math::BigInt (-5); $y = abs($x);
301 ok ($x, -5);
302
303 # check whether overloading cmp works
304 $try = "\$x = Math::BigInt->new(0);";
305 $try .= "\$y = 10;";
306 $try .= "'false' if \$x ne \$y;";
307 $ans = eval $try;
308 print "# For '$try'\n" if (!ok "$ans" , "false" ); 
309
310 # we cant test for working cmpt with other objects here, we would need a dummy
311 # object with stringify overload for this. see Math::String tests
312
313 ###############################################################################
314 # check shortcuts
315 $try = "\$x = Math::BigInt->new(1); \$x += 9;";
316 $try .= "'ok' if \$x == 10;";
317 $ans = eval $try;
318 print "# For '$try'\n" if (!ok "$ans" , "ok" ); 
319
320 $try = "\$x = Math::BigInt->new(1); \$x -= 9;";
321 $try .= "'ok' if \$x == -8;";
322 $ans = eval $try;
323 print "# For '$try'\n" if (!ok "$ans" , "ok" ); 
324
325 $try = "\$x = Math::BigInt->new(1); \$x *= 9;";
326 $try .= "'ok' if \$x == 9;";
327 $ans = eval $try;
328 print "# For '$try'\n" if (!ok "$ans" , "ok" ); 
329
330 $try = "\$x = Math::BigInt->new(10); \$x /= 2;";
331 $try .= "'ok' if \$x == 5;";
332 $ans = eval $try;
333 print "# For '$try'\n" if (!ok "$ans" , "ok" ); 
334
335 ###############################################################################
336 # check reversed order of arguments
337 $try = "\$x = Math::BigInt->new(10); \$x = 2 ** \$x;";
338 $try .= "'ok' if \$x == 1024;"; $ans = eval $try;
339 print "# For '$try'\n" if (!ok "$ans" , "ok" ); 
340
341 $try = "\$x = Math::BigInt->new(10); \$x = 2 * \$x;";
342 $try .= "'ok' if \$x == 20;"; $ans = eval $try;
343 print "# For '$try'\n" if (!ok "$ans" , "ok" ); 
344
345 $try = "\$x = Math::BigInt->new(10); \$x = 2 + \$x;";
346 $try .= "'ok' if \$x == 12;"; $ans = eval $try;
347 print "# For '$try'\n" if (!ok "$ans" , "ok" ); 
348
349 $try = "\$x = Math::BigInt->new(10); \$x = 2 - \$x;";
350 $try .= "'ok' if \$x == -8;"; $ans = eval $try;
351 print "# For '$try'\n" if (!ok "$ans" , "ok" ); 
352
353 $try = "\$x = Math::BigInt->new(10); \$x = 20 / \$x;";
354 $try .= "'ok' if \$x == 2;"; $ans = eval $try;
355 print "# For '$try'\n" if (!ok "$ans" , "ok" ); 
356
357 ###############################################################################
358 # check badd(4,5) form
359
360 $try = "\$x = Math::BigInt::badd(4,5);";
361 $try .= "'ok' if \$x == 9;";
362 $ans = eval $try;
363 print "# For '$try'\n" if (!ok "$ans" , "ok" ); 
364
365 $try = "\$x = Math::BigInt->badd(4,5);";
366 $try .= "'ok' if \$x == 9;";
367 $ans = eval $try;
368 print "# For '$try'\n" if (!ok "$ans" , "ok" ); 
369
370 ###############################################################################
371 # the followin tests only make sense with Math::BigInt::Calc
372
373 ###############################################################################
374 # check proper length of internal arrays
375
376 $x = Math::BigInt->new(99999); is_valid($x);
377 $x += 1; ok ($x,100000); is_valid($x); 
378 $x -= 1; ok ($x,99999); is_valid($x); 
379
380 ###############################################################################
381 # check numify
382
383 my $BASE = int(1e5);            # should access Math::BigInt::Calc::BASE
384 $x = Math::BigInt->new($BASE-1);     ok ($x->numify(),$BASE-1); 
385 $x = Math::BigInt->new(-($BASE-1));  ok ($x->numify(),-($BASE-1)); 
386 $x = Math::BigInt->new($BASE);       ok ($x->numify(),$BASE); 
387 $x = Math::BigInt->new(-$BASE);      ok ($x->numify(),-$BASE);
388 $x = Math::BigInt->new( -($BASE*$BASE*1+$BASE*1+1) ); 
389 ok($x->numify(),-($BASE*$BASE*1+$BASE*1+1)); 
390
391 ###############################################################################
392 # test bug in _digits with length($c[-1]) where $c[-1] was "00001" instead of 1
393
394 $x = Math::BigInt->new(99998); $x++; $x++; $x++; $x++;
395 if ($x > 100000) { ok (1,1) } else { ok ("$x < 100000","$x > 100000"); }
396
397 $x = Math::BigInt->new(100003); $x++;
398 $y = Math::BigInt->new(1000000);
399 if ($x < 1000000) { ok (1,1) } else { ok ("$x > 1000000","$x < 1000000"); }
400
401 ###############################################################################
402 # bug in sub where number with at least 6 trailing zeros after any op failed
403
404 $x = Math::BigInt->new(123456); $z = Math::BigInt->new(10000); $z *= 10;
405 $x -= $z;
406 ok ($z, 100000);
407 ok ($x, 23456);
408
409 ###############################################################################
410 # bug in shortcut in mul()
411
412 # construct a number with a zero-hole of BASE_LEN
413 my $bl = Math::BigInt::Calc::_base_len();
414 $x = '1' x $bl . '0' x $bl . '1' x $bl . '0' x $bl;
415 $y = '1' x (2*$bl);
416 #print "$x * $y\n";
417 $x = Math::BigInt->new($x)->bmul($y);
418 # result is 123..$bl .  $bl x (3*bl-1) . $bl...321 . '0' x $bl
419 $y = ''; my $d = '';
420 for (my $i = 1; $i <= $bl; $i++)
421   {
422   $y .= $i; $d = $i.$d;
423   }
424 #print "$y $d\n";
425 $y .= $bl x (3*$bl-1) . $d . '0' x $bl;
426 ok ($x,$y);
427
428 ###############################################################################
429 # bug with rest "-0" in div, causing further div()s to fail
430
431 $x = Math::BigInt->new('-322056000'); ($x,$y) = $x->bdiv('-12882240');
432
433 ok ($y,'0','not -0');   # not '-0'
434 is_valid($y);
435
436 ###############################################################################
437 # check undefs: NOT DONE YET
438
439 ###############################################################################
440 # bool
441
442 $x = Math::BigInt->new(1); if ($x) { ok (1,1); } else { ok($x,'to be true') }
443 $x = Math::BigInt->new(0); if (!$x) { ok (1,1); } else { ok($x,'to be false') }
444
445 ###############################################################################
446 # objectify()
447
448 @args = Math::BigInt::objectify(2,4,5);
449 ok (scalar @args,3);            # 'Math::BigInt', 4, 5
450 ok ($args[0],'Math::BigInt');
451 ok ($args[1],4);
452 ok ($args[2],5);
453
454 @args = Math::BigInt::objectify(0,4,5);
455 ok (scalar @args,3);            # 'Math::BigInt', 4, 5
456 ok ($args[0],'Math::BigInt');
457 ok ($args[1],4);
458 ok ($args[2],5);
459
460 @args = Math::BigInt::objectify(2,4,5);
461 ok (scalar @args,3);            # 'Math::BigInt', 4, 5
462 ok ($args[0],'Math::BigInt');
463 ok ($args[1],4);
464 ok ($args[2],5);
465
466 @args = Math::BigInt::objectify(2,4,5,6,7);
467 ok (scalar @args,5);            # 'Math::BigInt', 4, 5, 6, 7
468 ok ($args[0],'Math::BigInt');
469 ok ($args[1],4); ok (ref($args[1]),$args[0]);
470 ok ($args[2],5); ok (ref($args[2]),$args[0]);
471 ok ($args[3],6); ok (ref($args[3]),'');
472 ok ($args[4],7); ok (ref($args[4]),'');
473
474 @args = Math::BigInt::objectify(2,'Math::BigInt',4,5,6,7);
475 ok (scalar @args,5);            # 'Math::BigInt', 4, 5, 6, 7
476 ok ($args[0],'Math::BigInt');
477 ok ($args[1],4); ok (ref($args[1]),$args[0]);
478 ok ($args[2],5); ok (ref($args[2]),$args[0]);
479 ok ($args[3],6); ok (ref($args[3]),'');
480 ok ($args[4],7); ok (ref($args[4]),'');
481
482 ###############################################################################
483 # test for floating-point input (other tests in bnorm() below)
484
485 $z = 1050000000000000;          # may be int on systems with 64bit?
486 $x = Math::BigInt->new($z); ok ($x->bsstr(),'105e+13'); # not 1.03e+15
487 $z = 1e+129;                    # definitely a float (may fail on UTS)
488 $x = Math::BigInt->new($z); ok ($x->bsstr(),$z);
489
490 ###############################################################################
491 # prime number tests, also test for **= and length()
492 # found on: http://www.utm.edu/research/primes/notes/by_year.html
493
494 # ((2^148)-1)/17
495 $x = Math::BigInt->new(2); $x **= 148; $x++; $x = $x / 17;
496 ok ($x,"20988936657440586486151264256610222593863921");
497 ok ($x->length(),length "20988936657440586486151264256610222593863921");
498
499 # MM7 = 2^127-1
500 $x = Math::BigInt->new(2); $x **= 127; $x--;
501 ok ($x,"170141183460469231731687303715884105727");
502
503 $x = Math::BigInt->new('215960156869840440586892398248');
504 ($x,$y) = $x->length();
505 ok ($x,30); ok ($y,0);
506
507 $x = Math::BigInt->new('1_000_000_000_000');
508 ($x,$y) = $x->length();
509 ok ($x,13); ok ($y,0);
510
511 # I am afraid the following is not yet possible due to slowness
512 # Also, testing for 2 meg output is a bit hard ;)
513 #$x = new Math::BigInt(2); $x **= 6972593; $x--;
514
515 # 593573509*2^332162+1 has exactly 1,000,000 digits
516 # takes about 24 mins on 300 Mhz, so cannot be done yet ;)
517 #$x = Math::BigInt->new(2); $x **= 332162; $x *= "593573509"; $x++;
518 #ok ($x->length(),1_000_000);
519
520 ###############################################################################
521 # inheritance and overriding of _swap
522
523 $x = Math::Foo->new(5);
524 $x = $x - 8;            # 8 - 5 instead of 5-8
525 ok ($x,3);
526 ok (ref($x),'Math::Foo');
527
528 $x = Math::Foo->new(5);
529 $x = 8 - $x;            # 5 - 8 instead of 8 - 5
530 ok ($x,-3);
531 ok (ref($x),'Math::Foo');
532
533 ###############################################################################
534 # Test whether +inf eq inf
535 # This tried to test whether BigInt inf equals Perl inf. Unfortunately, Perl
536 # hasn't (before 5.7.3 at least) a consistent way to say inf, and some things
537 # like 1e100000 crash on some platforms. So simple test for 'inf'
538 $x = Math::BigInt->new('+inf'); ok ($x,'inf');
539
540 ###############################################################################
541 # all tests done
542
543 ###############################################################################
544 # Perl 5.005 does not like ok ($x,undef)
545
546 sub ok_undef
547   {
548   my $x = shift;
549
550   ok (1,1) and return if !defined $x;
551   ok ($x,'undef');
552   }
553
554 ###############################################################################
555 # sub to check validity of a BigInt internally, to ensure that no op leaves a
556 # number object in an invalid state (f.i. "-0")
557
558 sub is_valid
559   {
560   my ($x,$f) = @_;
561
562   my $e = 0;                    # error?
563   # ok as reference? 
564   $e = 'Not a reference to Math::BigInt' if !ref($x);
565
566   # has ok sign?
567   $e = "Illegal sign $x->{sign} (expected: '+', '-', '-inf', '+inf' or 'NaN'"
568    if $e eq '0' && $x->{sign} !~ /^(\+|-|\+inf|-inf|NaN)$/;
569
570   $e = "-0 is invalid!" if $e ne '0' && $x->{sign} eq '-' && $x == 0;
571   $e = $CALC->_check($x->{value}) if $e eq '0';
572
573   # test done, see if error did crop up
574   ok (1,1), return if ($e eq '0');
575
576   ok (1,$e." op '$f'");
577   }
578
579 __END__
580 &is_negative
581 0:0
582 -1:1
583 1:0
584 +inf:0
585 -inf:1
586 NaNneg:0
587 &is_positive
588 0:1
589 -1:0
590 1:1
591 +inf:1
592 -inf:0
593 NaNneg:0
594 &is_odd
595 abc:0
596 0:0
597 1:1
598 3:1
599 -1:1
600 -3:1
601 10000001:1
602 10000002:0
603 2:0
604 &is_even
605 abc:0
606 0:1
607 1:0
608 3:0
609 -1:0
610 -3:0
611 10000001:0
612 10000002:1
613 2:1
614 &bacmp
615 +0:-0:0
616 +0:+1:-1
617 -1:+1:0
618 +1:-1:0
619 -1:+2:-1
620 +2:-1:1
621 -123456789:+987654321:-1
622 +123456789:-987654321:-1
623 +987654321:+123456789:1
624 -987654321:+123456789:1
625 -123:+4567889:-1
626 # NaNs
627 acmpNaN:123:
628 123:acmpNaN:
629 acmpNaN:acmpNaN:
630 # infinity
631 +inf:+inf:0
632 -inf:-inf:0
633 +inf:-inf:0
634 -inf:+inf:0
635 +inf:123:1
636 -inf:123:1
637 +inf:-123:1
638 -inf:-123:1
639 # return undef
640 +inf:NaN:
641 NaN:inf:
642 -inf:NaN:
643 NaN:-inf:
644 &bnorm
645 123:123
646 # binary input
647 0babc:NaN
648 0b123:NaN
649 0b0:0
650 -0b0:0
651 -0b1:-1
652 0b0001:1
653 0b001:1
654 0b011:3
655 0b101:5
656 0b1000000000000000000000000000000:1073741824
657 0b_101:NaN
658 0b1_0_1:5
659 # hex input
660 -0x0:0
661 0xabcdefgh:NaN
662 0x1234:4660
663 0xabcdef:11259375
664 -0xABCDEF:-11259375
665 -0x1234:-4660
666 0x12345678:305419896
667 0x1_2_3_4_56_78:305419896
668 0x_123:NaN
669 # inf input
670 +inf:inf
671 -inf:-inf
672 0inf:NaN
673 # normal input
674 :NaN
675 abc:NaN
676    1 a:NaN
677 1bcd2:NaN
678 11111b:NaN
679 +1z:NaN
680 -1z:NaN
681 0:0
682 +0:0
683 +00:0
684 +000:0
685 000000000000000000:0
686 -0:0
687 -0000:0
688 +1:1
689 +01:1
690 +001:1
691 +00000100000:100000
692 123456789:123456789
693 -1:-1
694 -01:-1
695 -001:-1
696 -123456789:-123456789
697 -00000100000:-100000
698 1_2_3:123
699 _123:NaN
700 _123_:NaN
701 _123_:NaN
702 1__23:NaN
703 10000000000E-1_0:1
704 1E2:100
705 1E1:10
706 1E0:1
707 E1:NaN
708 E23:NaN
709 1.23E2:123
710 1.23E1:NaN
711 1.23E-1:NaN
712 100E-1:10
713 # floating point input
714 1.01E2:101
715 1010E-1:101
716 -1010E0:-1010
717 -1010E1:-10100
718 -1010E-2:NaN
719 -1.01E+1:NaN
720 -1.01E-1:NaN
721 1234.00:1234
722 &bnan
723 1:NaN
724 2:NaN
725 abc:NaN
726 &bone
727 2:+:+1
728 2:-:-1
729 boneNaN:-:-1
730 boneNaN:+:+1
731 2:abc:+1
732 3::+1
733 &binf
734 1:+:inf
735 2:-:-inf
736 3:abc:inf
737 &is_inf
738 +inf::1
739 -inf::1
740 abc::0
741 1::0
742 NaN::0
743 -1::0
744 +inf:-:0
745 +inf:+:1
746 -inf:-:1
747 -inf:+:0
748 # it must be exactly /^[+-]inf$/
749 +infinity::0
750 -infinity::0
751 &blsft
752 abc:abc:NaN
753 +2:+2:+8
754 +1:+32:+4294967296
755 +1:+48:+281474976710656
756 +8:-2:NaN
757 # excercise base 10
758 +12345:4:10:123450000
759 -1234:0:10:-1234
760 +1234:0:10:+1234
761 +2:2:10:200
762 +12:2:10:1200
763 +1234:-3:10:NaN
764 1234567890123:12:10:1234567890123000000000000
765 &brsft
766 abc:abc:NaN
767 +8:+2:+2
768 +4294967296:+32:+1
769 +281474976710656:+48:+1
770 +2:-2:NaN
771 # excercise base 10
772 -1234:0:10:-1234
773 +1234:0:10:+1234
774 +200:2:10:2
775 +1234:3:10:1
776 +1234:2:10:12
777 +1234:-3:10:NaN
778 310000:4:10:31
779 12300000:5:10:123
780 1230000000000:10:10:123
781 09876123456789067890:12:10:9876123
782 1234561234567890123:13:10:123456
783 &bsstr
784 1e+34:1e+34
785 123.456E3:123456e+0
786 100:1e+2
787 abc:NaN
788 &bneg
789 bnegNaN:NaN
790 +inf:-inf
791 -inf:inf
792 abd:NaN
793 +0:+0
794 +1:-1
795 -1:+1
796 +123456789:-123456789
797 -123456789:+123456789
798 &babs
799 babsNaN:NaN
800 +inf:inf
801 -inf:inf
802 +0:+0
803 +1:+1
804 -1:+1
805 +123456789:+123456789
806 -123456789:+123456789
807 &bcmp
808 bcmpNaN:bcmpNaN:
809 bcmpNaN:+0:
810 +0:bcmpNaN:
811 +0:+0:0
812 -1:+0:-1
813 +0:-1:1
814 +1:+0:1
815 +0:+1:-1
816 -1:+1:-1
817 +1:-1:1
818 -1:-1:0
819 +1:+1:0
820 +123:+123:0
821 +123:+12:1
822 +12:+123:-1
823 -123:-123:0
824 -123:-12:-1
825 -12:-123:1
826 +123:+124:-1
827 +124:+123:1
828 -123:-124:1
829 -124:-123:-1
830 +100:+5:1
831 -123456789:+987654321:-1
832 +123456789:-987654321:1
833 -987654321:+123456789:-1
834 -inf:5432112345:-1
835 +inf:5432112345:1
836 -inf:-5432112345:-1
837 +inf:-5432112345:1
838 +inf:+inf:0
839 -inf:-inf:0
840 +inf:-inf:1
841 -inf:+inf:-1
842 # return undef
843 +inf:NaN:
844 NaN:inf:
845 -inf:NaN:
846 NaN:-inf:
847 &binc
848 abc:NaN
849 +inf:inf
850 -inf:-inf
851 +0:+1
852 +1:+2
853 -1:+0
854 &bdec
855 abc:NaN
856 +inf:inf
857 -inf:-inf
858 +0:-1
859 +1:+0
860 -1:-2
861 &badd
862 abc:abc:NaN
863 abc:+0:NaN
864 +0:abc:NaN
865 +inf:-inf:0
866 -inf:+inf:0
867 +inf:+inf:inf
868 -inf:-inf:-inf
869 baddNaN:+inf:NaN
870 baddNaN:+inf:NaN
871 +inf:baddNaN:NaN
872 -inf:baddNaN:NaN
873 +0:+0:+0
874 +1:+0:+1
875 +0:+1:+1
876 +1:+1:+2
877 -1:+0:-1
878 +0:-1:-1
879 -1:-1:-2
880 -1:+1:+0
881 +1:-1:+0
882 +9:+1:+10
883 +99:+1:+100
884 +999:+1:+1000
885 +9999:+1:+10000
886 +99999:+1:+100000
887 +999999:+1:+1000000
888 +9999999:+1:+10000000
889 +99999999:+1:+100000000
890 +999999999:+1:+1000000000
891 +9999999999:+1:+10000000000
892 +99999999999:+1:+100000000000
893 +10:-1:+9
894 +100:-1:+99
895 +1000:-1:+999
896 +10000:-1:+9999
897 +100000:-1:+99999
898 +1000000:-1:+999999
899 +10000000:-1:+9999999
900 +100000000:-1:+99999999
901 +1000000000:-1:+999999999
902 +10000000000:-1:+9999999999
903 +123456789:+987654321:+1111111110
904 -123456789:+987654321:+864197532
905 -123456789:-987654321:-1111111110
906 +123456789:-987654321:-864197532
907 &bsub
908 abc:abc:NaN
909 abc:+0:NaN
910 +0:abc:NaN
911 +inf:-inf:inf
912 -inf:+inf:-inf
913 +inf:+inf:0
914 -inf:-inf:0
915 +0:+0:+0
916 +1:+0:+1
917 +0:+1:-1
918 +1:+1:+0
919 -1:+0:-1
920 +0:-1:+1
921 -1:-1:+0
922 -1:+1:-2
923 +1:-1:+2
924 +9:+1:+8
925 +99:+1:+98
926 +999:+1:+998
927 +9999:+1:+9998
928 +99999:+1:+99998
929 +999999:+1:+999998
930 +9999999:+1:+9999998
931 +99999999:+1:+99999998
932 +999999999:+1:+999999998
933 +9999999999:+1:+9999999998
934 +99999999999:+1:+99999999998
935 +10:-1:+11
936 +100:-1:+101
937 +1000:-1:+1001
938 +10000:-1:+10001
939 +100000:-1:+100001
940 +1000000:-1:+1000001
941 +10000000:-1:+10000001
942 +100000000:-1:+100000001
943 +1000000000:-1:+1000000001
944 +10000000000:-1:+10000000001
945 +123456789:+987654321:-864197532
946 -123456789:+987654321:-1111111110
947 -123456789:-987654321:+864197532
948 +123456789:-987654321:+1111111110
949 &bmul
950 abc:abc:NaN
951 abc:+0:NaN
952 +0:abc:NaN
953 NaNmul:+inf:NaN
954 NaNmul:-inf:NaN
955 -inf:NaNmul:NaN
956 +inf:NaNmul:NaN
957 +inf:+inf:inf
958 +inf:-inf:-inf
959 -inf:+inf:-inf
960 -inf:-inf:inf
961 +0:+0:+0
962 +0:+1:+0
963 +1:+0:+0
964 +0:-1:+0
965 -1:+0:+0
966 +123456789123456789:+0:+0
967 +0:+123456789123456789:+0
968 -1:-1:+1
969 -1:+1:-1
970 +1:-1:-1
971 +1:+1:+1
972 +2:+3:+6
973 -2:+3:-6
974 +2:-3:-6
975 -2:-3:+6
976 +111:+111:+12321
977 +10101:+10101:+102030201
978 +1001001:+1001001:+1002003002001
979 +100010001:+100010001:+10002000300020001
980 +10000100001:+10000100001:+100002000030000200001
981 +11111111111:+9:+99999999999
982 +22222222222:+9:+199999999998
983 +33333333333:+9:+299999999997
984 +44444444444:+9:+399999999996
985 +55555555555:+9:+499999999995
986 +66666666666:+9:+599999999994
987 +77777777777:+9:+699999999993
988 +88888888888:+9:+799999999992
989 +99999999999:+9:+899999999991
990 +25:+25:+625
991 +12345:+12345:+152399025
992 +99999:+11111:+1111088889
993 &bdiv-list
994 100:20:5,0
995 4095:4095:1,0
996 -4095:-4095:1,0
997 4095:-4095:-1,0
998 -4095:4095:-1,0
999 &bdiv
1000 abc:abc:NaN
1001 abc:+1:abc:NaN
1002 +1:abc:NaN
1003 +0:+0:NaN
1004 +5:0:inf
1005 -5:0:-inf
1006 +1:+0:inf
1007 +0:+1:+0
1008 +0:-1:+0
1009 -1:+0:-inf
1010 +1:+1:+1
1011 -1:-1:+1
1012 +1:-1:-1
1013 -1:+1:-1
1014 +1:+2:+0
1015 +2:+1:+2
1016 +1:+26:+0
1017 +1000000000:+9:+111111111
1018 +2000000000:+9:+222222222
1019 +3000000000:+9:+333333333
1020 +4000000000:+9:+444444444
1021 +5000000000:+9:+555555555
1022 +6000000000:+9:+666666666
1023 +7000000000:+9:+777777777
1024 +8000000000:+9:+888888888
1025 +9000000000:+9:+1000000000
1026 +35500000:+113:+314159
1027 +71000000:+226:+314159
1028 +106500000:+339:+314159
1029 +1000000000:+3:+333333333
1030 +10:+5:+2
1031 +100:+4:+25
1032 +1000:+8:+125
1033 +10000:+16:+625
1034 +999999999999:+9:+111111111111
1035 +999999999999:+99:+10101010101
1036 +999999999999:+999:+1001001001
1037 +999999999999:+9999:+100010001
1038 +999999999999999:+99999:+10000100001
1039 +1111088889:+99999:+11111
1040 -5:-3:1
1041 4:3:1
1042 1:3:0
1043 -2:-3:0
1044 -2:3:-1
1045 1:-3:-1
1046 -5:3:-2
1047 4:-3:-2
1048 123:+inf:0
1049 123:-inf:0
1050 &bmod
1051 abc:abc:NaN
1052 abc:+1:abc:NaN
1053 +1:abc:NaN
1054 +0:+0:NaN
1055 +0:+1:+0
1056 +1:+0:NaN
1057 +0:-1:+0
1058 -1:+0:NaN
1059 +1:+1:+0
1060 -1:-1:+0
1061 +1:-1:+0
1062 -1:+1:+0
1063 +1:+2:+1
1064 +2:+1:+0
1065 +1000000000:+9:+1
1066 +2000000000:+9:+2
1067 +3000000000:+9:+3
1068 +4000000000:+9:+4
1069 +5000000000:+9:+5
1070 +6000000000:+9:+6
1071 +7000000000:+9:+7
1072 +8000000000:+9:+8
1073 +9000000000:+9:+0
1074 +35500000:+113:+33
1075 +71000000:+226:+66
1076 +106500000:+339:+99
1077 +1000000000:+3:+1
1078 +10:+5:+0
1079 +100:+4:+0
1080 +1000:+8:+0
1081 +10000:+16:+0
1082 +999999999999:+9:+0
1083 +999999999999:+99:+0
1084 +999999999999:+999:+0
1085 +999999999999:+9999:+0
1086 +999999999999999:+99999:+0
1087 -9:+5:+1
1088 +9:-5:-1
1089 -9:-5:-4
1090 -5:3:1
1091 -2:3:1
1092 4:3:1
1093 1:3:1
1094 -5:-3:-2
1095 -2:-3:-2
1096 4:-3:-2
1097 1:-3:-2
1098 4095:4095:0
1099 &bgcd
1100 abc:abc:NaN
1101 abc:+0:NaN
1102 +0:abc:NaN
1103 +0:+0:+0
1104 +0:+1:+1
1105 +1:+0:+1
1106 +1:+1:+1
1107 +2:+3:+1
1108 +3:+2:+1
1109 -3:+2:+1
1110 +100:+625:+25
1111 +4096:+81:+1
1112 +1034:+804:+2
1113 +27:+90:+56:+1
1114 +27:+90:+54:+9
1115 &blcm
1116 abc:abc:NaN
1117 abc:+0:NaN
1118 +0:abc:NaN
1119 +0:+0:NaN
1120 +1:+0:+0
1121 +0:+1:+0
1122 +27:+90:+270
1123 +1034:+804:+415668
1124 &band
1125 abc:abc:NaN
1126 abc:0:NaN
1127 0:abc:NaN
1128 1:2:0
1129 3:2:2
1130 +8:+2:+0
1131 +281474976710656:+0:+0
1132 +281474976710656:+1:+0
1133 +281474976710656:+281474976710656:+281474976710656
1134 -2:-3:-4
1135 -1:-1:-1
1136 -6:-6:-6
1137 -7:-4:-8
1138 -7:4:0
1139 -4:7:4
1140 &bior
1141 abc:abc:NaN
1142 abc:0:NaN
1143 0:abc:NaN
1144 1:2:3
1145 +8:+2:+10
1146 +281474976710656:+0:+281474976710656
1147 +281474976710656:+1:+281474976710657
1148 +281474976710656:+281474976710656:+281474976710656
1149 -2:-3:-1
1150 -1:-1:-1
1151 -6:-6:-6
1152 -7:4:-3
1153 -4:7:-1
1154 &bxor
1155 abc:abc:NaN
1156 abc:0:NaN
1157 0:abc:NaN
1158 1:2:3
1159 +8:+2:+10
1160 +281474976710656:+0:+281474976710656
1161 +281474976710656:+1:+281474976710657
1162 +281474976710656:+281474976710656:+0
1163 -2:-3:3
1164 -1:-1:0
1165 -6:-6:0
1166 -7:4:-3
1167 -4:7:-5
1168 4:-7:-3
1169 -4:-7:5
1170 &bnot
1171 abc:NaN
1172 +0:-1
1173 +8:-9
1174 +281474976710656:-281474976710657
1175 -1:0
1176 -2:1
1177 -12:11
1178 &digit
1179 0:0:0
1180 12:0:2
1181 12:1:1
1182 123:0:3
1183 123:1:2
1184 123:2:1
1185 123:-1:1
1186 123:-2:2
1187 123:-3:3
1188 123456:0:6
1189 123456:1:5
1190 123456:2:4
1191 123456:3:3
1192 123456:4:2
1193 123456:5:1
1194 123456:-1:1
1195 123456:-2:2
1196 123456:-3:3
1197 100000:-3:0
1198 100000:0:0
1199 100000:1:0
1200 &mantissa
1201 abc:NaN
1202 1e4:1
1203 2e0:2
1204 123:123
1205 -1:-1
1206 -2:-2
1207 &exponent
1208 abc:NaN
1209 1e4:4
1210 2e0:0
1211 123:0
1212 -1:0
1213 -2:0
1214 0:1
1215 &parts
1216 abc:NaN,NaN
1217 1e4:1,4
1218 2e0:2,0
1219 123:123,0
1220 -1:-1,0
1221 -2:-2,0
1222 0:0,1
1223 &bpow
1224 abc:12:NaN
1225 12:abc:NaN
1226 0:0:1
1227 0:1:0
1228 0:2:0
1229 0:-1:NaN
1230 0:-2:NaN
1231 1:0:1
1232 1:1:1
1233 1:2:1
1234 1:3:1
1235 1:-1:1
1236 1:-2:1
1237 1:-3:1
1238 2:0:1
1239 2:1:2
1240 2:2:4
1241 2:3:8
1242 3:3:27
1243 2:-1:NaN
1244 -2:-1:NaN
1245 2:-2:NaN
1246 -2:-2:NaN
1247 +inf:1234500012:inf
1248 -inf:1234500012:-inf
1249 +inf:-12345000123:inf
1250 -inf:-12345000123:-inf
1251 # 1 ** -x => 1 / (1 ** x)
1252 -1:0:1
1253 -2:0:1
1254 -1:1:-1
1255 -1:2:1
1256 -1:3:-1
1257 -1:4:1
1258 -1:5:-1
1259 -1:-1:-1
1260 -1:-2:1
1261 -1:-3:-1
1262 -1:-4:1
1263 10:2:100
1264 10:3:1000
1265 10:4:10000
1266 10:5:100000
1267 10:6:1000000
1268 10:7:10000000
1269 10:8:100000000
1270 10:9:1000000000
1271 10:20:100000000000000000000
1272 123456:2:15241383936
1273 &length
1274 100:3
1275 10:2
1276 1:1
1277 0:1
1278 12345:5
1279 10000000000000000:17
1280 -123:3
1281 215960156869840440586892398248:30
1282 &bsqrt
1283 144:12
1284 16:4
1285 4:2
1286 2:1
1287 12:3
1288 256:16
1289 100000000:10000
1290 4000000000000:2000000
1291 1:1
1292 0:0
1293 -2:NaN
1294 Nan:NaN
1295 &bround
1296 $round_mode('trunc')
1297 0:12:0
1298 NaNbround:12:NaN
1299 +inf:12:inf
1300 -inf:12:-inf
1301 1234:0:1234
1302 1234:2:1200
1303 123456:4:123400
1304 123456:5:123450
1305 123456:6:123456
1306 +10123456789:5:+10123000000
1307 -10123456789:5:-10123000000
1308 +10123456789:9:+10123456700
1309 -10123456789:9:-10123456700
1310 +101234500:6:+101234000
1311 -101234500:6:-101234000
1312 #+101234500:-4:+101234000
1313 #-101234500:-4:-101234000
1314 $round_mode('zero')
1315 +20123456789:5:+20123000000
1316 -20123456789:5:-20123000000
1317 +20123456789:9:+20123456800
1318 -20123456789:9:-20123456800
1319 +201234500:6:+201234000
1320 -201234500:6:-201234000
1321 #+201234500:-4:+201234000
1322 #-201234500:-4:-201234000
1323 +12345000:4:12340000
1324 -12345000:4:-12340000
1325 $round_mode('+inf')
1326 +30123456789:5:+30123000000
1327 -30123456789:5:-30123000000
1328 +30123456789:9:+30123456800
1329 -30123456789:9:-30123456800
1330 +301234500:6:+301235000
1331 -301234500:6:-301234000
1332 #+301234500:-4:+301235000
1333 #-301234500:-4:-301234000
1334 +12345000:4:12350000
1335 -12345000:4:-12340000
1336 $round_mode('-inf')
1337 +40123456789:5:+40123000000
1338 -40123456789:5:-40123000000
1339 +40123456789:9:+40123456800
1340 -40123456789:9:-40123456800
1341 +401234500:6:+401234000
1342 +401234500:6:+401234000
1343 #-401234500:-4:-401235000
1344 #-401234500:-4:-401235000
1345 +12345000:4:12340000
1346 -12345000:4:-12350000
1347 $round_mode('odd')
1348 +50123456789:5:+50123000000
1349 -50123456789:5:-50123000000
1350 +50123456789:9:+50123456800
1351 -50123456789:9:-50123456800
1352 +501234500:6:+501235000
1353 -501234500:6:-501235000
1354 #+501234500:-4:+501235000
1355 #-501234500:-4:-501235000
1356 +12345000:4:12350000
1357 -12345000:4:-12350000
1358 $round_mode('even')
1359 +60123456789:5:+60123000000
1360 -60123456789:5:-60123000000
1361 +60123456789:9:+60123456800
1362 -60123456789:9:-60123456800
1363 +601234500:6:+601234000
1364 -601234500:6:-601234000
1365 #+601234500:-4:+601234000
1366 #-601234500:-4:-601234000
1367 #-601234500:-9:0
1368 #-501234500:-9:0
1369 #-601234500:-8:0
1370 #-501234500:-8:0
1371 +1234567:7:1234567
1372 +1234567:6:1234570
1373 +12345000:4:12340000
1374 -12345000:4:-12340000
1375 &is_zero
1376 0:1
1377 NaNzero:0
1378 +inf:0
1379 -inf:0
1380 123:0
1381 -1:0
1382 1:0
1383 &is_one
1384 0:0
1385 NaNone:0
1386 +inf:0
1387 -inf:0
1388 1:1
1389 2:0
1390 -1:0
1391 -2:0
1392 # floor and ceil tests are pretty pointless in integer space...but play safe
1393 &bfloor
1394 0:0
1395 NaNfloor:NaN
1396 +inf:inf
1397 -inf:-inf
1398 -1:-1
1399 -2:-2
1400 2:2
1401 3:3
1402 abc:NaN
1403 &bceil
1404 NaNceil:NaN
1405 +inf:inf
1406 -inf:-inf
1407 0:0
1408 -1:-1
1409 -2:-2
1410 2:2
1411 3:3
1412 abc:NaN
1413 &as_hex
1414 128:0x80
1415 -128:-0x80
1416 0:0x0
1417 -0:0x0
1418 1:0x1
1419 0x123456789123456789:0x123456789123456789
1420 +inf:inf
1421 -inf:-inf
1422 NaNas_hex:NaN
1423 &as_bin
1424 128:0b10000000
1425 -128:-0b10000000
1426 0:0b0
1427 -0:0b0
1428 1:0b1
1429 0b1010111101010101010110110110110110101:0b1010111101010101010110110110110110101
1430 +inf:inf
1431 -inf:-inf
1432 NaNas_bin:NaN