Question

I’d like to write (not to use existing one) a library (or something) that works with long numbers (I mean at least few hundred digits).

The first question: choosing a language for it. Which one is better: Perl/JavaScript/PHP?

The second question: how to implement operations with long numbers? The only thing I get is to work with them as with arrays, e.g.:

arr1 = (12, 34); //1234
arr2 = (98, 76); //9876
sum = longnumbers_add(arr1, arr2); // +
// 34 + 76 = 110 = 10 -..> 1
// 12 + 98 = 110 = 110 + 1 = 11 -..> 1
//sum == (1, 11, 10);

But it worked to slow (at least with my try in PHP). Maybe there’s some “shift bits” super-fast method?

P.S.

I know there are gmp and other cool libraries.

Any help is appreciated.

Answer 1

I’ve written a couple big number libraries for fun. As far as the language, I would either choose whichever one you’re most comfortable with or one you want to learn more about. For me, that was JavaScript most recently, but in my opinion, none of those languages are any more or less suited to large numbers. For the web though, a large part of the decision comes down to whether you want to do the calculations on the client or server side. On the client side, JavaScript is pretty much the only option.

I wrote a couple blog posts demonstrating the basic algorithms and how I chose to store them. Note that these are for big integers only (so no decimal point), but the basics still apply.

• http://silentmatt.com/blog/2011/10/how-bigintegers-work/
• http://silentmatt.com/blog/2011/10/how-bigintegers-work-part-2-multiplication/

Here are a few thoughts from my experience:

• It’s probably easiest conceptually to store the numbers in base 10 because it’s more familiar, but it really doesn’t change much of the implementation. Larger bases are more efficient though (in both memory and speed).
• It’s almost always simpler to keep the digits in “little endian” order, so the least significant digit comes first in the array (or if you used strings, store them reversed).
• Don’t worry too much about performance until you get it working. The fastest way to do things can sometimes be surprising so you’ll get it wrong anyway, and it’s easy to go back and optimize each operation once you’re done.
• If you want to support decimals, it can be easiest to write an integer type first, then implement floating point numbers on top of that. Basically, you can separate out the code to keep track of decimal places so it keeps the algorithms cleaner.
• You’ll need to decide if you want to use two’s complement (10’s complement, or the equivalent for whatever base you choose also works) or sign-magnitude (where you store the sign separately from the digits) for handling negative numbers. Each method is more complicated in some areas and simpler in others. Generally though, n’s-complement is probably simpler if you have a fixed size, but sign-magnitude might be simpler for arbitrarily-sized numbers.