lib/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}; ok ($CALC,$CL);
  40
  41 my ($f,$z,$a,$exp,@a,$m,$e,$round_mode,$expected_class);
  42
  43 while (<DATA>)
  44   {
  45   chomp;
  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|sstr|neg|abs|inc|dec|not|sqrt|fac)$/) {
  77     $try .= "\$x->$f();";
  78    } elsif ($f =~ /^(numify|length|stringify|as_hex|as_bin)$/) {
  79     $try .= "\$x->$f();";
  80    } elsif ($f eq "exponent"){
  81     # ->bstr() to see if an object is returned
  82     $try .= '$x = $x->exponent()->bstr();';
  83    } elsif ($f eq "mantissa"){
  84     # ->bstr() to see if an object is returned
  85     $try .= '$x = $x->mantissa()->bstr();';
  86    } elsif ($f eq "parts"){
  87     $try .= '($m,$e) = $x->parts();';
  88     # ->bstr() to see if an object is returned
  89     $try .= '$m = $m->bstr(); $m = "NaN" if !defined $m;';
  90     $try .= '$e = $e->bstr(); $e = "NaN" if !defined $e;';
  91     $try .= '"$m,$e";';
  92    } else {
  93     # binary ops
  94     $try .= "\$y = $class->new('$args[1]');";
  95     if ($f eq "bcmp")
  96       {
  97       $try .= '$x <=> $y;';
  98       } elsif ($f eq "bround") {
  99       $try .= "$round_mode; \$x->bround(\$y);";
 100       } elsif ($f eq "bacmp"){
 101       $try .= '$x->bacmp($y);';
 102       } elsif ($f eq "badd"){
 103       $try .= '$x + $y;';
 104       } elsif ($f eq "bsub"){
 105       $try .= '$x - $y;';
 106       } elsif ($f eq "bmul"){
 107       $try .= '$x * $y;';
 108       } elsif ($f eq "bdiv"){
 109       $try .= '$x / $y;';
 110       } elsif ($f eq "bdiv-list"){
 111       $try .= 'join (",",$x->bdiv($y));';
 112       # overload via x=
 113       } elsif ($f =~ /^.=$/){
 114       $try .= "\$x $f \$y;";
 115       # overload via x
 116       } elsif ($f =~ /^.$/){
 117       $try .= "\$x $f \$y;";
 118       } elsif ($f eq "bmod"){
 119       $try .= '$x % $y;';
 120       } elsif ($f eq "bgcd")
 121         {
 122         if (defined $args[2])
 123           {
 124           $try .= " \$z = $class->new('$args[2]'); ";
 125           }
 126         $try .= "$class\::bgcd(\$x, \$y";
 127         $try .= ", \$z" if (defined $args[2]);
 128         $try .= " );";
 129         }
 130       elsif ($f eq "blcm")
 131         {
 132         if (defined $args[2])
 133           {
 134           $try .= " \$z = $class->new('$args[2]'); ";
 135           }
 136         $try .= "$class\::blcm(\$x, \$y";
 137         $try .= ", \$z" if (defined $args[2]);
 138         $try .= " );";
 139       }elsif ($f eq "blsft"){
 140         if (defined $args[2])
 141           {
 142           $try .= "\$x->blsft(\$y,$args[2]);";
 143           }
 144         else
 145           {
 146           $try .= "\$x << \$y;";
 147           }
 148       }elsif ($f eq "brsft"){
 149         if (defined $args[2])
 150           {
 151           $try .= "\$x->brsft(\$y,$args[2]);";
 152           }
 153         else
 154           {
 155           $try .= "\$x >> \$y;";
 156           }
 157       }elsif ($f eq "broot"){
 158         $try .= "\$x->broot(\$y);";
 159       }elsif ($f eq "band"){
 160         $try .= "\$x & \$y;";
 161       }elsif ($f eq "bior"){
 162         $try .= "\$x | \$y;";
 163       }elsif ($f eq "bxor"){
 164         $try .= "\$x ^ \$y;";
 165       }elsif ($f eq "bpow"){
 166         $try .= "\$x ** \$y;";
 167       } elsif( $f eq "bmodinv") {
 168        $try .= "\$x->bmodinv(\$y);";
 169       }elsif ($f eq "digit"){
 170         $try .= "\$x->digit(\$y);";
 171       } else {
 172        $try .= "\$z = $class->new(\"$args[2]\");";
 173
 174        # Functions with three arguments
 175        if( $f eq "bmodpow") {
 176          $try .= "\$x->bmodpow(\$y,\$z);";
 177        } else { warn "Unknown op '$f'"; }
 178       }
 179     } # end else all other ops
 180
 181   $ans1 = eval $try;
 182   # convert hex/binary targets to decimal
 183   if ($ans =~ /^(0x0x|0b0b)/)
 184     {
 185     $ans =~ s/^0[xb]//; $ans = Math::BigInt->new($ans)->bstr();
 186     }
 187   if ($ans eq "")
 188     {
 189     ok_undef ($ans1);
 190     }
 191   else
 192     {
 193     # print "try: $try ans: $ans1 $ans\n";
 194     print "# Tried: '$try'\n" if !ok ($ans1, $ans);
 195     ok (ref($ans),$expected_class) if $expected_class ne $class;
 196     }
 197   # check internal state of number objects
 198   is_valid($ans1,$f) if ref $ans1;
 199   } # endwhile data tests
 200 close DATA;
 201
 202 # test some more
 203 @a = ();
 204 for (my $i = 1; $i < 10; $i++)
 205   {
 206   push @a, $i;
 207   }
 208 ok "@a", "1 2 3 4 5 6 7 8 9";
 209
 210 # test whether self-multiplication works correctly (result is 2**64)
 211 $try = "\$x = $class->new('4294967296');";
 212 $try .= '$a = $x->bmul($x);';
 213 $ans1 = eval $try;
 214 print "# Tried: '$try'\n" if !ok ($ans1, $class->new(2) ** 64);
 215 # test self-pow
 216 $try = "\$x = $class->new(10);";
 217 $try .= '$a = $x->bpow($x);';
 218 $ans1 = eval $try;
 219 print "# Tried: '$try'\n" if !ok ($ans1, $class->new(10) ** 10);
 220
 221 ###############################################################################
 222 # test whether op destroys args or not (should better not)
 223
 224 $x = $class->new(3);
 225 $y = $class->new(4);
 226 $z = $x & $y;
 227 ok ($x,3);
 228 ok ($y,4);
 229 ok ($z,0);
 230 $z = $x | $y;
 231 ok ($x,3);
 232 ok ($y,4);
 233 ok ($z,7);
 234 $x = $class->new(1);
 235 $y = $class->new(2);
 236 $z = $x | $y;
 237 ok ($x,1);
 238 ok ($y,2);
 239 ok ($z,3);
 240
 241 $x = $class->new(5);
 242 $y = $class->new(4);
 243 $z = $x ^ $y;
 244 ok ($x,5);
 245 ok ($y,4);
 246 ok ($z,1);
 247
 248 $x = $class->new(-5); $y = -$x;
 249 ok ($x, -5);
 250
 251 $x = $class->new(-5); $y = abs($x);
 252 ok ($x, -5);
 253
 254 $x = $class->new(8);
 255 $y = $class->new(-1);
 256 $z = $class->new(5033);
 257 my $u = $x->copy()->bmodpow($y,$z);
 258 ok ($u,4404);
 259 ok ($y,-1);
 260 ok ($z,5033);
 261
 262 $x = $class->new(-5); $y = -$x; ok ($x,-5); ok ($y,5);
 263 $x = $class->new(-5); $y = $x->copy()->bneg(); ok ($x,-5); ok ($y,5);
 264
 265 $x = $class->new(-5); $y = $class->new(3); $x->bmul($y); ok ($x,-15); ok ($y,3);
 266 $x = $class->new(-5); $y = $class->new(3); $x->badd($y); ok ($x,-2); ok ($y,3);
 267 $x = $class->new(-5); $y = $class->new(3); $x->bsub($y); ok ($x,-8); ok ($y,3);
 268 $x = $class->new(-15); $y = $class->new(3); $x->bdiv($y); ok ($x,-5); ok ($y,3);
 269 $x = $class->new(-5); $y = $class->new(3); $x->bmod($y); ok ($x,1); ok ($y,3);
 270
 271 $x = $class->new(5); $y = $class->new(3); $x->bmul($y); ok ($x,15); ok ($y,3);
 272 $x = $class->new(5); $y = $class->new(3); $x->badd($y); ok ($x,8); ok ($y,3);
 273 $x = $class->new(5); $y = $class->new(3); $x->bsub($y); ok ($x,2); ok ($y,3);
 274 $x = $class->new(15); $y = $class->new(3); $x->bdiv($y); ok ($x,5); ok ($y,3);
 275 $x = $class->new(5); $y = $class->new(3); $x->bmod($y); ok ($x,2); ok ($y,3);
 276
 277 $x = $class->new(5); $y = $class->new(-3); $x->bmul($y); ok ($x,-15); ok($y,-3);
 278 $x = $class->new(5); $y = $class->new(-3); $x->badd($y); ok ($x,2); ok($y,-3);
 279 $x = $class->new(5); $y = $class->new(-3); $x->bsub($y); ok ($x,8); ok($y,-3);
 280 $x = $class->new(15); $y = $class->new(-3); $x->bdiv($y); ok ($x,-5); ok($y,-3);
 281 $x = $class->new(5); $y = $class->new(-3); $x->bmod($y); ok ($x,-1); ok($y,-3);
 282
 283 ###############################################################################
 284 # check whether overloading cmp works
 285 $try = "\$x = $class->new(0);";
 286 $try .= "\$y = 10;";
 287 $try .= "'false' if \$x ne \$y;";
 288 $ans = eval $try;
 289 print "# For '$try'\n" if (!ok "$ans" , "false" );
 290
 291 # we cant test for working cmpt with other objects here, we would need a dummy
 292 # object with stringify overload for this. see Math::String tests as example
 293
 294 ###############################################################################
 295 # check reversed order of arguments
 296
 297 $try = "\$x = $class->new(10); \$x = 2 ** \$x;";
 298 $try .= "'ok' if \$x == 1024;"; $ans = eval $try;
 299 print "# For '$try'\n" if (!ok "$ans" , "ok" );
 300
 301 $try = "\$x = $class->new(10); \$x = 2 * \$x;";
 302 $try .= "'ok' if \$x == 20;"; $ans = eval $try;
 303 print "# For '$try'\n" if (!ok "$ans" , "ok" );
 304
 305 $try = "\$x = $class->new(10); \$x = 2 + \$x;";
 306 $try .= "'ok' if \$x == 12;"; $ans = eval $try;
 307 print "# For '$try'\n" if (!ok "$ans" , "ok" );
 308
 309 $try = "\$x = $class\->new(10); \$x = 2 - \$x;";
 310 $try .= "'ok' if \$x == -8;"; $ans = eval $try;
 311 print "# For '$try'\n" if (!ok "$ans" , "ok" );
 312
 313 $try = "\$x = $class\->new(10); \$x = 20 / \$x;";
 314 $try .= "'ok' if \$x == 2;"; $ans = eval $try;
 315 print "# For '$try'\n" if (!ok "$ans" , "ok" );
 316
 317 $try = "\$x = $class\->new(3); \$x = 20 % \$x;";
 318 $try .= "'ok' if \$x == 2;"; $ans = eval $try;
 319 print "# For '$try'\n" if (!ok "$ans" , "ok" );
 320
 321 $try = "\$x = $class\->new(7); \$x = 20 & \$x;";
 322 $try .= "'ok' if \$x == 4;"; $ans = eval $try;
 323 print "# For '$try'\n" if (!ok "$ans" , "ok" );
 324
 325 $try = "\$x = $class\->new(7); \$x = 0x20 | \$x;";
 326 $try .= "'ok' if \$x == 0x27;"; $ans = eval $try;
 327 print "# For '$try'\n" if (!ok "$ans" , "ok" );
 328
 329 $try = "\$x = $class\->new(7); \$x = 0x20 ^ \$x;";
 330 $try .= "'ok' if \$x == 0x27;"; $ans = eval $try;
 331 print "# For '$try'\n" if (!ok "$ans" , "ok" );
 332
 333 ###############################################################################
 334 # check badd(4,5) form
 335
 336 $try = "\$x = $class\->badd(4,5);";
 337 $try .= "'ok' if \$x == 9;";
 338 $ans = eval $try;
 339 print "# For '$try'\n" if (!ok "$ans" , "ok" );
 340
 341 ###############################################################################
 342 # check undefs: NOT DONE YET
 343
 344 ###############################################################################
 345 # bool
 346
 347 $x = $class->new(1); if ($x) { ok (1,1); } else { ok($x,'to be true') }
 348 $x = $class->new(0); if (!$x) { ok (1,1); } else { ok($x,'to be false') }
 349
 350 ###############################################################################
 351 # objectify()
 352
 353 @args = Math::BigInt::objectify(2,4,5);
 354 ok (scalar @args,3);            # $class, 4, 5
 355 ok ($args[0] =~ /^Math::BigInt/);
 356 ok ($args[1],4);
 357 ok ($args[2],5);
 358
 359 @args = Math::BigInt::objectify(0,4,5);
 360 ok (scalar @args,3);            # $class, 4, 5
 361 ok ($args[0] =~ /^Math::BigInt/);
 362 ok ($args[1],4);
 363 ok ($args[2],5);
 364
 365 @args = Math::BigInt::objectify(2,4,5);
 366 ok (scalar @args,3);            # $class, 4, 5
 367 ok ($args[0] =~ /^Math::BigInt/);
 368 ok ($args[1],4);
 369 ok ($args[2],5);
 370
 371 @args = Math::BigInt::objectify(2,4,5,6,7);
 372 ok (scalar @args,5);            # $class, 4, 5, 6, 7
 373 ok ($args[0] =~ /^Math::BigInt/);
 374 ok ($args[1],4); ok (ref($args[1]),$args[0]);
 375 ok ($args[2],5); ok (ref($args[2]),$args[0]);
 376 ok ($args[3],6); ok (ref($args[3]),'');
 377 ok ($args[4],7); ok (ref($args[4]),'');
 378
 379 @args = Math::BigInt::objectify(2,$class,4,5,6,7);
 380 ok (scalar @args,5);            # $class, 4, 5, 6, 7
 381 ok ($args[0],$class);
 382 ok ($args[1],4); ok (ref($args[1]),$args[0]);
 383 ok ($args[2],5); ok (ref($args[2]),$args[0]);
 384 ok ($args[3],6); ok (ref($args[3]),'');
 385 ok ($args[4],7); ok (ref($args[4]),'');
 386
 387 ###############################################################################
 388 # test whether an opp calls objectify properly or not (or at least does what
 389 # it should do given non-objects, w/ or w/o objectify())
 390
 391 ok ($class->new(123)->badd(123),246);
 392 ok ($class->badd(123,321),444);
 393 ok ($class->badd(123,$class->new(321)),444);
 394
 395 ok ($class->new(123)->bsub(122),1);
 396 ok ($class->bsub(321,123),198);
 397 ok ($class->bsub(321,$class->new(123)),198);
 398
 399 ok ($class->new(123)->bmul(123),15129);
 400 ok ($class->bmul(123,123),15129);
 401 ok ($class->bmul(123,$class->new(123)),15129);
 402
 403 ok ($class->new(15129)->bdiv(123),123);
 404 ok ($class->bdiv(15129,123),123);
 405 ok ($class->bdiv(15129,$class->new(123)),123);
 406
 407 ok ($class->new(15131)->bmod(123),2);
 408 ok ($class->bmod(15131,123),2);
 409 ok ($class->bmod(15131,$class->new(123)),2);
 410
 411 ok ($class->new(2)->bpow(16),65536);
 412 ok ($class->bpow(2,16),65536);
 413 ok ($class->bpow(2,$class->new(16)),65536);
 414
 415 ok ($class->new(2**15)->brsft(1),2**14);
 416 ok ($class->brsft(2**15,1),2**14);
 417 ok ($class->brsft(2**15,$class->new(1)),2**14);
 418
 419 ok ($class->new(2**13)->blsft(1),2**14);
 420 ok ($class->blsft(2**13,1),2**14);
 421 ok ($class->blsft(2**13,$class->new(1)),2**14);
 422
 423 ###############################################################################
 424 # test for floating-point input (other tests in bnorm() below)
 425
 426 $z = 1050000000000000;          # may be int on systems with 64bit?
 427 $x = $class->new($z); ok ($x->bsstr(),'105e+13');       # not 1.05e+15
 428 $z = 1e+129;                    # definitely a float (may fail on UTS)
 429 # don't compare to $z, since some Perl versions stringify $z into something
 430 # like '1.e+129' or something equally ugly
 431 $x = $class->new($z); ok ($x->bsstr(),'1e+129');
 432
 433 ###############################################################################
 434 # test for whitespace inlcuding newlines to be handled correctly
 435
 436 # ok ($Math::BigInt::strict,1);         # the default
 437
 438 foreach my $c (
 439   qw/1 12 123 1234 12345 123456 1234567 12345678 123456789 1234567890/)
 440   {
 441   my $m = $class->new($c);
 442   ok ($class->new("$c"),$m);
 443   ok ($class->new(" $c"),$m);
 444   ok ($class->new("$c "),$m);
 445   ok ($class->new(" $c "),$m);
 446   ok ($class->new("\n$c"),$m);
 447   ok ($class->new("$c\n"),$m);
 448   ok ($class->new("\n$c\n"),$m);
 449   ok ($class->new(" \n$c\n"),$m);
 450   ok ($class->new(" \n$c \n"),$m);
 451   ok ($class->new(" \n$c\n "),$m);
 452   ok ($class->new(" \n$c\n1"),'NaN');
 453   ok ($class->new("1 \n$c\n1"),'NaN');
 454   }
 455
 456 ###############################################################################
 457 # prime number tests, also test for **= and length()
 458 # found on: http://www.utm.edu/research/primes/notes/by_year.html
 459
 460 # ((2^148)-1)/17
 461 $x = $class->new(2); $x **= 148; $x++; $x = $x / 17;
 462 ok ($x,"20988936657440586486151264256610222593863921");
 463 ok ($x->length(),length "20988936657440586486151264256610222593863921");
 464
 465 # MM7 = 2^127-1
 466 $x = $class->new(2); $x **= 127; $x--;
 467 ok ($x,"170141183460469231731687303715884105727");
 468
 469 $x = $class->new('215960156869840440586892398248');
 470 ($x,$y) = $x->length();
 471 ok ($x,30); ok ($y,0);
 472
 473 $x = $class->new('1_000_000_000_000');
 474 ($x,$y) = $x->length();
 475 ok ($x,13); ok ($y,0);
 476
 477 # I am afraid the following is not yet possible due to slowness
 478 # Also, testing for 2 meg output is a bit hard ;)
 479 #$x = $class->new(2); $x **= 6972593; $x--;
 480
 481 # 593573509*2^332162+1 has exactly 1,000,000 digits
 482 # takes about 24 mins on 300 Mhz, so cannot be done yet ;)
 483 #$x = $class->new(2); $x **= 332162; $x *= "593573509"; $x++;
 484 #ok ($x->length(),1_000_000);
 485
 486 ###############################################################################
 487 # inheritance and overriding of _swap
 488
 489 $x = Math::Foo->new(5);
 490 $x = $x - 8;            # 8 - 5 instead of 5-8
 491 ok ($x,3);
 492 ok (ref($x),'Math::Foo');
 493
 494 $x = Math::Foo->new(5);
 495 $x = 8 - $x;            # 5 - 8 instead of 8 - 5
 496 ok ($x,-3);
 497 ok (ref($x),'Math::Foo');
 498
 499 ###############################################################################
 500 # Test whether +inf eq inf
 501 # This tried to test whether BigInt inf equals Perl inf. Unfortunately, Perl
 502 # hasn't (before 5.7.3 at least) a consistent way to say inf, and some things
 503 # like 1e100000 crash on some platforms. So simple test for the string 'inf'
 504 $x = $class->new('+inf'); ok ($x,'inf');
 505
 506 ###############################################################################
 507 ###############################################################################
 508 # the followin tests only make sense with Math::BigInt::Calc or BareCalc or
 509 # FastCalc
 510
 511 exit if $CALC !~ /^Math::BigInt::(|Bare|Fast)Calc$/; # for Pari et al.
 512
 513 ###############################################################################
 514 # check proper length of internal arrays
 515
 516 my $bl = $CL->_base_len();
 517 my $BASE = '9' x $bl;
 518 my $MAX = $BASE;
 519 $BASE++;
 520
 521 $x = $class->new($MAX); is_valid($x);   # f.i. 9999
 522 $x += 1; ok ($x,$BASE); is_valid($x);   # 10000
 523 $x -= 1; ok ($x,$MAX); is_valid($x);    # 9999 again
 524
 525 ###############################################################################
 526 # check numify
 527
 528 $x = $class->new($BASE-1);     ok ($x->numify(),$BASE-1);
 529 $x = $class->new(-($BASE-1));  ok ($x->numify(),-($BASE-1));
 530
 531 # +0 is to protect from 1e15 vs 100000000 (stupid to_string aaaarglburblll...)
 532 $x = $class->new($BASE);       ok ($x->numify()+0,$BASE+0);
 533 $x = $class->new(-$BASE);      ok ($x->numify(),-$BASE);
 534 $x = $class->new( -($BASE*$BASE*1+$BASE*1+1) );
 535 ok($x->numify(),-($BASE*$BASE*1+$BASE*1+1));
 536
 537 ###############################################################################
 538 # test bug in _digits with length($c[-1]) where $c[-1] was "00001" instead of 1
 539
 540 $x = $class->new($BASE-2); $x++; $x++; $x++; $x++;
 541 if ($x > $BASE) { ok (1,1) } else { ok ("$x < $BASE","$x > $BASE"); }
 542
 543 $x = $class->new($BASE+3); $x++;
 544 if ($x > $BASE) { ok (1,1) } else { ok ("$x > $BASE","$x < $BASE"); }
 545
 546 # test for +0 instead of int():
 547 $x = $class->new($MAX); ok ($x->length(), length($MAX));
 548
 549 ###############################################################################
 550 # test bug that $class->digit($string) did not work
 551
 552 ok ($class->digit(123,2),1);
 553
 554 ###############################################################################
 555 # bug in sub where number with at least 6 trailing zeros after any op failed
 556
 557 $x = $class->new(123456); $z = $class->new(10000); $z *= 10; $x -= $z;
 558 ok ($z, 100000);
 559 ok ($x, 23456);
 560
 561 ###############################################################################
 562 # bug in shortcut in mul()
 563
 564 # construct a number with a zero-hole of BASE_LEN_SMALL
 565 {
 566  my @bl = $CL->_base_len(); my $bl = $bl[4];
 567
 568  $x = '1' x $bl . '0' x $bl . '1' x $bl . '0' x $bl;
 569  $y = '1' x (2*$bl);
 570  $x = $class->new($x)->bmul($y);
 571  # result is 123..$bl .  $bl x (3*bl-1) . $bl...321 . '0' x $bl
 572  $y = ''; my $d = '';
 573  for (my $i = 1; $i <= $bl; $i++)
 574    {
 575    $y .= $i; $d = $i.$d;
 576    }
 577  $y .= $bl x (3*$bl-1) . $d . '0' x $bl;
 578  ok ($x,$y);
 579
 580
 581   #############################################################################
 582   # see if mul shortcut for small numbers works
 583
 584   $x = '9' x $bl;
 585   $x = $class->new($x);
 586   # 999 * 999 => 998 . 001, 9999*9999 => 9998 . 0001
 587   ok ($x*$x, '9' x ($bl-1) . '8' . '0' x ($bl-1) . '1');
 588 }
 589
 590 ###############################################################################
 591 # bug with rest "-0" in div, causing further div()s to fail
 592
 593 $x = $class->new('-322056000'); ($x,$y) = $x->bdiv('-12882240');
 594
 595 ok ($y,'0'); is_valid($y);      # $y not '-0'
 596
 597 ###############################################################################
 598 # bug in $x->bmod($y)
 599
 600 # if $x < 0 and $y > 0
 601 $x = $class->new('-629'); ok ($x->bmod(5033),4404);
 602
 603 ###############################################################################
 604 # bone/binf etc as plain calls (Lite failed them)
 605
 606 ok ($class->bzero(),0);
 607 ok ($class->bone(),1);
 608 ok ($class->bone('+'),1);
 609 ok ($class->bone('-'),-1);
 610 ok ($class->bnan(),'NaN');
 611 ok ($class->binf(),'inf');
 612 ok ($class->binf('+'),'inf');
 613 ok ($class->binf('-'),'-inf');
 614 ok ($class->binf('-inf'),'-inf');
 615
 616 ###############################################################################
 617 # is_one('-')
 618
 619 ok ($class->new(1)->is_one('-'),0);
 620 ok ($class->new(-1)->is_one('-'),1);
 621 ok ($class->new(1)->is_one(),1);
 622 ok ($class->new(-1)->is_one(),0);
 623
 624 ###############################################################################
 625 # all tests done
 626
 627 1;
 628
 629 ###############################################################################
 630 ###############################################################################
 631 # Perl 5.005 does not like ok ($x,undef)
 632
 633 sub ok_undef
 634   {
 635   my $x = shift;
 636
 637   ok (1,1) and return if !defined $x;
 638   ok ($x,'undef');
 639   }
 640
 641 ###############################################################################
 642 # sub to check validity of a BigInt internally, to ensure that no op leaves a
 643 # number object in an invalid state (f.i. "-0")
 644
 645 sub is_valid
 646   {
 647   my ($x,$f) = @_;
 648
 649   my $e = 0;                    # error?
 650
 651   # allow the check to pass for all Lite, and all MBI and subclasses
 652   # ok as reference?
 653   $e = 'Not a reference to Math::BigInt' if ref($x) !~ /^Math::BigInt/;
 654
 655   if (ref($x) ne 'Math::BigInt::Lite')
 656     {
 657     # has ok sign?
 658     $e = "Illegal sign $x->{sign} (expected: '+', '-', '-inf', '+inf' or 'NaN'"
 659      if $e eq '0' && $x->{sign} !~ /^(\+|-|\+inf|-inf|NaN)$/;
 660
 661     $e = "-0 is invalid!" if $e ne '0' && $x->{sign} eq '-' && $x == 0;
 662     $e = $CALC->_check($x->{value}) if $e eq '0';
 663     }
 664
 665   # test done, see if error did crop up
 666   ok (1,1), return if ($e eq '0');
 667
 668   ok (1,$e." after op '$f'");
 669   }
 670
 671 __DATA__
 672 &.=
 673 1234:-345:1234-345
 674 &+=
 675 1:2:3
 676 -1:-2:-3
 677 &-=
 678 1:2:-1
 679 -1:-2:1
 680 &*=
 681 2:3:6
 682 -1:5:-5
 683 &%=
 684 100:3:1
 685 8:9:8
 686 -629:5033:4404
 687 &/=
 688 100:3:33
 689 -8:2:-4
 690 &|=
 691 2:1:3
 692 &&=
 693 5:7:5
 694 &^=
 695 5:7:2
 696 &is_negative
 697 0:0
 698 -1:1
 699 1:0
 700 +inf:0
 701 -inf:1
 702 NaNneg:0
 703 &is_positive
 704 0:1
 705 -1:0
 706 1:1
 707 +inf:1
 708 -inf:0
 709 NaNneg:0
 710 &is_int
 711 -inf:0
 712 +inf:0
 713 NaNis_int:0
 714 1:1
 715 0:1
 716 123e12:1
 717 &is_odd
 718 abc:0
 719 0:0
 720 1:1
 721 3:1
 722 -1:1
 723 -3:1
 724 10000001:1
 725 10000002:0
 726 2:0
 727 120:0
 728 121:1
 729 &is_even
 730 abc:0
 731 0:1
 732 1:0
 733 3:0
 734 -1:0
 735 -3:0
 736 10000001:0
 737 10000002:1
 738 2:1
 739 120:1
 740 121:0
 741 &bacmp
 742 +0:-0:0
 743 +0:+1:-1
 744 -1:+1:0
 745 +1:-1:0
 746 -1:+2:-1
 747 +2:-1:1
 748 -123456789:+987654321:-1
 749 +123456789:-987654321:-1
 750 +987654321:+123456789:1
 751 -987654321:+123456789:1
 752 -123:+4567889:-1
 753 # NaNs
 754 acmpNaN:123:
 755 123:acmpNaN:
 756 acmpNaN:acmpNaN:
 757 # infinity
 758 +inf:+inf:0
 759 -inf:-inf:0
 760 +inf:-inf:0
 761 -inf:+inf:0
 762 +inf:123:1
 763 -inf:123:1
 764 +inf:-123:1
 765 -inf:-123:1
 766 # return undef
 767 +inf:NaN:
 768 NaN:inf:
 769 -inf:NaN:
 770 NaN:-inf:
 771 &bnorm
 772 0e999:0
 773 0e-999:0
 774 -0e999:0
 775 -0e-999:0
 776 123:123
 777 # binary input
 778 0babc:NaN
 779 0b123:NaN
 780 0b0:0
 781 -0b0:0
 782 -0b1:-1
 783 0b0001:1
 784 0b001:1
 785 0b011:3
 786 0b101:5
 787 0b1001:9
 788 0b10001:17
 789 0b100001:33
 790 0b1000001:65
 791 0b10000001:129
 792 0b100000001:257
 793 0b1000000001:513
 794 0b10000000001:1025
 795 0b100000000001:2049
 796 0b1000000000001:4097
 797 0b10000000000001:8193
 798 0b100000000000001:16385
 799 0b1000000000000001:32769
 800 0b10000000000000001:65537
 801 0b100000000000000001:131073
 802 0b1000000000000000001:262145
 803 0b10000000000000000001:524289
 804 0b100000000000000000001:1048577
 805 0b1000000000000000000001:2097153
 806 0b10000000000000000000001:4194305
 807 0b100000000000000000000001:8388609
 808 0b1000000000000000000000001:16777217
 809 0b10000000000000000000000001:33554433
 810 0b100000000000000000000000001:67108865
 811 0b1000000000000000000000000001:134217729
 812 0b10000000000000000000000000001:268435457
 813 0b100000000000000000000000000001:536870913
 814 0b1000000000000000000000000000001:1073741825
 815 0b10000000000000000000000000000001:2147483649
 816 0b100000000000000000000000000000001:4294967297
 817 0b1000000000000000000000000000000001:8589934593
 818 0b10000000000000000000000000000000001:17179869185
 819 0b_101:NaN
 820 0b1_0_1:5
 821 0b0_0_0_1:1
 822 # hex input
 823 -0x0:0
 824 0xabcdefgh:NaN
 825 0x1234:4660
 826 0xabcdef:11259375
 827 -0xABCDEF:-11259375
 828 -0x1234:-4660
 829 0x12345678:305419896
 830 0x1_2_3_4_56_78:305419896
 831 0xa_b_c_d_e_f:11259375
 832 0x_123:NaN
 833 0x9:9
 834 0x11:17
 835 0x21:33
 836 0x41:65
 837 0x81:129
 838 0x101:257
 839 0x201:513
 840 0x401:1025
 841 0x801:2049
 842 0x1001:4097
 843 0x2001:8193
 844 0x4001:16385
 845 0x8001:32769
 846 0x10001:65537
 847 0x20001:131073
 848 0x40001:262145
 849 0x80001:524289
 850 0x100001:1048577
 851 0x200001:2097153
 852 0x400001:4194305
 853 0x800001:8388609
 854 0x1000001:16777217
 855 0x2000001:33554433
 856 0x4000001:67108865
 857 0x8000001:134217729
 858 0x10000001:268435457
 859 0x20000001:536870913
 860 0x40000001:1073741825
 861 0x80000001:2147483649
 862 0x100000001:4294967297
 863 0x200000001:8589934593
 864 0x400000001:17179869185
 865 0x800000001:34359738369
 866 # inf input
 867 inf:inf
 868 +inf:inf
 869 -inf:-inf
 870 0inf:NaN
 871 # abnormal input
 872 :NaN
 873 abc:NaN
 874    1 a:NaN
 875 1bcd2:NaN
 876 11111b:NaN
 877 +1z:NaN
 878 -1z:NaN
 879 # only one underscore between two digits
 880 _123:NaN
 881 _123_:NaN
 882 123_:NaN
 883 1__23:NaN
 884 1E1__2:NaN
 885 1_E12:NaN
 886 1E_12:NaN
 887 1_E_12:NaN
 888 +_1E12:NaN
 889 +0_1E2:100
 890 +0_0_1E2:100
 891 -0_0_1E2:-100
 892 -0_0_1E+0_0_2:-100
 893 E1:NaN
 894 E23:NaN
 895 1.23E1:NaN
 896 1.23E-1:NaN
 897 # bug with two E's in number beeing valid
 898 1e2e3:NaN
 899 1e2r:NaN
 900 1e2.0:NaN
 901 # bug with two '.' in number beeing valid
 902 1.2.2:NaN
 903 1.2.3e1:NaN
 904 -1.2.3:NaN
 905 -1.2.3e-4:NaN
 906 1.2e3.4:NaN
 907 1.2e-3.4:NaN
 908 1.2.3.4:NaN
 909 1.2.t:NaN
 910 1..2:NaN
 911 1..2e1:NaN
 912 1..2e1..1:NaN
 913 12e1..1:NaN
 914 ..2:NaN
 915 .-2:NaN
 916 # leading zeros
 917 012:12
 918 0123:123
 919 01234:1234
 920 012345:12345
 921 0123456:123456
 922 01234567:1234567
 923 012345678:12345678
 924 0123456789:123456789
 925 01234567891:1234567891
 926 012345678912:12345678912
 927 0123456789123:123456789123
 928 01234567891234:1234567891234
 929 # normal input
 930 0:0
 931 +0:0
 932 +00:0
 933 +000:0
 934 000000000000000000:0
 935 -0:0
 936 -0000:0
 937 +1:1
 938 +01:1
 939 +001:1
 940 +00000100000:100000
 941 123456789:123456789
 942 -1:-1
 943 -01:-1
 944 -001:-1
 945 -123456789:-123456789
 946 -00000100000:-100000
 947 1_2_3:123
 948 10000000000E-1_0:1
 949 1E2:100
 950 1E1:10
 951 1E0:1
 952 1.23E2:123
 953 100E-1:10
 954 # floating point input
 955 # .2e2:20
 956 1.E3:1000
 957 1.01E2:101
 958 1010E-1:101
 959 -1010E0:-1010
 960 -1010E1:-10100
 961 1234.00:1234
 962 # non-integer numbers
 963 -1010E-2:NaN
 964 -1.01E+1:NaN
 965 -1.01E-1:NaN
 966 &bnan
 967 1:NaN
 968 2:NaN
 969 abc:NaN
 970 &bone
 971 2:+:1
 972 2:-:-1
 973 boneNaN:-:-1
 974 boneNaN:+:1
 975 2:abc:1
 976 3::1
 977 &binf
 978 1:+:inf
 979 2:-:-inf
 980 3:abc:inf
 981 &is_nan
 982 123:0
 983 abc:1
 984 NaN:1
 985 -123:0
 986 &is_inf
 987 +inf::1
 988 -inf::1
 989 abc::0
 990 1::0
 991 NaN::0
 992 -1::0
 993 +inf:-:0
 994 +inf:+:1
 995 -inf:-:1
 996 -inf:+:0
 997 -inf:-inf:1
 998 -inf:+inf:0
 999 +inf:-inf:0
