use Math::BigInt;

         # or make it faster: install (optional) Math::BigInt::GMP
         # and always use (it will fall back to pure Perl if the
         # GMP library is not installed):

         use Math::BigInt lib => 'GMP';

         my $str = '1234567890';

         $x = Math::BigInt->new($str);         # defaults to 0
         $y = $x->copy();                      # make a true copy
         $x->badd($y);         # addition (add $y to $x)
         $x->bsub($y);         # subtraction (subtract $y from $x)
         $x->bstr();              # convert to a normalized string
         $x->bsstr();             # normalized string in scientific no
+tation
         $x->as_hex();            # as signed hexadecimal string with 
+prefixed 0x
         $x->as_bin();            # as signed binary string with prefi
+xed 0b

# etc.
[download]

No need to resort to "big int" modules if you only need 10 digits. Every version of Perl can do arithmatic with exact precision on integers at least to 15 digits. If you divide and wish to get an integer result, then use int which removes the fractional part of the number but doesn't truncate the value to fit in an IV.

That is, a C data type of "double" (NV) can handle integers (and rather large ones at that) quite well and Perl does this. And Perl's int() doesn't convert to a C data type like "int" or "long" (IV).

- tye        

Use should consider using BigInt/BigFloat for very large numbers, as if you get too many significant digits normal floating point math is going to lose accuracy...but of course there is a speed tradeoff.

But that's the thing: it is doing at least some things correctly. I wanted to see what would happen with this code:

perl -le 'print $i+=100_000_000 while 1'
[download]

...and it takes it like a champ, not reaching "Infinity" until something like 1e315. Also, this looks right, too:

perl -le 'print (((1<<31)**(1<<5)), " ",((1<<31)**(1<<5)/2))'
[download]

So, perl is somehow doing the arithmetic...maybe it's just lucky. :)

thor

p.s. This whole thing was more of a curiosity than anything. I've used Math::BigInt before. I was just perplexed by something that I would have expected not to work.

Anything larger than 2**32-1 is converted to 2**32-1 (aka -1).

Anything smaller than -2**31 is converted to 2**31 (aka -2**31).

Nothing else works this way. Certainly not libm.

Whatever, it can really screw you if you aren't careful:

(0xFFFFFFFF+1)&0xFFFFFFFF == 0xFFFFFFFF and die "Database wiped\n"

Database wiped
[download]