This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
Math-BigInt v1.49 released
[perl5.git] / lib / Math / BigInt / t / bigintpm.inc
1 #include this file into another for subclass testing
2
3 my $version = ${"$class\::VERSION"};
4
5 ##############################################################################
6 # for testing inheritance of _swap
7
8 package Math::Foo;
9
10 use Math::BigInt lib => $main::CL;
11 use vars qw/@ISA/;
12 @ISA = (qw/Math::BigInt/);
13
14 use overload
15 # customized overload for sub, since original does not use swap there
16 '-'     =>      sub { my @a = ref($_[0])->_swap(@_);
17                    $a[0]->bsub($a[1])};
18
19 sub _swap
20   {
21   # a fake _swap, which reverses the params
22   my $self = shift;                     # for override in subclass
23   if ($_[2])
24     {
25     my $c = ref ($_[0] ) || 'Math::Foo';
26     return ( $_[0]->copy(), $_[1] );
27     }
28   else
29     {
30     return ( Math::Foo->new($_[1]), $_[0] );
31     }
32   }
33
34 ##############################################################################
35 package main;
36
37 my $CALC = $class->_core_lib(); ok ($CALC,$CL);
38
39 my ($f,$z,$a,$exp,@a,$m,$e,$round_mode);
40
41 while (<DATA>) 
42   {
43   chop;
44   next if /^#/; # skip comments
45   if (s/^&//) 
46     {
47     $f = $_; next;
48     }
49   elsif (/^\$/) 
50     {
51     $round_mode = $_; $round_mode =~ s/^\$/$class\->/; next;
52     }
53
54   @args = split(/:/,$_,99); $ans = pop(@args);
55   $try = "\$x = $class->new(\"$args[0]\");";
56   if ($f eq "bnorm")
57     {
58     $try = "\$x = $class->bnorm(\"$args[0]\");";
59   # some is_xxx tests
60    } elsif ($f =~ /^is_(zero|one|odd|even|negative|positive|nan)$/) {
61     $try .= "\$x->$f();";
62    } elsif ($f eq "as_hex") {
63     $try .= '$x->as_hex();';
64    } elsif ($f eq "as_bin") {
65     $try .= '$x->as_bin();';
66    } elsif ($f eq "is_inf") {
67     $try .= "\$x->is_inf('$args[1]');";
68    } elsif ($f eq "binf") {
69     $try .= "\$x->binf('$args[1]');";
70    } elsif ($f eq "bone") {
71     $try .= "\$x->bone('$args[1]');";
72    # some unary ops
73    } elsif ($f =~ /^b(nan|floor|ceil|sstr|neg|abs|inc|dec|not|sqrt)$/) {
74     $try .= "\$x->$f();";
75    } elsif ($f eq "length") {
76     $try .= '$x->length();';
77    } elsif ($f eq "exponent"){
78     # ->bstr() to see if an object is returned
79     $try .= '$x = $x->exponent()->bstr();';
80    } elsif ($f eq "mantissa"){
81     # ->bstr() to see if an object is returned
82     $try .= '$x = $x->mantissa()->bstr();';
83    } elsif ($f eq "parts"){
84     $try .= '($m,$e) = $x->parts();'; 
85     # ->bstr() to see if an object is returned
86     $try .= '$m = $m->bstr(); $m = "NaN" if !defined $m;';
87     $try .= '$e = $e->bstr(); $e = "NaN" if !defined $e;';
88     $try .= '"$m,$e";';
89    } else {
90     $try .= "\$y = $class->new('$args[1]');";
91     if ($f eq "bcmp")
92       {
93       $try .= '$x <=> $y;';
94       } elsif ($f eq "bround") {
95       $try .= "$round_mode; \$x->bround(\$y);";
96       } elsif ($f eq "bacmp"){
97       $try .= '$x->bacmp($y);';
98       } elsif ($f eq "badd"){
99       $try .= '$x + $y;';
100       } elsif ($f eq "bsub"){
101       $try .= '$x - $y;';
102       } elsif ($f eq "bmul"){
103       $try .= '$x * $y;';
104       } elsif ($f eq "bdiv"){
105       $try .= '$x / $y;';
106       } elsif ($f eq "bdiv-list"){
107       $try .= 'join (",",$x->bdiv($y));';
108       # overload via x=
109       } elsif ($f =~ /^.=$/){
110       $try .= "\$x $f \$y;";
111       # overload via x
112       } elsif ($f =~ /^.$/){
113       $try .= "\$x $f \$y;";
114       } elsif ($f eq "bmod"){
115       $try .= '$x % $y;';
116       } elsif ($f eq "bgcd")
117         {
118         if (defined $args[2])
119           {
120           $try .= " \$z = $class->new('$args[2]'); ";
121           }
122         $try .= "$class\::bgcd(\$x, \$y";
123         $try .= ", \$z" if (defined $args[2]);
124         $try .= " );";
125         }
126       elsif ($f eq "blcm")
127         {
128         if (defined $args[2])
129           {
130           $try .= " \$z = $class->new('$args[2]'); ";
131           }
132         $try .= "$class\::blcm(\$x, \$y";
133         $try .= ", \$z" if (defined $args[2]);
134         $try .= " );";
135       }elsif ($f eq "blsft"){
136         if (defined $args[2])
137           {
138           $try .= "\$x->blsft(\$y,$args[2]);";
139           }
140         else
141           {
142           $try .= "\$x << \$y;";
143           }
144       }elsif ($f eq "brsft"){
145         if (defined $args[2])
146           {
147           $try .= "\$x->brsft(\$y,$args[2]);";
148           }
149         else
150           {
151           $try .= "\$x >> \$y;";
152           }
153       }elsif ($f eq "band"){
154         $try .= "\$x & \$y;";
155       }elsif ($f eq "bior"){
156         $try .= "\$x | \$y;";
157       }elsif ($f eq "bxor"){
158         $try .= "\$x ^ \$y;";
159       }elsif ($f eq "bpow"){
160         $try .= "\$x ** \$y;";
161       }elsif ($f eq "digit"){
162         $try = "\$x = $class->new('$args[0]'); \$x->digit($args[1]);";
163       } else { warn "Unknown op '$f'"; }
164     } # end else all other ops
165
166   $ans1 = eval $try;
167   # convert hex/binary targets to decimal       
168   if ($ans =~ /^(0x0x|0b0b)/)
169     {
170     $ans =~ s/^0[xb]//; $ans = Math::BigInt->new($ans)->bstr();
171     }
172   if ($ans eq "")
173     {
174     ok_undef ($ans1); 
175     }
176   else
177     {
178     # print "try: $try ans: $ans1 $ans\n";
179     print "# Tried: '$try'\n" if !ok ($ans1, $ans);
180     }
181   # check internal state of number objects
182   is_valid($ans1,$f) if ref $ans1; 
183   } # endwhile data tests
184 close DATA;
185
186 # test some more
187 @a = ();
188 for (my $i = 1; $i < 10; $i++) 
189   {
190   push @a, $i;
191   }
192 ok "@a", "1 2 3 4 5 6 7 8 9";
193
194 # test whether self-multiplication works correctly (result is 2**64)
195 $try = "\$x = $class->new('4294967296');";
196 $try .= '$a = $x->bmul($x);';
197 $ans1 = eval $try;
198 print "# Tried: '$try'\n" if !ok ($ans1, $class->new(2) ** 64);
199 # test self-pow
200 $try = "\$x = $class->new(10);";
201 $try .= '$a = $x->bpow($x);';
202 $ans1 = eval $try;
203 print "# Tried: '$try'\n" if !ok ($ans1, $class->new(10) ** 10);
204
205 # test whether op destroys args or not (should better not)
206
207 $x = $class->new(3);
208 $y = $class->new(4);
209 $z = $x & $y;
210 ok ($x,3);
211 ok ($y,4);
212 ok ($z,0);
213 $z = $x | $y;
214 ok ($x,3);
215 ok ($y,4);
216 ok ($z,7);
217 $x = $class->new(1);
218 $y = $class->new(2);
219 $z = $x | $y;
220 ok ($x,1);
221 ok ($y,2);
222 ok ($z,3);
223
224 $x = $class->new(5);
225 $y = $class->new(4);
226 $z = $x ^ $y;
227 ok ($x,5);
228 ok ($y,4);
229 ok ($z,1);
230
231 $x = $class->new(-5); $y = -$x;
232 ok ($x, -5);
233
234 $x = $class->new(-5); $y = abs($x);
235 ok ($x, -5);
236
237 # check whether overloading cmp works
238 $try = "\$x = $class->new(0);";
239 $try .= "\$y = 10;";
240 $try .= "'false' if \$x ne \$y;";
241 $ans = eval $try;
242 print "# For '$try'\n" if (!ok "$ans" , "false" ); 
243
244 # we cant test for working cmpt with other objects here, we would need a dummy
245 # object with stringify overload for this. see Math::String tests as example
246
247 ###############################################################################
248 # check reversed order of arguments
249
250 $try = "\$x = $class->new(10); \$x = 2 ** \$x;";
251 $try .= "'ok' if \$x == 1024;"; $ans = eval $try;
252 print "# For '$try'\n" if (!ok "$ans" , "ok" ); 
253
254 $try = "\$x = $class->new(10); \$x = 2 * \$x;";
255 $try .= "'ok' if \$x == 20;"; $ans = eval $try;
256 print "# For '$try'\n" if (!ok "$ans" , "ok" ); 
257
258 $try = "\$x = $class->new(10); \$x = 2 + \$x;";
259 $try .= "'ok' if \$x == 12;"; $ans = eval $try;
260 print "# For '$try'\n" if (!ok "$ans" , "ok" ); 
261
262 $try = "\$x = $class\->new(10); \$x = 2 - \$x;";
263 $try .= "'ok' if \$x == -8;"; $ans = eval $try;
264 print "# For '$try'\n" if (!ok "$ans" , "ok" ); 
265
266 $try = "\$x = $class\->new(10); \$x = 20 / \$x;";
267 $try .= "'ok' if \$x == 2;"; $ans = eval $try;
268 print "# For '$try'\n" if (!ok "$ans" , "ok" ); 
269
270 $try = "\$x = $class\->new(3); \$x = 20 % \$x;";
271 $try .= "'ok' if \$x == 2;"; $ans = eval $try;
272 print "# For '$try'\n" if (!ok "$ans" , "ok" ); 
273
274 $try = "\$x = $class\->new(7); \$x = 20 & \$x;";
275 $try .= "'ok' if \$x == 4;"; $ans = eval $try;
276 print "# For '$try'\n" if (!ok "$ans" , "ok" ); 
277
278 $try = "\$x = $class\->new(7); \$x = 0x20 | \$x;";
279 $try .= "'ok' if \$x == 0x27;"; $ans = eval $try;
280 print "# For '$try'\n" if (!ok "$ans" , "ok" ); 
281
282 $try = "\$x = $class\->new(7); \$x = 0x20 ^ \$x;";
283 $try .= "'ok' if \$x == 0x27;"; $ans = eval $try;
284 print "# For '$try'\n" if (!ok "$ans" , "ok" ); 
285
286 ###############################################################################
287 # check badd(4,5) form
288
289 $try = "\$x = $class\->badd(4,5);";
290 $try .= "'ok' if \$x == 9;";
291 $ans = eval $try;
292 print "# For '$try'\n" if (!ok "$ans" , "ok" ); 
293
294 ###############################################################################
295 # check undefs: NOT DONE YET
296
297 ###############################################################################
298 # bool
299
300 $x = Math::BigInt->new(1); if ($x) { ok (1,1); } else { ok($x,'to be true') }
301 $x = Math::BigInt->new(0); if (!$x) { ok (1,1); } else { ok($x,'to be false') }
302
303 ###############################################################################
304 # objectify()
305
306 @args = Math::BigInt::objectify(2,4,5);
307 ok (scalar @args,3);            # $class, 4, 5
308 ok ($args[0],$class);
309 ok ($args[1],4);
310 ok ($args[2],5);
311
312 @args = Math::BigInt::objectify(0,4,5);
313 ok (scalar @args,3);            # $class, 4, 5
314 ok ($args[0],$class);
315 ok ($args[1],4);
316 ok ($args[2],5);
317
318 @args = Math::BigInt::objectify(2,4,5);
319 ok (scalar @args,3);            # $class, 4, 5
320 ok ($args[0],$class);
321 ok ($args[1],4);
322 ok ($args[2],5);
323
324 @args = Math::BigInt::objectify(2,4,5,6,7);
325 ok (scalar @args,5);            # $class, 4, 5, 6, 7
326 ok ($args[0],$class);
327 ok ($args[1],4); ok (ref($args[1]),$args[0]);
328 ok ($args[2],5); ok (ref($args[2]),$args[0]);
329 ok ($args[3],6); ok (ref($args[3]),'');
330 ok ($args[4],7); ok (ref($args[4]),'');
331
332 @args = Math::BigInt::objectify(2,$class,4,5,6,7);
333 ok (scalar @args,5);            # $class, 4, 5, 6, 7
334 ok ($args[0],$class);
335 ok ($args[1],4); ok (ref($args[1]),$args[0]);
336 ok ($args[2],5); ok (ref($args[2]),$args[0]);
337 ok ($args[3],6); ok (ref($args[3]),'');
338 ok ($args[4],7); ok (ref($args[4]),'');
339
340 ###############################################################################
341 # test for floating-point input (other tests in bnorm() below)
342
343 $z = 1050000000000000;          # may be int on systems with 64bit?
344 $x = $class->new($z); ok ($x->bsstr(),'105e+13');       # not 1.05e+15
345 $z = 1e+129;                    # definitely a float (may fail on UTS)
346 # don't compare to $z, since some Perl versions stringify $z into something
347 # like '1.e+129' or something equally ugly
348 $x = $class->new($z); ok ($x->bsstr(),'1e+129');
349
350 ###############################################################################
351 # prime number tests, also test for **= and length()
352 # found on: http://www.utm.edu/research/primes/notes/by_year.html
353
354 # ((2^148)-1)/17
355 $x = $class->new(2); $x **= 148; $x++; $x = $x / 17;
356 ok ($x,"20988936657440586486151264256610222593863921");
357 ok ($x->length(),length "20988936657440586486151264256610222593863921");
358
359 # MM7 = 2^127-1
360 $x = $class->new(2); $x **= 127; $x--;
361 ok ($x,"170141183460469231731687303715884105727");
362
363 $x = $class->new('215960156869840440586892398248');
364 ($x,$y) = $x->length();
365 ok ($x,30); ok ($y,0);
366
367 $x = $class->new('1_000_000_000_000');
368 ($x,$y) = $x->length();
369 ok ($x,13); ok ($y,0);
370
371 # I am afraid the following is not yet possible due to slowness
372 # Also, testing for 2 meg output is a bit hard ;)
373 #$x = $class->new(2); $x **= 6972593; $x--;
374
375 # 593573509*2^332162+1 has exactly 1,000,000 digits
376 # takes about 24 mins on 300 Mhz, so cannot be done yet ;)
377 #$x = $class->new(2); $x **= 332162; $x *= "593573509"; $x++;
378 #ok ($x->length(),1_000_000);
379
380 ###############################################################################
381 # inheritance and overriding of _swap
382
383 $x = Math::Foo->new(5);
384 $x = $x - 8;            # 8 - 5 instead of 5-8
385 ok ($x,3);
386 ok (ref($x),'Math::Foo');
387
388 $x = Math::Foo->new(5);
389 $x = 8 - $x;            # 5 - 8 instead of 8 - 5
390 ok ($x,-3);
391 ok (ref($x),'Math::Foo');
392
393 ###############################################################################
394 # Test whether +inf eq inf
395 # This tried to test whether BigInt inf equals Perl inf. Unfortunately, Perl
396 # hasn't (before 5.7.3 at least) a consistent way to say inf, and some things
397 # like 1e100000 crash on some platforms. So simple test for the string 'inf'
398 $x = $class->new('+inf'); ok ($x,'inf');
399
400 ###############################################################################
401 ###############################################################################
402 # the followin tests only make sense with Math::BigInt::Calc or BareCalc
403
404 exit if $CALC !~ /^Math::BigInt::(Calc|BareCalc)$/; # for Pari et al.
405
406 ###############################################################################
407 # check proper length of internal arrays
408
409 my $bl = $CL->_base_len();
410 my $BASE = '9' x $bl;
411 my $MAX = $BASE;
412 $BASE++;
413
414 $x = $class->new($MAX); is_valid($x);   # f.i. 9999
415 $x += 1; ok ($x,$BASE); is_valid($x);   # 10000
416 $x -= 1; ok ($x,$MAX); is_valid($x);    # 9999 again
417
418 ###############################################################################
419 # check numify
420
421 $x = $class->new($BASE-1);     ok ($x->numify(),$BASE-1); 
422 $x = $class->new(-($BASE-1));  ok ($x->numify(),-($BASE-1)); 
423
424 # +0 is to protect from 1e15 vs 100000000 (stupid to_string aaaarglburblll...)
425 $x = $class->new($BASE);       ok ($x->numify()+0,$BASE+0);     
426 $x = $class->new(-$BASE);      ok ($x->numify(),-$BASE);
427 $x = $class->new( -($BASE*$BASE*1+$BASE*1+1) ); 
428 ok($x->numify(),-($BASE*$BASE*1+$BASE*1+1)); 
429
430 ###############################################################################
431 # test bug in _digits with length($c[-1]) where $c[-1] was "00001" instead of 1
432
433 $x = $class->new($BASE-2); $x++; $x++; $x++; $x++;
434 if ($x > $BASE) { ok (1,1) } else { ok ("$x < $BASE","$x > $BASE"); }
435
436 $x = $class->new($BASE+3); $x++;
437 if ($x > $BASE) { ok (1,1) } else { ok ("$x > $BASE","$x < $BASE"); }
438
439 # test for +0 instead of int(): 
440 $x = $class->new($MAX); ok ($x->length(), length($MAX));
441
442 ###############################################################################
443 # bug in sub where number with at least 6 trailing zeros after any op failed
444
445 $x = $class->new(123456); $z = $class->new(10000); $z *= 10; $x -= $z;
446 ok ($z, 100000);
447 ok ($x, 23456);
448
449 ###############################################################################
450 # bug in shortcut in mul()
451
452 # construct a number with a zero-hole of BASE_LEN_SMALL
453 {
454  my @bl = $CL->_base_len(); my $bl = $bl[4];
455
456  $x = '1' x $bl . '0' x $bl . '1' x $bl . '0' x $bl;
457  $y = '1' x (2*$bl);
458  $x = $class->new($x)->bmul($y);
459  # result is 123..$bl .  $bl x (3*bl-1) . $bl...321 . '0' x $bl
460  $y = ''; my $d = '';
461  for (my $i = 1; $i <= $bl; $i++)
462    {
463    $y .= $i; $d = $i.$d;
464    }
465  $y .= $bl x (3*$bl-1) . $d . '0' x $bl;
466  ok ($x,$y);
467
468
469 ###############################################################################
470 # see if mul shortcut for small numbers works
471
472 $x = '9' x $bl;
473 $x = $class->new($x); 
474 # 999 * 999 => 998 . 001, 9999*9999 => 9998 . 0001
475 ok ($x*$x, '9' x ($bl-1) . '8' . '0' x ($bl-1) . '1');
476
477  }
478
479 ###############################################################################
480 # bug with rest "-0" in div, causing further div()s to fail
481
482 $x = $class->new('-322056000'); ($x,$y) = $x->bdiv('-12882240');
483
484 ok ($y,'0'); is_valid($y);      # $y not '-0'
485
486 # all tests done
487
488 1;
489
490 ###############################################################################
491 ###############################################################################
492 # Perl 5.005 does not like ok ($x,undef)
493
494 sub ok_undef
495   {
496   my $x = shift;
497
498   ok (1,1) and return if !defined $x;
499   ok ($x,'undef');
500   }
501
502 ###############################################################################
503 # sub to check validity of a BigInt internally, to ensure that no op leaves a
504 # number object in an invalid state (f.i. "-0")
505
506 sub is_valid
507   {
508   my ($x,$f) = @_;
509
510   my $e = 0;                    # error?
511   # ok as reference? 
512   $e = 'Not a reference to Math::BigInt' if !ref($x);
513
514   # has ok sign?
515   $e = "Illegal sign $x->{sign} (expected: '+', '-', '-inf', '+inf' or 'NaN'"
516    if $e eq '0' && $x->{sign} !~ /^(\+|-|\+inf|-inf|NaN)$/;
517
518   $e = "-0 is invalid!" if $e ne '0' && $x->{sign} eq '-' && $x == 0;
519   $e = $CALC->_check($x->{value}) if $e eq '0';
520
521   # test done, see if error did crop up
522   ok (1,1), return if ($e eq '0');
523
524   ok (1,$e." after op '$f'");
525   }
526
527 __DATA__
528 &.=
529 1234:-345:1234-345
530 &+=
531 1:2:3
532 -1:-2:-3
533 &-=
534 1:2:-1
535 -1:-2:1
536 &*=
537 2:3:6
538 -1:5:-5
539 &%=
540 100:3:1
541 8:9:8
542 &/=
543 100:3:33
544 -8:2:-4
545 &|=
546 2:1:3
547 &&=
548 5:7:5
549 &^=
550 5:7:2
551 &is_negative
552 0:0
553 -1:1
554 1:0
555 +inf:0
556 -inf:1
557 NaNneg:0
558 &is_positive
559 0:1
560 -1:0
561 1:1
562 +inf:1
563 -inf:0
564 NaNneg:0
565 &is_odd
566 abc:0
567 0:0
568 1:1
569 3:1
570 -1:1
571 -3:1
572 10000001:1
573 10000002:0
574 2:0
575 &is_even
576 abc:0
577 0:1
578 1:0
579 3:0
580 -1:0
581 -3:0
582 10000001:0
583 10000002:1
584 2:1
585 &bacmp
586 +0:-0:0
587 +0:+1:-1
588 -1:+1:0
589 +1:-1:0
590 -1:+2:-1
591 +2:-1:1
592 -123456789:+987654321:-1
593 +123456789:-987654321:-1
594 +987654321:+123456789:1
595 -987654321:+123456789:1
596 -123:+4567889:-1
597 # NaNs
598 acmpNaN:123:
599 123:acmpNaN:
600 acmpNaN:acmpNaN:
601 # infinity
602 +inf:+inf:0
603 -inf:-inf:0
604 +inf:-inf:0
605 -inf:+inf:0
606 +inf:123:1
607 -inf:123:1
608 +inf:-123:1
609 -inf:-123:1
610 # return undef
611 +inf:NaN:
612 NaN:inf:
613 -inf:NaN:
614 NaN:-inf:
615 &bnorm
616 123:123
617 # binary input
618 0babc:NaN
619 0b123:NaN
620 0b0:0
621 -0b0:0
622 -0b1:-1
623 0b0001:1
624 0b001:1
625 0b011:3
626 0b101:5
627 0b1001:9
628 0b10001:17
629 0b100001:33
630 0b1000001:65
631 0b10000001:129
632 0b100000001:257
633 0b1000000001:513
634 0b10000000001:1025
635 0b100000000001:2049
636 0b1000000000001:4097
637 0b10000000000001:8193
638 0b100000000000001:16385
639 0b1000000000000001:32769
640 0b10000000000000001:65537
641 0b100000000000000001:131073
642 0b1000000000000000001:262145
643 0b10000000000000000001:524289
644 0b100000000000000000001:1048577
645 0b1000000000000000000001:2097153
646 0b10000000000000000000001:4194305
647 0b100000000000000000000001:8388609
648 0b1000000000000000000000001:16777217
649 0b10000000000000000000000001:33554433
650 0b100000000000000000000000001:67108865
651 0b1000000000000000000000000001:134217729
652 0b10000000000000000000000000001:268435457
653 0b100000000000000000000000000001:536870913
654 0b1000000000000000000000000000001:1073741825
655 0b10000000000000000000000000000001:2147483649
656 0b100000000000000000000000000000001:4294967297
657 0b1000000000000000000000000000000001:8589934593
658 0b10000000000000000000000000000000001:17179869185
659 0b_101:NaN
660 0b1_0_1:5
661 0b0_0_0_1:1
662 # hex input
663 -0x0:0
664 0xabcdefgh:NaN
665 0x1234:4660
666 0xabcdef:11259375
667 -0xABCDEF:-11259375
668 -0x1234:-4660
669 0x12345678:305419896
670 0x1_2_3_4_56_78:305419896
671 0xa_b_c_d_e_f:11259375
672 0x_123:NaN
673 0x9:9
674 0x11:17
675 0x21:33
676 0x41:65
677 0x81:129
678 0x101:257
679 0x201:513
680 0x401:1025
681 0x801:2049
682 0x1001:4097
683 0x2001:8193
684 0x4001:16385
685 0x8001:32769
686 0x10001:65537
687 0x20001:131073
688 0x40001:262145
689 0x80001:524289
690 0x100001:1048577
691 0x200001:2097153
692 0x400001:4194305
693 0x800001:8388609
694 0x1000001:16777217
695 0x2000001:33554433
696 0x4000001:67108865
697 0x8000001:134217729
698 0x10000001:268435457
699 0x20000001:536870913
700 0x40000001:1073741825
701 0x80000001:2147483649
702 0x100000001:4294967297
703 0x200000001:8589934593
704 0x400000001:17179869185
705 0x800000001:34359738369
706 # inf input
707 inf:inf
708 +inf:inf
709 -inf:-inf
710 0inf:NaN
711 # abnormal input
712 :NaN
713 abc:NaN
714    1 a:NaN
715 1bcd2:NaN
716 11111b:NaN
717 +1z:NaN
718 -1z:NaN
719 # only one underscore between two digits
720 _123:NaN
721 _123_:NaN
722 123_:NaN
723 1__23:NaN
724 1E1__2:NaN
725 1_E12:NaN
726 1E_12:NaN
727 1_E_12:NaN
728 +_1E12:NaN
729 +0_1E2:100
730 +0_0_1E2:100
731 -0_0_1E2:-100
732 -0_0_1E+0_0_2:-100
733 E1:NaN
734 E23:NaN
735 1.23E1:NaN
736 1.23E-1:NaN
737 # bug with two E's in number beeing valid
738 1e2e3:NaN
739 1e2r:NaN
740 1e2.0:NaN
741 # leading zeros
742 012:12
743 0123:123
744 01234:1234
745 012345:12345
746 0123456:123456
747 01234567:1234567
748 012345678:12345678
749 0123456789:123456789
750 01234567891:1234567891
751 012345678912:12345678912
752 0123456789123:123456789123
753 01234567891234:1234567891234
754 # normal input
755 0:0
756 +0:0
757 +00:0
758 +000:0
759 000000000000000000:0
760 -0:0
761 -0000:0
762 +1:1
763 +01:1
764 +001:1
765 +00000100000:100000
766 123456789:123456789
767 -1:-1
768 -01:-1
769 -001:-1
770 -123456789:-123456789
771 -00000100000:-100000
772 1_2_3:123
773 10000000000E-1_0:1
774 1E2:100
775 1E1:10
776 1E0:1
777 1.23E2:123
778 100E-1:10
779 # floating point input
780 # .2e2:20
781 1.E3:1000
782 1.01E2:101
783 1010E-1:101
784 -1010E0:-1010
785 -1010E1:-10100
786 1234.00:1234
787 # non-integer numbers
788 -1010E-2:NaN
789 -1.01E+1:NaN
790 -1.01E-1:NaN
791 &bnan
792 1:NaN
793 2:NaN
794 abc:NaN
795 &bone
796 2:+:1
797 2:-:-1
798 boneNaN:-:-1
799 boneNaN:+:1
800 2:abc:1
801 3::1
802 &binf
803 1:+:inf
804 2:-:-inf
805 3:abc:inf
806 &is_nan
807 123:0
808 abc:1
809 NaN:1
810 -123:0
811 &is_inf
812 +inf::1
813 -inf::1
814 abc::0
815 1::0
816 NaN::0
817 -1::0
818 +inf:-:0
819 +inf:+:1
820 -inf:-:1
821 -inf:+:0
822 # it must be exactly /^[+-]inf$/
823 +infinity::0
824 -infinity::0
825 &blsft
826 abc:abc:NaN
827 +2:+2:8
828 +1:+32:4294967296
829 +1:+48:281474976710656
830 +8:-2:NaN
831 # excercise base 10
832 +12345:4:10:123450000
833 -1234:0:10:-1234
834 +1234:0:10:1234
835 +2:2:10:200
836 +12:2:10:1200
837 +1234:-3:10:NaN
838 1234567890123:12:10:1234567890123000000000000
839 &brsft
840 abc:abc:NaN
841 +8:+2:2
842 +4294967296:+32:1
843 +281474976710656:+48:1
844 +2:-2:NaN
845 # excercise base 10
846 -1234:0:10:-1234
847 +1234:0:10:1234
848 +200:2:10:2
849 +1234:3:10:1
850 +1234:2:10:12
851 +1234:-3:10:NaN
852 310000:4:10:31
853 12300000:5:10:123
854 1230000000000:10:10:123
855 09876123456789067890:12:10:9876123
856 1234561234567890123:13:10:123456
857 &bsstr
858 1e+34:1e+34
859 123.456E3:123456e+0
860 100:1e+2
861 abc:NaN
862 &bneg
863 bnegNaN:NaN
864 +inf:-inf
865 -inf:inf
866 abd:NaN
867 0:0
868 1:-1
869 -1:1
870 +123456789:-123456789
871 -123456789:123456789
872 &babs
873 babsNaN:NaN
874 +inf:inf
875 -inf:inf
876 0:0
877 1:1
878 -1:1
879 +123456789:123456789
880 -123456789:123456789
881 &bcmp
882 bcmpNaN:bcmpNaN:
883 bcmpNaN:0:
884 0:bcmpNaN:
885 0:0:0
886 -1:0:-1
887 0:-1:1
888 1:0:1
889 0:1:-1
890 -1:1:-1
891 1:-1:1
892 -1:-1:0
893 1:1:0
894 123:123:0
895 123:12:1
896 12:123:-1
897 -123:-123:0
898 -123:-12:-1
899 -12:-123:1
900 123:124:-1
901 124:123:1
902 -123:-124:1
903 -124:-123:-1
904 100:5:1
905 -123456789:987654321:-1
906 +123456789:-987654321:1
907 -987654321:123456789:-1
908 -inf:5432112345:-1
909 +inf:5432112345:1
910 -inf:-5432112345:-1
911 +inf:-5432112345:1
912 +inf:+inf:0
913 -inf:-inf:0
914 +inf:-inf:1
915 -inf:+inf:-1
916 5:inf:-1
917 5:inf:-1
918 -5:-inf:1
919 -5:-inf:1
920 # return undef
921 +inf:NaN:
922 NaN:inf:
923 -inf:NaN:
924 NaN:-inf:
925 &binc
926 abc:NaN
927 +inf:inf
928 -inf:-inf
929 +0:1
930 +1:2
931 -1:0
932 &bdec
933 abc:NaN
934 +inf:inf
935 -inf:-inf
936 +0:-1
937 +1:0
938 -1:-2
939 &badd
940 abc:abc:NaN
941 abc:0:NaN
942 +0:abc:NaN
943 +inf:-inf:0
944 -inf:+inf:0
945 +inf:+inf:inf
946 -inf:-inf:-inf
947 baddNaN:+inf:NaN
948 baddNaN:+inf:NaN
949 +inf:baddNaN:NaN
950 -inf:baddNaN:NaN
951 0:0:0
952 1:0:1
953 0:1:1
954 1:1:2
955 -1:0:-1
956 0:-1:-1
957 -1:-1:-2
958 -1:+1:0
959 +1:-1:0
960 +9:+1:10
961 +99:+1:100
962 +999:+1:1000
963 +9999:+1:10000
964 +99999:+1:100000
965 +999999:+1:1000000
966 +9999999:+1:10000000
967 +99999999:+1:100000000
968 +999999999:+1:1000000000
969 +9999999999:+1:10000000000
970 +99999999999:+1:100000000000
971 +10:-1:9
972 +100:-1:99
973 +1000:-1:999
974 +10000:-1:9999
975 +100000:-1:99999
976 +1000000:-1:999999
977 +10000000:-1:9999999
978 +100000000:-1:99999999
979 +1000000000:-1:999999999
980 +10000000000:-1:9999999999
981 +123456789:987654321:1111111110
982 -123456789:987654321:864197532
983 -123456789:-987654321:-1111111110
984 +123456789:-987654321:-864197532
985 &bsub
986 abc:abc:NaN
987 abc:+0:NaN
988 +0:abc:NaN
989 +inf:-inf:inf
990 -inf:+inf:-inf
991 +inf:+inf:0
992 -inf:-inf:0
993 +0:+0:0
994 +1:+0:1
995 +0:+1:-1
996 +1:+1:0
997 -1:+0:-1
998 +0:-1:1
999 -1:-1:0
1000 -1:+1:-2
1001 +1:-1:2
1002 +9:+1:8
1003 +99:+1:98
1004 +999:+1:998
1005 +9999:+1:9998
1006 +99999:+1:99998
1007 +999999:+1:999998
1008 +9999999:+1:9999998
1009 +99999999:+1:99999998
1010 +999999999:+1:999999998
1011 +9999999999:+1:9999999998
1012 +99999999999:+1:99999999998
1013 +10:-1:11
1014 +100:-1:101
1015 +1000:-1:1001
1016 +10000:-1:10001
1017 +100000:-1:100001
1018 +1000000:-1:1000001
1019 +10000000:-1:10000001
1020 +100000000:-1:100000001
1021 +1000000000:-1:1000000001
1022 +10000000000:-1:10000000001
1023 +123456789:+987654321:-864197532
1024 -123456789:+987654321:-1111111110
1025 -123456789:-987654321:864197532
1026 +123456789:-987654321:1111111110
1027 &bmul
1028 abc:abc:NaN
1029 abc:+0:NaN
1030 +0:abc:NaN
1031 NaNmul:+inf:NaN
1032 NaNmul:-inf:NaN
1033 -inf:NaNmul:NaN
1034 +inf:NaNmul:NaN
1035 +inf:+inf:inf
1036 +inf:-inf:-inf
1037 -inf:+inf:-inf
1038 -inf:-inf:inf
1039 +0:+0:0
1040 +0:+1:0
1041 +1:+0:0
1042 +0:-1:0
1043 -1:+0:0
1044 123456789123456789:0:0
1045 0:123456789123456789:0
1046 -1:-1:1
1047 -1:+1:-1
1048 +1:-1:-1
1049 +1:+1:1
1050 +2:+3:6
1051 -2:+3:-6
1052 +2:-3:-6
1053 -2:-3:6
1054 111:111:12321
1055 10101:10101:102030201
1056 1001001:1001001:1002003002001
1057 100010001:100010001:10002000300020001
1058 10000100001:10000100001:100002000030000200001
1059 11111111111:9:99999999999
1060 22222222222:9:199999999998
1061 33333333333:9:299999999997
1062 44444444444:9:399999999996
1063 55555555555:9:499999999995
1064 66666666666:9:599999999994
1065 77777777777:9:699999999993
1066 88888888888:9:799999999992
1067 99999999999:9:899999999991
1068 +25:+25:625
1069 +12345:+12345:152399025
1070 +99999:+11111:1111088889
1071 9999:10000:99990000
1072 99999:100000:9999900000
1073 999999:1000000:999999000000
1074 9999999:10000000:99999990000000
1075 99999999:100000000:9999999900000000
1076 999999999:1000000000:999999999000000000
1077 9999999999:10000000000:99999999990000000000
1078 99999999999:100000000000:9999999999900000000000
1079 999999999999:1000000000000:999999999999000000000000
1080 9999999999999:10000000000000:99999999999990000000000000
1081 99999999999999:100000000000000:9999999999999900000000000000
1082 999999999999999:1000000000000000:999999999999999000000000000000
1083 9999999999999999:10000000000000000:99999999999999990000000000000000
1084 99999999999999999:100000000000000000:9999999999999999900000000000000000
1085 999999999999999999:1000000000000000000:999999999999999999000000000000000000
1086 9999999999999999999:10000000000000000000:99999999999999999990000000000000000000
1087 &bdiv-list
1088 100:20:5,0
1089 4095:4095:1,0
1090 -4095:-4095:1,0
1091 4095:-4095:-1,0
1092 -4095:4095:-1,0
1093 123:2:61,1
1094 # inf handling and general remainder
1095 5:8:0,5
1096 0:8:0,0
1097 11:2:5,1
1098 11:-2:-5,-1
1099 -11:2:-5,1
1100 # see table in documentation in MBI
1101 0:inf:0,0
1102 0:-inf:0,0
1103 5:inf:0,5
1104 5:-inf:0,5
1105 -5:inf:0,-5
1106 -5:-inf:0,-5
1107 inf:5:inf,0
1108 -inf:5:-inf,0
1109 inf:-5:-inf,0
1110 -inf:-5:inf,0
1111 5:5:1,0
1112 -5:-5:1,0
1113 inf:inf:1,0
1114 -inf:-inf:1,0
1115 -inf:inf:-1,0
1116 inf:-inf:-1,0
1117 8:0:inf,8
1118 inf:0:inf,inf
1119 # exceptions to reminder rule
1120 -8:0:-inf,-8
1121 -inf:0:-inf,-inf
1122 0:0:NaN,NaN
1123 &bdiv
1124 abc:abc:NaN
1125 abc:1:NaN
1126 1:abc:NaN
1127 0:0:NaN
1128 # inf handling (see table in doc)
1129 0:inf:0
1130 0:-inf:0
1131 5:inf:0
1132 5:-inf:0
1133 -5:inf:0
1134 -5:-inf:0
1135 inf:5:inf
1136 -inf:5:-inf
1137 inf:-5:-inf
1138 -inf:-5:inf
1139 5:5:1
1140 -5:-5:1
1141 inf:inf:1
1142 -inf:-inf:1
1143 -inf:inf:-1
1144 inf:-inf:-1
1145 8:0:inf
1146 inf:0:inf
1147 -8:0:-inf
1148 -inf:0:-inf
1149 0:0:NaN
1150 11:2:5
1151 -11:-2:5
1152 -11:2:-5
1153 11:-2:-5
1154 0:1:0
1155 0:-1:0
1156 1:1:1
1157 -1:-1:1
1158 1:-1:-1
1159 -1:1:-1
1160 1:2:0
1161 2:1:2
1162 1:26:0
1163 1000000000:9:111111111
1164 2000000000:9:222222222
1165 3000000000:9:333333333
1166 4000000000:9:444444444
1167 5000000000:9:555555555
1168 6000000000:9:666666666
1169 7000000000:9:777777777
1170 8000000000:9:888888888
1171 9000000000:9:1000000000
1172 35500000:113:314159
1173 71000000:226:314159
1174 106500000:339:314159
1175 1000000000:3:333333333
1176 +10:+5:2
1177 +100:+4:25
1178 +1000:+8:125
1179 +10000:+16:625
1180 999999999999:9:111111111111
1181 999999999999:99:10101010101
1182 999999999999:999:1001001001
1183 999999999999:9999:100010001
1184 999999999999999:99999:10000100001
1185 +1111088889:99999:11111
1186 -5:-3:1
1187 -5:3:-1
1188 4:3:1
1189 4:-3:-1
1190 1:3:0
1191 1:-3:0
1192 -2:-3:0
1193 -2:3:0
1194 8:3:2
1195 -8:3:-2
1196 14:-3:-4
1197 -14:3:-4
1198 -14:-3:4
1199 14:3:4
1200 # bug in Calc with '99999' vs $BASE-1
1201 10000000000000000000000000000000000000000000000000000000000000000000000000000000000:10000000375084540248994272022843165711074:999999962491547381984643365663244474111576
1202 &bmod
1203 # inf handling, see table in doc
1204 0:inf:0
1205 0:-inf:0
1206 5:inf:5
1207 5:-inf:5
1208 -5:inf:-5
1209 -5:-inf:-5
1210 inf:5:0
1211 -inf:5:0
1212 inf:-5:0
1213 -inf:-5:0
1214 5:5:0
1215 -5:-5:0
1216 inf:inf:0
1217 -inf:-inf:0
1218 -inf:inf:0
1219 inf:-inf:0
1220 8:0:8
1221 inf:0:inf
1222 # exceptions to reminder rule
1223 -inf:0:-inf
1224 -8:0:-8
1225 0:0:NaN
1226 abc:abc:NaN
1227 abc:1:abc:NaN
1228 1:abc:NaN
1229 0:0:NaN
1230 0:1:0
1231 1:0:1
1232 0:-1:0
1233 -1:0:-1
1234 1:1:0
1235 -1:-1:0
1236 1:-1:0
1237 -1:1:0
1238 1:2:1
1239 2:1:0
1240 1000000000:9:1
1241 2000000000:9:2
1242 3000000000:9:3
1243 4000000000:9:4
1244 5000000000:9:5
1245 6000000000:9:6
1246 7000000000:9:7
1247 8000000000:9:8
1248 9000000000:9:0
1249 35500000:113:33
1250 71000000:226:66
1251 106500000:339:99
1252 1000000000:3:1
1253 10:5:0
1254 100:4:0
1255 1000:8:0
1256 10000:16:0
1257 999999999999:9:0
1258 999999999999:99:0
1259 999999999999:999:0
1260 999999999999:9999:0
1261 999999999999999:99999:0
1262 -9:+5:1
1263 +9:-5:-1
1264 -9:-5:-4
1265 -5:3:1
1266 -2:3:1
1267 4:3:1
1268 1:3:1
1269 -5:-3:-2
1270 -2:-3:-2
1271 4:-3:-2
1272 1:-3:-2
1273 4095:4095:0
1274 100041000510123:3:0
1275 152403346:12345:4321
1276 &bgcd
1277 abc:abc:NaN
1278 abc:+0:NaN
1279 +0:abc:NaN
1280 +0:+0:0
1281 +0:+1:1
1282 +1:+0:1
1283 +1:+1:1
1284 +2:+3:1
1285 +3:+2:1
1286 -3:+2:1
1287 100:625:25
1288 4096:81:1
1289 1034:804:2
1290 27:90:56:1
1291 27:90:54:9
1292 &blcm
1293 abc:abc:NaN
1294 abc:+0:NaN
1295 +0:abc:NaN
1296 +0:+0:NaN
1297 +1:+0:0
1298 +0:+1:0
1299 +27:+90:270
1300 +1034:+804:415668
1301 &band
1302 abc:abc:NaN
1303 abc:0:NaN
1304 0:abc:NaN
1305 1:2:0
1306 3:2:2
1307 +8:+2:0
1308 +281474976710656:0:0
1309 +281474976710656:1:0
1310 +281474976710656:+281474976710656:281474976710656
1311 -2:-3:-4
1312 -1:-1:-1
1313 -6:-6:-6
1314 -7:-4:-8
1315 -7:4:0
1316 -4:7:4
1317 # equal arguments are treated special, so also do some test with unequal ones
1318 0xFFFF:0xFFFF:0x0xFFFF
1319 0xFFFFFF:0xFFFFFF:0x0xFFFFFF
1320 0xFFFFFFFF:0xFFFFFFFF:0x0xFFFFFFFF
1321 0xFFFFFFFFFF:0xFFFFFFFFFF:0x0xFFFFFFFFFF
1322 0xFFFFFFFFFFFF:0xFFFFFFFFFFFF:0x0xFFFFFFFFFFFF
1323 0xF0F0:0xF0F0:0x0xF0F0
1324 0x0F0F:0x0F0F:0x0x0F0F
1325 0xF0F0F0:0xF0F0F0:0x0xF0F0F0
1326 0x0F0F0F:0x0F0F0F:0x0x0F0F0F
1327 0xF0F0F0F0:0xF0F0F0F0:0x0xF0F0F0F0
1328 0x0F0F0F0F:0x0F0F0F0F:0x0x0F0F0F0F
1329 0xF0F0F0F0F0:0xF0F0F0F0F0:0x0xF0F0F0F0F0
1330 0x0F0F0F0F0F:0x0F0F0F0F0F:0x0x0F0F0F0F0F
1331 0xF0F0F0F0F0F0:0xF0F0F0F0F0F0:0x0xF0F0F0F0F0F0
1332 0x0F0F0F0F0F0F:0x0F0F0F0F0F0F:0x0x0F0F0F0F0F0F
1333 0x1F0F0F0F0F0F:0x3F0F0F0F0F0F:0x0x1F0F0F0F0F0F
1334 &bior
1335 abc:abc:NaN
1336 abc:0:NaN
1337 0:abc:NaN
1338 1:2:3
1339 +8:+2:10
1340 +281474976710656:0:281474976710656
1341 +281474976710656:1:281474976710657
1342 +281474976710656:281474976710656:281474976710656
1343 -2:-3:-1
1344 -1:-1:-1
1345 -6:-6:-6
1346 -7:4:-3
1347 -4:7:-1
1348 # equal arguments are treated special, so also do some test with unequal ones
1349 0xFFFF:0xFFFF:0x0xFFFF
1350 0xFFFFFF:0xFFFFFF:0x0xFFFFFF
1351 0xFFFFFFFF:0xFFFFFFFF:0x0xFFFFFFFF
1352 0xFFFFFFFFFF:0xFFFFFFFFFF:0x0xFFFFFFFFFF
1353 0xFFFFFFFFFFFF:0xFFFFFFFFFFFF:0x0xFFFFFFFFFFFF
1354 0:0xFFFF:0x0xFFFF
1355 0:0xFFFFFF:0x0xFFFFFF
1356 0:0xFFFFFFFF:0x0xFFFFFFFF
1357 0:0xFFFFFFFFFF:0x0xFFFFFFFFFF
1358 0:0xFFFFFFFFFFFF:0x0xFFFFFFFFFFFF
1359 0xFFFF:0:0x0xFFFF
1360 0xFFFFFF:0:0x0xFFFFFF
1361 0xFFFFFFFF:0:0x0xFFFFFFFF
1362 0xFFFFFFFFFF:0:0x0xFFFFFFFFFF
1363 0xFFFFFFFFFFFF:0:0x0xFFFFFFFFFFFF
1364 0xF0F0:0xF0F0:0x0xF0F0
1365 0x0F0F:0x0F0F:0x0x0F0F
1366 0xF0F0:0x0F0F:0x0xFFFF
1367 0xF0F0F0:0xF0F0F0:0x0xF0F0F0
1368 0x0F0F0F:0x0F0F0F:0x0x0F0F0F
1369 0x0F0F0F:0xF0F0F0:0x0xFFFFFF
1370 0xF0F0F0F0:0xF0F0F0F0:0x0xF0F0F0F0
1371 0x0F0F0F0F:0x0F0F0F0F:0x0x0F0F0F0F
1372 0x0F0F0F0F:0xF0F0F0F0:0x0xFFFFFFFF
1373 0xF0F0F0F0F0:0xF0F0F0F0F0:0x0xF0F0F0F0F0
1374 0x0F0F0F0F0F:0x0F0F0F0F0F:0x0x0F0F0F0F0F
1375 0x0F0F0F0F0F:0xF0F0F0F0F0:0x0xFFFFFFFFFF
1376 0xF0F0F0F0F0F0:0xF0F0F0F0F0F0:0x0xF0F0F0F0F0F0
1377 0x0F0F0F0F0F0F:0x0F0F0F0F0F0F:0x0x0F0F0F0F0F0F
1378 0x0F0F0F0F0F0F:0xF0F0F0F0F0F0:0x0xFFFFFFFFFFFF
1379 0x1F0F0F0F0F0F:0xF0F0F0F0F0F0:0x0xFFFFFFFFFFFF
1380 &bxor
1381 abc:abc:NaN
1382 abc:0:NaN
1383 0:abc:NaN
1384 1:2:3
1385 +8:+2:10
1386 +281474976710656:0:281474976710656
1387 +281474976710656:1:281474976710657
1388 +281474976710656:281474976710656:0
1389 -2:-3:3
1390 -1:-1:0
1391 -6:-6:0
1392 -7:4:-3
1393 -4:7:-5
1394 4:-7:-3
1395 -4:-7:5
1396 # equal arguments are treated special, so also do some test with unequal ones
1397 0xFFFF:0xFFFF:0
1398 0xFFFFFF:0xFFFFFF:0
1399 0xFFFFFFFF:0xFFFFFFFF:0
1400 0xFFFFFFFFFF:0xFFFFFFFFFF:0
1401 0xFFFFFFFFFFFF:0xFFFFFFFFFFFF:0
1402 0:0xFFFF:0x0xFFFF
1403 0:0xFFFFFF:0x0xFFFFFF
1404 0:0xFFFFFFFF:0x0xFFFFFFFF
1405 0:0xFFFFFFFFFF:0x0xFFFFFFFFFF
1406 0:0xFFFFFFFFFFFF:0x0xFFFFFFFFFFFF
1407 0xFFFF:0:0x0xFFFF
1408 0xFFFFFF:0:0x0xFFFFFF
1409 0xFFFFFFFF:0:0x0xFFFFFFFF
1410 0xFFFFFFFFFF:0:0x0xFFFFFFFFFF
1411 0xFFFFFFFFFFFF:0:0x0xFFFFFFFFFFFF
1412 0xF0F0:0xF0F0:0
1413 0x0F0F:0x0F0F:0
1414 0xF0F0:0x0F0F:0x0xFFFF
1415 0xF0F0F0:0xF0F0F0:0
1416 0x0F0F0F:0x0F0F0F:0
1417 0x0F0F0F:0xF0F0F0:0x0xFFFFFF
1418 0xF0F0F0F0:0xF0F0F0F0:0
1419 0x0F0F0F0F:0x0F0F0F0F:0
1420 0x0F0F0F0F:0xF0F0F0F0:0x0xFFFFFFFF
1421 0xF0F0F0F0F0:0xF0F0F0F0F0:0
1422 0x0F0F0F0F0F:0x0F0F0F0F0F:0
1423 0x0F0F0F0F0F:0xF0F0F0F0F0:0x0xFFFFFFFFFF
1424 0xF0F0F0F0F0F0:0xF0F0F0F0F0F0:0
1425 0x0F0F0F0F0F0F:0x0F0F0F0F0F0F:0
1426 0x0F0F0F0F0F0F:0xF0F0F0F0F0F0:0x0xFFFFFFFFFFFF
1427 &bnot
1428 abc:NaN
1429 +0:-1
1430 +8:-9
1431 +281474976710656:-281474976710657
1432 -1:0
1433 -2:1
1434 -12:11
1435 &digit
1436 0:0:0
1437 12:0:2
1438 12:1:1
1439 123:0:3
1440 123:1:2
1441 123:2:1
1442 123:-1:1
1443 123:-2:2
1444 123:-3:3
1445 123456:0:6
1446 123456:1:5
1447 123456:2:4
1448 123456:3:3
1449 123456:4:2
1450 123456:5:1
1451 123456:-1:1
1452 123456:-2:2
1453 123456:-3:3
1454 100000:-3:0
1455 100000:0:0
1456 100000:1:0
1457 &mantissa
1458 abc:NaN
1459 1e4:1
1460 2e0:2
1461 123:123
1462 -1:-1
1463 -2:-2
1464 +inf:inf
1465 -inf:-inf
1466 &exponent
1467 abc:NaN
1468 1e4:4
1469 2e0:0
1470 123:0
1471 -1:0
1472 -2:0
1473 0:1
1474 +inf:inf
1475 -inf:inf
1476 &parts
1477 abc:NaN,NaN
1478 1e4:1,4
1479 2e0:2,0
1480 123:123,0
1481 -1:-1,0
1482 -2:-2,0
1483 0:0,1
1484 +inf:inf,inf
1485 -inf:-inf,inf
1486 &bpow
1487 abc:12:NaN
1488 12:abc:NaN
1489 0:0:1
1490 0:1:0
1491 0:2:0
1492 0:-1:NaN
1493 0:-2:NaN
1494 1:0:1
1495 1:1:1
1496 1:2:1
1497 1:3:1
1498 1:-1:1
1499 1:-2:1
1500 1:-3:1
1501 2:0:1
1502 2:1:2
1503 2:2:4
1504 2:3:8
1505 3:3:27
1506 2:-1:NaN
1507 -2:-1:NaN
1508 2:-2:NaN
1509 -2:-2:NaN
1510 +inf:1234500012:inf
1511 -inf:1234500012:-inf
1512 +inf:-12345000123:inf
1513 -inf:-12345000123:-inf
1514 # 1 ** -x => 1 / (1 ** x)
1515 -1:0:1
1516 -2:0:1
1517 -1:1:-1
1518 -1:2:1
1519 -1:3:-1
1520 -1:4:1
1521 -1:5:-1
1522 -1:-1:-1
1523 -1:-2:1
1524 -1:-3:-1
1525 -1:-4:1
1526 10:2:100
1527 10:3:1000
1528 10:4:10000
1529 10:5:100000
1530 10:6:1000000
1531 10:7:10000000
1532 10:8:100000000
1533 10:9:1000000000
1534 10:20:100000000000000000000
1535 123456:2:15241383936
1536 &length
1537 100:3
1538 10:2
1539 1:1
1540 0:1
1541 12345:5
1542 10000000000000000:17
1543 -123:3
1544 215960156869840440586892398248:30
1545 &bsqrt
1546 145:12
1547 144:12
1548 143:11
1549 16:4
1550 170:13
1551 169:13
1552 168:12
1553 4:2
1554 3:1
1555 2:1
1556 9:3
1557 12:3
1558 256:16
1559 100000000:10000
1560 4000000000000:2000000
1561 152399026:12345
1562 152399025:12345
1563 152399024:12344
1564 1:1
1565 0:0
1566 -2:NaN
1567 -123:NaN
1568 Nan:NaN
1569 +inf:NaN
1570 &bround
1571 $round_mode('trunc')
1572 0:12:0
1573 NaNbround:12:NaN
1574 +inf:12:inf
1575 -inf:12:-inf
1576 1234:0:1234
1577 1234:2:1200
1578 123456:4:123400
1579 123456:5:123450
1580 123456:6:123456
1581 +10123456789:5:10123000000
1582 -10123456789:5:-10123000000
1583 +10123456789:9:10123456700
1584 -10123456789:9:-10123456700
1585 +101234500:6:101234000
1586 -101234500:6:-101234000
1587 #+101234500:-4:101234000
1588 #-101234500:-4:-101234000
1589 $round_mode('zero')
1590 +20123456789:5:20123000000
1591 -20123456789:5:-20123000000
1592 +20123456789:9:20123456800
1593 -20123456789:9:-20123456800
1594 +201234500:6:201234000
1595 -201234500:6:-201234000
1596 #+201234500:-4:201234000
1597 #-201234500:-4:-201234000
1598 +12345000:4:12340000
1599 -12345000:4:-12340000
1600 $round_mode('+inf')
1601 +30123456789:5:30123000000
1602 -30123456789:5:-30123000000
1603 +30123456789:9:30123456800
1604 -30123456789:9:-30123456800
1605 +301234500:6:301235000
1606 -301234500:6:-301234000
1607 #+301234500:-4:301235000
1608 #-301234500:-4:-301234000
1609 +12345000:4:12350000
1610 -12345000:4:-12340000
1611 $round_mode('-inf')
1612 +40123456789:5:40123000000
1613 -40123456789:5:-40123000000
1614 +40123456789:9:40123456800
1615 -40123456789:9:-40123456800
1616 +401234500:6:401234000
1617 +401234500:6:401234000
1618 #-401234500:-4:-401235000
1619 #-401234500:-4:-401235000
1620 +12345000:4:12340000
1621 -12345000:4:-12350000
1622 $round_mode('odd')
1623 +50123456789:5:50123000000
1624 -50123456789:5:-50123000000
1625 +50123456789:9:50123456800
1626 -50123456789:9:-50123456800
1627 +501234500:6:501235000
1628 -501234500:6:-501235000
1629 #+501234500:-4:501235000
1630 #-501234500:-4:-501235000
1631 +12345000:4:12350000
1632 -12345000:4:-12350000
1633 $round_mode('even')
1634 +60123456789:5:60123000000
1635 -60123456789:5:-60123000000
1636 +60123456789:9:60123456800
1637 -60123456789:9:-60123456800
1638 +601234500:6:601234000
1639 -601234500:6:-601234000
1640 #+601234500:-4:601234000
1641 #-601234500:-4:-601234000
1642 #-601234500:-9:0
1643 #-501234500:-9:0
1644 #-601234500:-8:0
1645 #-501234500:-8:0
1646 +1234567:7:1234567
1647 +1234567:6:1234570
1648 +12345000:4:12340000
1649 -12345000:4:-12340000
1650 &is_zero
1651 0:1
1652 NaNzero:0
1653 +inf:0
1654 -inf:0
1655 123:0
1656 -1:0
1657 1:0
1658 &is_one
1659 0:0
1660 NaNone:0
1661 +inf:0
1662 -inf:0
1663 1:1
1664 2:0
1665 -1:0
1666 -2:0
1667 # floor and ceil tests are pretty pointless in integer space...but play safe
1668 &bfloor
1669 0:0
1670 NaNfloor:NaN
1671 +inf:inf
1672 -inf:-inf
1673 -1:-1
1674 -2:-2
1675 2:2
1676 3:3
1677 abc:NaN
1678 &bceil
1679 NaNceil:NaN
1680 +inf:inf
1681 -inf:-inf
1682 0:0
1683 -1:-1
1684 -2:-2
1685 2:2
1686 3:3
1687 abc:NaN
1688 &as_hex
1689 128:0x80
1690 -128:-0x80
1691 0:0x0
1692 -0:0x0
1693 1:0x1
1694 0x123456789123456789:0x123456789123456789
1695 +inf:inf
1696 -inf:-inf
1697 NaNas_hex:NaN
1698 &as_bin
1699 128:0b10000000
1700 -128:-0b10000000
1701 0:0b0
1702 -0:0b0
1703 1:0b1
1704 0b1010111101010101010110110110110110101:0b1010111101010101010110110110110110101
1705 +inf:inf
1706 -inf:-inf
1707 NaNas_bin:NaN