1000 +inf:+inf:1
1001 # it must be exactly /^[+-]inf$/
1002 +infinity::0
1003 -infinity::0
1004 &blsft
1005 abc:abc:NaN
1006 +2:+2:8
1007 +1:+32:4294967296
1008 +1:+48:281474976710656
1009 +8:-2:NaN
1010 # excercise base 10
1011 +12345:4:10:123450000
1012 -1234:0:10:-1234
1013 +1234:0:10:1234
1014 +2:2:10:200
1015 +12:2:10:1200
1016 +1234:-3:10:NaN
1017 1234567890123:12:10:1234567890123000000000000
1018 -3:1:2:-6
1019 -5:1:2:-10
1020 -2:1:2:-4
1021 -102533203:1:2:-205066406
1022 &brsft
1023 abc:abc:NaN
1024 +8:+2:2
1025 +4294967296:+32:1
1026 +281474976710656:+48:1
1027 +2:-2:NaN
1028 # excercise base 10
1029 -1234:0:10:-1234
1030 +1234:0:10:1234
1031 +200:2:10:2
1032 +1234:3:10:1
1033 +1234:2:10:12
1034 +1234:-3:10:NaN
1035 310000:4:10:31
1036 12300000:5:10:123
1037 1230000000000:10:10:123
1038 09876123456789067890:12:10:9876123
1039 1234561234567890123:13:10:123456
1040 820265627:1:2:410132813
1041 # test shifting negative numbers in base 2
1042 -15:1:2:-8
1043 -14:1:2:-7
1044 -13:1:2:-7
1045 -12:1:2:-6
1046 -11:1:2:-6
1047 -10:1:2:-5
1048 -9:1:2:-5
1049 -8:1:2:-4
1050 -7:1:2:-4
1051 -6:1:2:-3
1052 -5:1:2:-3
1053 -4:1:2:-2
1054 -3:1:2:-2
1055 -2:1:2:-1
1056 -1:1:2:-1
1057 -1640531254:2:2:-410132814
1058 -1640531254:1:2:-820265627
1059 -820265627:1:2:-410132814
1060 -205066405:1:2:-102533203
1061 &bsstr
1062 +inf:inf
1063 -inf:-inf
1064 1e+34:1e+34
1065 123.456E3:123456e+0
1066 100:1e+2
1067 bsstrabc:NaN
1068 -5:-5e+0
1069 -100:-1e+2
1070 &numify
1071 numifyabc:NaN
1072 +inf:inf
1073 -inf:-inf
1074 5:5
1075 -5:-5
1076 100:100
1077 -100:-100
1078 &bneg
1079 bnegNaN:NaN
1080 +inf:-inf
1081 -inf:inf
1082 abd:NaN
1083 0:0
1084 1:-1
1085 -1:1
1086 +123456789:-123456789
1087 -123456789:123456789
1088 &babs
1089 babsNaN:NaN
1090 +inf:inf
1091 -inf:inf
1092 0:0
1093 1:1
1094 -1:1
1095 +123456789:123456789
1096 -123456789:123456789
1097 &bcmp
1098 bcmpNaN:bcmpNaN:
1099 bcmpNaN:0:
1100 0:bcmpNaN:
1101 0:0:0
1102 -1:0:-1
1103 0:-1:1
1104 1:0:1
1105 0:1:-1
1106 -1:1:-1
1107 1:-1:1
1108 -1:-1:0
1109 1:1:0
1110 123:123:0
1111 123:12:1
1112 12:123:-1
1113 -123:-123:0
1114 -123:-12:-1
1115 -12:-123:1
1116 123:124:-1
1117 124:123:1
1118 -123:-124:1
1119 -124:-123:-1
1120 100:5:1
1121 -123456789:987654321:-1
1122 +123456789:-987654321:1
1123 -987654321:123456789:-1
1124 -inf:5432112345:-1
1125 +inf:5432112345:1
1126 -inf:-5432112345:-1
1127 +inf:-5432112345:1
1128 +inf:+inf:0
1129 -inf:-inf:0
1130 +inf:-inf:1
1131 -inf:+inf:-1
1132 5:inf:-1
1133 5:inf:-1
1134 -5:-inf:1
1135 -5:-inf:1
1136 # return undef
1137 +inf:NaN:
1138 NaN:inf:
1139 -inf:NaN:
1140 NaN:-inf:
1141 &binc
1142 abc:NaN
1143 +inf:inf
1144 -inf:-inf
1145 +0:1
1146 +1:2
1147 -1:0
1148 &bdec
1149 abc:NaN
1150 +inf:inf
1151 -inf:-inf
1152 +0:-1
1153 +1:0
1154 -1:-2
1155 &badd
1156 abc:abc:NaN
1157 abc:0:NaN
1158 +0:abc:NaN
1159 +inf:-inf:NaN
1160 -inf:+inf:NaN
1161 +inf:+inf:inf
1162 -inf:-inf:-inf
1163 baddNaN:+inf:NaN
1164 baddNaN:+inf:NaN
1165 +inf:baddNaN:NaN
1166 -inf:baddNaN:NaN
1167 0:0:0
1168 1:0:1
1169 0:1:1
1170 1:1:2
1171 -1:0:-1
1172 0:-1:-1
1173 -1:-1:-2
1174 -1:+1:0
1175 +1:-1:0
1176 +9:+1:10
1177 +99:+1:100
1178 +999:+1:1000
1179 +9999:+1:10000
1180 +99999:+1:100000
1181 +999999:+1:1000000
1182 +9999999:+1:10000000
1183 +99999999:+1:100000000
1184 +999999999:+1:1000000000
1185 +9999999999:+1:10000000000
1186 +99999999999:+1:100000000000
1187 +10:-1:9
1188 +100:-1:99
1189 +1000:-1:999
1190 +10000:-1:9999
1191 +100000:-1:99999
1192 +1000000:-1:999999
1193 +10000000:-1:9999999
1194 +100000000:-1:99999999
1195 +1000000000:-1:999999999
1196 +10000000000:-1:9999999999
1197 +123456789:987654321:1111111110
1198 -123456789:987654321:864197532
1199 -123456789:-987654321:-1111111110
1200 +123456789:-987654321:-864197532
1201 -1:10001:10000
1202 -1:100001:100000
1203 -1:1000001:1000000
1204 -1:10000001:10000000
1205 -1:100000001:100000000
1206 -1:1000000001:1000000000
1207 -1:10000000001:10000000000
1208 -1:100000000001:100000000000
1209 -1:1000000000001:1000000000000
1210 -1:10000000000001:10000000000000
1211 -1:-10001:-10002
1212 -1:-100001:-100002
1213 -1:-1000001:-1000002
1214 -1:-10000001:-10000002
1215 -1:-100000001:-100000002
1216 -1:-1000000001:-1000000002
1217 -1:-10000000001:-10000000002
1218 -1:-100000000001:-100000000002
1219 -1:-1000000000001:-1000000000002
1220 -1:-10000000000001:-10000000000002
1221 &bsub
1222 abc:abc:NaN
1223 abc:+0:NaN
1224 +0:abc:NaN
1225 +inf:-inf:inf
1226 -inf:+inf:-inf
1227 +inf:+inf:NaN
1228 -inf:-inf:NaN
1229 +0:+0:0
1230 +1:+0:1
1231 +0:+1:-1
1232 +1:+1:0
1233 -1:+0:-1
1234 +0:-1:1
1235 -1:-1:0
1236 -1:+1:-2
1237 +1:-1:2
1238 +9:+1:8
1239 +99:+1:98
1240 +999:+1:998
1241 +9999:+1:9998
1242 +99999:+1:99998
1243 +999999:+1:999998
1244 +9999999:+1:9999998
1245 +99999999:+1:99999998
1246 +999999999:+1:999999998
1247 +9999999999:+1:9999999998
1248 +99999999999:+1:99999999998
1249 +10:-1:11
1250 +100:-1:101
1251 +1000:-1:1001
1252 +10000:-1:10001
1253 +100000:-1:100001
1254 +1000000:-1:1000001
1255 +10000000:-1:10000001
1256 +100000000:-1:100000001
1257 +1000000000:-1:1000000001
1258 +10000000000:-1:10000000001
1259 +123456789:+987654321:-864197532
1260 -123456789:+987654321:-1111111110
1261 -123456789:-987654321:864197532
1262 +123456789:-987654321:1111111110
1263 10001:1:10000
1264 100001:1:100000
1265 1000001:1:1000000
1266 10000001:1:10000000
1267 100000001:1:100000000
1268 1000000001:1:1000000000
1269 10000000001:1:10000000000
1270 100000000001:1:100000000000
1271 1000000000001:1:1000000000000
1272 10000000000001:1:10000000000000
1273 10001:-1:10002
1274 100001:-1:100002
1275 1000001:-1:1000002
1276 10000001:-1:10000002
1277 100000001:-1:100000002
1278 1000000001:-1:1000000002
1279 10000000001:-1:10000000002
1280 100000000001:-1:100000000002
1281 1000000000001:-1:1000000000002
1282 10000000000001:-1:10000000000002
1283 &bmul
1284 abc:abc:NaN
1285 abc:+0:NaN
1286 +0:abc:NaN
1287 NaNmul:+inf:NaN
1288 NaNmul:-inf:NaN
1289 -inf:NaNmul:NaN
1290 +inf:NaNmul:NaN
1291 +inf:+inf:inf
1292 +inf:-inf:-inf
1293 -inf:+inf:-inf
1294 -inf:-inf:inf
1295 +0:+0:0
1296 +0:+1:0
1297 +1:+0:0
1298 +0:-1:0
1299 -1:+0:0
1300 123456789123456789:0:0
1301 0:123456789123456789:0
1302 -1:-1:1
1303 -1:+1:-1
1304 +1:-1:-1
1305 +1:+1:1
1306 +2:+3:6
1307 -2:+3:-6
1308 +2:-3:-6
1309 -2:-3:6
1310 111:111:12321
1311 10101:10101:102030201
1312 1001001:1001001:1002003002001
1313 100010001:100010001:10002000300020001
1314 10000100001:10000100001:100002000030000200001
1315 11111111111:9:99999999999
1316 22222222222:9:199999999998
1317 33333333333:9:299999999997
1318 44444444444:9:399999999996
1319 55555555555:9:499999999995
1320 66666666666:9:599999999994
1321 77777777777:9:699999999993
1322 88888888888:9:799999999992
1323 99999999999:9:899999999991
1324 +25:+25:625
1325 +12345:+12345:152399025
1326 +99999:+11111:1111088889
1327 9999:10000:99990000
1328 99999:100000:9999900000
1329 999999:1000000:999999000000
1330 9999999:10000000:99999990000000
1331 99999999:100000000:9999999900000000
1332 999999999:1000000000:999999999000000000
1333 9999999999:10000000000:99999999990000000000
1334 99999999999:100000000000:9999999999900000000000
1335 999999999999:1000000000000:999999999999000000000000
1336 9999999999999:10000000000000:99999999999990000000000000
1337 99999999999999:100000000000000:9999999999999900000000000000
1338 999999999999999:1000000000000000:999999999999999000000000000000
1339 9999999999999999:10000000000000000:99999999999999990000000000000000
1340 99999999999999999:100000000000000000:9999999999999999900000000000000000
1341 999999999999999999:1000000000000000000:999999999999999999000000000000000000
1342 9999999999999999999:10000000000000000000:99999999999999999990000000000000000000
1343 &bdiv-list
1344 100:20:5,0
1345 4095:4095:1,0
1346 -4095:-4095:1,0
1347 4095:-4095:-1,0
1348 -4095:4095:-1,0
1349 123:2:61,1
1350 9:5:1,4
1351 9:4:2,1
1352 # inf handling and general remainder
1353 5:8:0,5
1354 0:8:0,0
1355 11:2:5,1
1356 11:-2:-5,-1
1357 -11:2:-5,1
1358 # see table in documentation in MBI
1359 0:inf:0,0
1360 0:-inf:0,0
1361 5:inf:0,5
1362 5:-inf:0,5
1363 -5:inf:0,-5
1364 -5:-inf:0,-5
1365 inf:5:inf,0
1366 -inf:5:-inf,0
1367 inf:-5:-inf,0
1368 -inf:-5:inf,0
1369 5:5:1,0
1370 -5:-5:1,0
1371 inf:inf:NaN,NaN
1372 -inf:-inf:NaN,NaN
1373 -inf:inf:NaN,NaN
1374 inf:-inf:NaN,NaN
1375 8:0:inf,8
1376 inf:0:inf,inf
1377 # exceptions to reminder rule
1378 -8:0:-inf,-8
1379 -inf:0:-inf,-inf
1380 0:0:NaN,NaN
1381 # test the shortcut in Calc if @$x == @$yorg
1382 1234567812345678:123456712345678:10,688888898
1383 12345671234567:1234561234567:10,58888897
1384 123456123456:12345123456:10,4888896
1385 1234512345:123412345:10,388895
1386 1234567890999999999:1234567890:1000000000,999999999
1387 1234567890000000000:1234567890:1000000000,0
1388 1234567890999999999:9876543210:124999998,9503086419
1389 1234567890000000000:9876543210:124999998,8503086420
1390 96969696969696969696969696969678787878626262626262626262626262:484848484848484848484848486666666666666689898989898989898989:199,484848484848484848484848123012121211954972727272727272727451
1391 &bdiv
1392 abc:abc:NaN
1393 abc:1:NaN
1394 1:abc:NaN
1395 0:0:NaN
1396 # inf handling (see table in doc)
1397 0:inf:0
1398 0:-inf:0
1399 5:inf:0
1400 5:-inf:0
1401 -5:inf:0
1402 -5:-inf:0
1403 inf:5:inf
1404 -inf:5:-inf
1405 inf:-5:-inf
1406 -inf:-5:inf
1407 5:5:1
1408 -5:-5:1
1409 inf:inf:NaN
1410 -inf:-inf:NaN
1411 -inf:inf:NaN
1412 inf:-inf:NaN
1413 8:0:inf
1414 inf:0:inf
1415 -8:0:-inf
1416 -inf:0:-inf
1417 0:0:NaN
1418 11:2:5
1419 -11:-2:5
1420 -11:2:-5
1421 11:-2:-5
1422 0:1:0
1423 0:-1:0
1424 1:1:1
1425 -1:-1:1
1426 1:-1:-1
1427 -1:1:-1
1428 1:2:0
1429 2:1:2
1430 1:26:0
1431 1000000000:9:111111111
1432 2000000000:9:222222222
1433 3000000000:9:333333333
1434 4000000000:9:444444444
1435 5000000000:9:555555555
1436 6000000000:9:666666666
1437 7000000000:9:777777777
1438 8000000000:9:888888888
1439 9000000000:9:1000000000
1440 35500000:113:314159
1441 71000000:226:314159
1442 106500000:339:314159
1443 1000000000:3:333333333
1444 +10:+5:2
1445 +100:+4:25
1446 +1000:+8:125
1447 +10000:+16:625
1448 999999999999:9:111111111111
1449 999999999999:99:10101010101
1450 999999999999:999:1001001001
1451 999999999999:9999:100010001
1452 999999999999999:99999:10000100001
1453 +1111088889:99999:11111
1454 -5:-3:1
1455 -5:3:-1
1456 4:3:1
1457 4:-3:-1
1458 1:3:0
1459 1:-3:0
1460 -2:-3:0
1461 -2:3:0
1462 8:3:2
1463 -8:3:-2
1464 14:-3:-4
1465 -14:3:-4
1466 -14:-3:4
1467 14:3:4
1468 # bug in Calc with '99999' vs $BASE-1
1469 10000000000000000000000000000000000000000000000000000000000000000000000000000000000:10000000375084540248994272022843165711074:999999962491547381984643365663244474111576
1470 # test the shortcut in Calc if @$x == @$yorg
1471 1234567812345678:123456712345678:10
1472 12345671234567:1234561234567:10
1473 123456123456:12345123456:10
1474 1234512345:123412345:10
1475 1234567890999999999:1234567890:1000000000
1476 1234567890000000000:1234567890:1000000000
1477 1234567890999999999:9876543210:124999998
1478 1234567890000000000:9876543210:124999998
1479 96969696969696969696969696969678787878626262626262626262626262:484848484848484848484848486666666666666689898989898989898989:199
1480 # bug up to v0.35 in Calc (--$q one too many)
1481 84696969696969696956565656566184292929292929292847474747436308080808080808086765396464646464646465:13131313131313131313131313131394949494949494949494949494943535353535353535353535:6449999999999999999
1482 84696969696969696943434343434871161616161616161452525252486813131313131313143230042929292929292930:13131313131313131313131313131394949494949494949494949494943535353535353535353535:6449999999999999998
1483 84696969696969696969696969697497424242424242424242424242385803030303030303030300750000000000000000:13131313131313131313131313131394949494949494949494949494943535353535353535353535:6450000000000000000
1484 84696969696969696930303030303558030303030303030057575757537318181818181818199694689393939393939395:13131313131313131313131313131394949494949494949494949494943535353535353535353535:6449999999999999997
1485 &bmodinv
1486 # format: number:modulus:result
1487 # bmodinv Data errors
1488 abc:abc:NaN
1489 abc:5:NaN
1490 5:abc:NaN
1491 # bmodinv Expected Results from normal use
1492 1:5:1
1493 3:5:2
1494 -2:5:2
1495 8:5033:4404
1496 1234567891:13:6
1497 -1234567891:13:7
1498 324958749843759385732954874325984357439658735983745:2348249874968739:1741662881064902
1499 ## bmodinv Error cases / useless use of function
1500 3:-5:NaN
1501 inf:5:NaN
1502 5:inf:NaN
1503 -inf:5:NaN
1504 5:-inf:NaN
1505 &bmodpow
1506 # format: number:exponent:modulus:result
1507 # bmodpow Data errors
1508 abc:abc:abc:NaN
1509 5:abc:abc:NaN
1510 abc:5:abc:NaN
1511 abc:abc:5:NaN
1512 5:5:abc:NaN
1513 5:abc:5:NaN
1514 abc:5:5:NaN
1515 # bmodpow Expected results
1516 0:0:2:1
1517 1:0:2:1
1518 0:0:1:0
1519 8:7:5032:3840
1520 8:-1:5033:4404
1521 98436739867439843769485798542749827593285729587325:43698764986460981048259837659386739857456983759328457:6943857329857295827698367:3104744730915914415259518
1522 # bmodpow Error cases
1523 8:8:-5:NaN
1524 8:-1:16:NaN
1525 inf:5:13:NaN
1526 5:inf:13:NaN
1527 &bmod
1528 # inf handling, see table in doc
1529 0:inf:0
1530 0:-inf:0
1531 5:inf:5
1532 5:-inf:5
1533 -5:inf:-5
1534 -5:-inf:-5
1535 inf:5:0
1536 -inf:5:0
1537 inf:-5:0
1538 -inf:-5:0
1539 5:5:0
1540 -5:-5:0
1541 inf:inf:NaN
1542 -inf:-inf:NaN
1543 -inf:inf:NaN
1544 inf:-inf:NaN
1545 8:0:8
1546 inf:0:inf
1547 # exceptions to reminder rule
1548 -inf:0:-inf
1549 -8:0:-8
1550 0:0:NaN
1551 abc:abc:NaN
1552 abc:1:abc:NaN
1553 1:abc:NaN
1554 0:0:NaN
1555 0:1:0
1556 1:0:1
1557 0:-1:0
1558 -1:0:-1
1559 1:1:0
1560 -1:-1:0
1561 1:-1:0
1562 -1:1:0
1563 1:2:1
1564 2:1:0
1565 1000000000:9:1
1566 2000000000:9:2
1567 3000000000:9:3
1568 4000000000:9:4
1569 5000000000:9:5
1570 6000000000:9:6
1571 7000000000:9:7
1572 8000000000:9:8
1573 9000000000:9:0
1574 35500000:113:33
1575 71000000:226:66
1576 106500000:339:99
1577 1000000000:3:1
1578 10:5:0
1579 100:4:0
1580 1000:8:0
1581 10000:16:0
1582 999999999999:9:0
1583 999999999999:99:0
1584 999999999999:999:0
1585 999999999999:9999:0
1586 999999999999999:99999:0
1587 -9:+5:1
1588 +9:-5:-1
1589 -9:-5:-4
1590 -5:3:1
1591 -2:3:1
1592 4:3:1
1593 1:3:1
1594 -5:-3:-2
1595 -2:-3:-2
1596 4:-3:-2
1597 1:-3:-2
1598 4095:4095:0
1599 100041000510123:3:0
1600 152403346:12345:4321
1601 9:5:4
1602 # test shortcuts in Calc
1603 # 1ex % 9 is always == 1, 1ex % 113 is != 1 for x = (4..9), 1ex % 10 = 0
1604 1234:9:1
1605 123456:9:3
1606 12345678:9:0
1607 1234567891:9:1
1608 123456789123:9:6
1609 12345678912345:9:6
1610 1234567891234567:9:1
1611 123456789123456789:9:0
1612 1234:10:4
1613 123456:10:6
1614 12345678:10:8
1615 1234567891:10:1
1616 123456789123:10:3
1617 12345678912345:10:5
1618 1234567891234567:10:7
1619 123456789123456789:10:9
1620 1234:113:104
1621 123456:113:60
1622 12345678:113:89
1623 1234567891:113:64
1624 123456789123:113:95
1625 12345678912345:113:53
1626 1234567891234567:113:56
1627 123456789123456789:113:39
1628 # bug in bmod() not modifying the variable in place
1629 -629:5033:4404
1630 # bug in bmod() in Calc in the _div_use_div() shortcut code path,
1631 # when X == X and X was big
1632 111111111111111111111111111111:111111111111111111111111111111:0
1633 12345678901234567890:12345678901234567890:0
1634 &bgcd
1635 abc:abc:NaN
1636 abc:+0:NaN
1637 +0:abc:NaN
1638 +0:+0:0
1639 +0:+1:1
1640 +1:+0:1
1641 +1:+1:1
1642 +2:+3:1
1643 +3:+2:1
1644 -3:+2:1
1645 100:625:25
1646 4096:81:1
1647 1034:804:2
1648 27:90:56:1
1649 27:90:54:9
1650 &blcm
1651 abc:abc:NaN
1652 abc:+0:NaN
1653 +0:abc:NaN
1654 +0:+0:NaN
1655 +1:+0:0
1656 +0:+1:0
1657 +27:+90:270
1658 +1034:+804:415668
1659 &band
1660 abc:abc:NaN
1661 abc:0:NaN
1662 0:abc:NaN
1663 1:2:0
1664 3:2:2
1665 +8:+2:0
1666 +281474976710656:0:0
1667 +281474976710656:1:0
1668 +281474976710656:+281474976710656:281474976710656
1669 -2:-3:-4
1670 -1:-1:-1
1671 -6:-6:-6
1672 -7:-4:-8
1673 -7:4:0
1674 -4:7:4
1675 # equal arguments are treated special, so also do some test with unequal ones
1676 0xFFFF:0xFFFF:0x0xFFFF
1677 0xFFFFFF:0xFFFFFF:0x0xFFFFFF
1678 0xFFFFFFFF:0xFFFFFFFF:0x0xFFFFFFFF
1679 0xFFFFFFFFFF:0xFFFFFFFFFF:0x0xFFFFFFFFFF
1680 0xFFFFFFFFFFFF:0xFFFFFFFFFFFF:0x0xFFFFFFFFFFFF
1681 0xF0F0:0xF0F0:0x0xF0F0
1682 0x0F0F:0x0F0F:0x0x0F0F
1683 0xF0F0F0:0xF0F0F0:0x0xF0F0F0
1684 0x0F0F0F:0x0F0F0F:0x0x0F0F0F
1685 0xF0F0F0F0:0xF0F0F0F0:0x0xF0F0F0F0
1686 0x0F0F0F0F:0x0F0F0F0F:0x0x0F0F0F0F
1687 0xF0F0F0F0F0:0xF0F0F0F0F0:0x0xF0F0F0F0F0
1688 0x0F0F0F0F0F:0x0F0F0F0F0F:0x0x0F0F0F0F0F
1689 0xF0F0F0F0F0F0:0xF0F0F0F0F0F0:0x0xF0F0F0F0F0F0
1690 0x0F0F0F0F0F0F:0x0F0F0F0F0F0F:0x0x0F0F0F0F0F0F
1691 0x1F0F0F0F0F0F:0x3F0F0F0F0F0F:0x0x1F0F0F0F0F0F
1692 &bior
1693 abc:abc:NaN
1694 abc:0:NaN
1695 0:abc:NaN
1696 1:2:3
1697 +8:+2:10
1698 +281474976710656:0:281474976710656
1699 +281474976710656:1:281474976710657
1700 +281474976710656:281474976710656:281474976710656
1701 -2:-3:-1
1702 -1:-1:-1
1703 -6:-6:-6
1704 -7:4:-3
1705 -4:7:-1
1706 # equal arguments are treated special, so also do some test with unequal ones
1707 0xFFFF:0xFFFF:0x0xFFFF
1708 0xFFFFFF:0xFFFFFF:0x0xFFFFFF
1709 0xFFFFFFFF:0xFFFFFFFF:0x0xFFFFFFFF
1710 0xFFFFFFFFFF:0xFFFFFFFFFF:0x0xFFFFFFFFFF
1711 0xFFFFFFFFFFFF:0xFFFFFFFFFFFF:0x0xFFFFFFFFFFFF
1712 0:0xFFFF:0x0xFFFF
1713 0:0xFFFFFF:0x0xFFFFFF
1714 0:0xFFFFFFFF:0x0xFFFFFFFF
1715 0:0xFFFFFFFFFF:0x0xFFFFFFFFFF
1716 0:0xFFFFFFFFFFFF:0x0xFFFFFFFFFFFF
1717 0xFFFF:0:0x0xFFFF
1718 0xFFFFFF:0:0x0xFFFFFF
1719 0xFFFFFFFF:0:0x0xFFFFFFFF
1720 0xFFFFFFFFFF:0:0x0xFFFFFFFFFF
1721 0xFFFFFFFFFFFF:0:0x0xFFFFFFFFFFFF
1722 0xF0F0:0xF0F0:0x0xF0F0
1723 0x0F0F:0x0F0F:0x0x0F0F
1724 0xF0F0:0x0F0F:0x0xFFFF
1725 0xF0F0F0:0xF0F0F0:0x0xF0F0F0
1726 0x0F0F0F:0x0F0F0F:0x0x0F0F0F
1727 0x0F0F0F:0xF0F0F0:0x0xFFFFFF
1728 0xF0F0F0F0:0xF0F0F0F0:0x0xF0F0F0F0
1729 0x0F0F0F0F:0x0F0F0F0F:0x0x0F0F0F0F
1730 0x0F0F0F0F:0xF0F0F0F0:0x0xFFFFFFFF
1731 0xF0F0F0F0F0:0xF0F0F0F0F0:0x0xF0F0F0F0F0
1732 0x0F0F0F0F0F:0x0F0F0F0F0F:0x0x0F0F0F0F0F
1733 0x0F0F0F0F0F:0xF0F0F0F0F0:0x0xFFFFFFFFFF
1734 0xF0F0F0F0F0F0:0xF0F0F0F0F0F0:0x0xF0F0F0F0F0F0
1735 0x0F0F0F0F0F0F:0x0F0F0F0F0F0F:0x0x0F0F0F0F0F0F
1736 0x0F0F0F0F0F0F:0xF0F0F0F0F0F0:0x0xFFFFFFFFFFFF
1737 0x1F0F0F0F0F0F:0xF0F0F0F0F0F0:0x0xFFFFFFFFFFFF
1738 &bxor
1739 abc:abc:NaN
1740 abc:0:NaN
1741 0:abc:NaN
1742 1:2:3
1743 +8:+2:10
1744 +281474976710656:0:281474976710656
1745 +281474976710656:1:281474976710657
1746 +281474976710656:281474976710656:0
1747 -2:-3:3
1748 -1:-1:0
1749 -6:-6:0
1750 -7:4:-3
1751 -4:7:-5
1752 4:-7:-3
1753 -4:-7:5
1754 # equal arguments are treated special, so also do some test with unequal ones
1755 0xFFFF:0xFFFF:0
1756 0xFFFFFF:0xFFFFFF:0
1757 0xFFFFFFFF:0xFFFFFFFF:0
1758 0xFFFFFFFFFF:0xFFFFFFFFFF:0
1759 0xFFFFFFFFFFFF:0xFFFFFFFFFFFF:0
1760 0:0xFFFF:0x0xFFFF
1761 0:0xFFFFFF:0x0xFFFFFF
1762 0:0xFFFFFFFF:0x0xFFFFFFFF
1763 0:0xFFFFFFFFFF:0x0xFFFFFFFFFF
1764 0:0xFFFFFFFFFFFF:0x0xFFFFFFFFFFFF
1765 0xFFFF:0:0x0xFFFF
1766 0xFFFFFF:0:0x0xFFFFFF
1767 0xFFFFFFFF:0:0x0xFFFFFFFF
1768 0xFFFFFFFFFF:0:0x0xFFFFFFFFFF
1769 0xFFFFFFFFFFFF:0:0x0xFFFFFFFFFFFF
1770 0xF0F0:0xF0F0:0
1771 0x0F0F:0x0F0F:0
1772 0xF0F0:0x0F0F:0x0xFFFF
1773 0xF0F0F0:0xF0F0F0:0
1774 0x0F0F0F:0x0F0F0F:0
1775 0x0F0F0F:0xF0F0F0:0x0xFFFFFF
1776 0xF0F0F0F0:0xF0F0F0F0:0
1777 0x0F0F0F0F:0x0F0F0F0F:0
1778 0x0F0F0F0F:0xF0F0F0F0:0x0xFFFFFFFF
1779 0xF0F0F0F0F0:0xF0F0F0F0F0:0
1780 0x0F0F0F0F0F:0x0F0F0F0F0F:0
1781 0x0F0F0F0F0F:0xF0F0F0F0F0:0x0xFFFFFFFFFF
1782 0xF0F0F0F0F0F0:0xF0F0F0F0F0F0:0
1783 0x0F0F0F0F0F0F:0x0F0F0F0F0F0F:0
1784 0x0F0F0F0F0F0F:0xF0F0F0F0F0F0:0x0xFFFFFFFFFFFF
1785 &bnot
1786 abc:NaN
1787 +0:-1
1788 +8:-9
1789 +281474976710656:-281474976710657
1790 -1:0
1791 -2:1
1792 -12:11
1793 &digit
1794 0:0:0
1795 12:0:2
1796 12:1:1
1797 123:0:3
1798 123:1:2
1799 123:2:1
1800 123:-1:1
1801 123:-2:2
1802 123:-3:3
1803 123456:0:6
1804 123456:1:5
1805 123456:2:4
1806 123456:3:3
1807 123456:4:2
1808 123456:5:1
1809 123456:-1:1
1810 123456:-2:2
1811 123456:-3:3
1812 100000:-3:0
1813 100000:0:0
1814 100000:1:0
1815 &mantissa
1816 abc:NaN
1817 1e4:1
1818 2e0:2
1819 123:123
1820 -1:-1
1821 -2:-2
1822 +inf:inf
1823 -inf:-inf
1824 &exponent
1825 abc:NaN
1826 1e4:4
1827 2e0:0
1828 123:0
1829 -1:0
1830 -2:0
1831 0:1
1832 +inf:inf
1833 -inf:inf
1834 &parts
1835 abc:NaN,NaN
1836 1e4:1,4
1837 2e0:2,0
1838 123:123,0
1839 -1:-1,0
1840 -2:-2,0
1841 0:0,1
1842 +inf:inf,inf
1843 -inf:-inf,inf
1844 &bfac
1845 -1:NaN
1846 NaNfac:NaN
1847 +inf:NaN
1848 -inf:NaN
1849 0:1
1850 1:1
1851 2:2
1852 3:6
1853 4:24
1854 5:120
1855 6:720
1856 7:5040
1857 8:40320
1858 9:362880
1859 10:3628800
1860 11:39916800
1861 12:479001600
1862 &bpow
1863 abc:12:NaN
1864 12:abc:NaN
1865 0:0:1
1866 0:1:0
1867 0:2:0
1868 0:-1:NaN
1869 0:-2:NaN
1870 1:0:1
1871 1:1:1
1872 1:2:1
1873 1:3:1
1874 1:-1:1
1875 1:-2:1
1876 1:-3:1
1877 2:0:1
1878 2:1:2
1879 2:2:4
1880 2:3:8
1881 3:3:27
1882 2:-1:NaN
1883 -2:-1:NaN
1884 2:-2:NaN
1885 -2:-2:NaN
1886 +inf:1234500012:inf
1887 -inf:1234500012:-inf
1888 +inf:-12345000123:inf
1889 -inf:-12345000123:-inf
1890 # 1 ** -x => 1 / (1 ** x)
1891 -1:0:1
1892 -2:0:1
1893 -1:1:-1
1894 -1:2:1
1895 -1:3:-1
1896 -1:4:1
1897 -1:5:-1
1898 -1:-1:-1
1899 -1:-2:1
1900 -1:-3:-1
1901 -1:-4:1
1902 10:2:100
1903 10:3:1000
1904 10:4:10000
1905 10:5:100000
1906 10:6:1000000
1907 10:7:10000000
1908 10:8:100000000
1909 10:9:1000000000
1910 10:20:100000000000000000000
1911 123456:2:15241383936
1912 &length
1913 100:3
1914 10:2
1915 1:1
1916 0:1
1917 12345:5
1918 10000000000000000:17
1919 -123:3
1920 215960156869840440586892398248:30
1921 &broot
1922 # sqrt()
1923 +0:2:0
1924 +1:2:1
1925 -1:2:NaN
1926 # -$x ** (1/2) => -$y, but not in froot()
1927 -123:2:NaN
1928 +inf:2:inf
1929 -inf:2:NaN
1930 2:2:1
1931 -2:2:NaN
1932 4:2:2
1933 9:2:3
1934 16:2:4
1935 100:2:10
1936 123:2:11
1937 15241:2:123
1938 144:2:12
1939 12:2:3
1940 0.49:2:0
1941 0.0049:2:0
1942 # invalid ones
1943 1:NaN:NaN
1944 -1:NaN:NaN
1945 0:NaN:NaN
1946 -inf:NaN:NaN
1947 +inf:NaN:NaN
1948 NaN:0:NaN
1949 NaN:2:NaN
1950 NaN:inf:NaN
1951 NaN:inf:NaN
1952 12:-inf:NaN
1953 12:inf:NaN
1954 +0:0:NaN
1955 +1:0:NaN
1956 -1:0:NaN
1957 -2:0:NaN
1958 -123.45:0:NaN
1959 +inf:0:NaN
1960 12:1:12
1961 -12:1:NaN
1962 8:-1:NaN
1963 -8:-1:NaN
1964 # cubic root
1965 8:3:2
1966 -8:3:NaN
1967 # fourths root
1968 16:4:2
1969 81:4:3
1970 # 2 ** 32
1971 18446744073709551616:4:65536
1972 18446744073709551616:8:256
1973 18446744073709551616:16:16
1974 18446744073709551616:32:4
1975 18446744073709551616:64:2
1976 18446744073709551616:128:1
1977 &bsqrt
1978 145:12
1979 144:12
1980 143:11
1981 16:4
1982 170:13
1983 169:13
1984 168:12
1985 4:2
1986 3:1
1987 2:1
1988 9:3
1989 12:3
1990 256:16
1991 100000000:10000
1992 4000000000000:2000000
1993 152399026:12345
1994 152399025:12345
1995 152399024:12344
1996 1:1
1997 0:0
1998 -2:NaN
1999 -123:NaN
2000 Nan:NaN
2001 +inf:inf
2002 -inf:NaN
2003 &bround
2004 $round_mode('trunc')
2005 0:12:0
2006 NaNbround:12:NaN
2007 +inf:12:inf
2008 -inf:12:-inf
2009 1234:0:1234
2010 1234:2:1200
2011 123456:4:123400
2012 123456:5:123450
2013 123456:6:123456
2014 +10123456789:5:10123000000
2015 -10123456789:5:-10123000000
2016 +10123456789:9:10123456700
2017 -10123456789:9:-10123456700
2018 +101234500:6:101234000
2019 -101234500:6:-101234000
2020 #+101234500:-4:101234000
2021 #-101234500:-4:-101234000
2022 $round_mode('zero')
2023 +20123456789:5:20123000000
2024 -20123456789:5:-20123000000
2025 +20123456789:9:20123456800
2026 -20123456789:9:-20123456800
2027 +201234500:6:201234000
2028 -201234500:6:-201234000
2029 #+201234500:-4:201234000
2030 #-201234500:-4:-201234000
2031 +12345000:4:12340000
2032 -12345000:4:-12340000
2033 $round_mode('+inf')
2034 +30123456789:5:30123000000
2035 -30123456789:5:-30123000000
2036 +30123456789:9:30123456800
2037 -30123456789:9:-30123456800
2038 +301234500:6:301235000
2039 -301234500:6:-301234000
2040 #+301234500:-4:301235000
2041 #-301234500:-4:-301234000
2042 +12345000:4:12350000
2043 -12345000:4:-12340000
2044 $round_mode('-inf')
2045 +40123456789:5:40123000000
2046 -40123456789:5:-40123000000
2047 +40123456789:9:40123456800
2048 -40123456789:9:-40123456800
2049 +401234500:6:401234000
2050 +401234500:6:401234000
2051 #-401234500:-4:-401235000
2052 #-401234500:-4:-401235000
2053 +12345000:4:12340000
2054 -12345000:4:-12350000
2055 $round_mode('odd')
2056 +50123456789:5:50123000000
2057 -50123456789:5:-50123000000
2058 +50123456789:9:50123456800
2059 -50123456789:9:-50123456800
2060 +501234500:6:501235000
2061 -501234500:6:-501235000
2062 #+501234500:-4:501235000
2063 #-501234500:-4:-501235000
2064 +12345000:4:12350000
2065 -12345000:4:-12350000
2066 $round_mode('even')
2067 +60123456789:5:60123000000
2068 -60123456789:5:-60123000000
2069 +60123456789:9:60123456800
2070 -60123456789:9:-60123456800
2071 +601234500:6:601234000
2072 -601234500:6:-601234000
2073 #+601234500:-4:601234000
2074 #-601234500:-4:-601234000
2075 #-601234500:-9:0
2076 #-501234500:-9:0
2077 #-601234500:-8:0
2078 #-501234500:-8:0
2079 +1234567:7:1234567
2080 +1234567:6:1234570
2081 +12345000:4:12340000
2082 -12345000:4:-12340000
2083 &is_zero
2084 0:1
2085 NaNzero:0
2086 +inf:0
2087 -inf:0
2088 123:0
2089 -1:0
2090 1:0
2091 &is_one
2092 0:0
2093 NaNone:0
2094 +inf:0
2095 -inf:0
2096 1:1
2097 2:0
2098 -1:0
2099 -2:0
2100 # floor and ceil tests are pretty pointless in integer space...but play safe
2101 &bfloor
2102 0:0
2103 NaNfloor:NaN
2104 +inf:inf
2105 -inf:-inf
2106 -1:-1
2107 -2:-2
2108 2:2
2109 3:3
2110 abc:NaN
2111 &bceil
2112 NaNceil:NaN
2113 +inf:inf
2114 -inf:-inf
2115 0:0
2116 -1:-1
2117 -2:-2
2118 2:2
2119 3:3
2120 abc:NaN
2121 &as_hex
2122 128:0x80
2123 -128:-0x80
2124 0:0x0
2125 -0:0x0
2126 1:0x1
2127 0x123456789123456789:0x123456789123456789
2128 +inf:inf
2129 -inf:-inf
2130 NaNas_hex:NaN
2131 &as_bin
2132 128:0b10000000
2133 -128:-0b10000000
2134 0:0b0
2135 -0:0b0
2136 1:0b1
2137 0b1010111101010101010110110110110110101:0b1010111101010101010110110110110110101
2138 0x123456789123456789:0b100100011010001010110011110001001000100100011010001010110011110001001
2139 +inf:inf
2140 -inf:-inf
2141 NaNas_bin:NaN