What Is the Standard Solution in JavaScript for Handling Big Numbers (Bignum)

What is the standard solution in JavaScript for handling big numbers (BigNum)?

Update(2019-08-19): BigInt is now part of Firefox and Chrome; you no longer need a library:

const bigInt1 = 1111111111111111111111111111111n;

const bigInt2 = BigInt("1111111111111111111111111111111")

console.log((bigInt1 + bigInt2)+"")

How to deal with big numbers in javascript

While looking for an big integer library for an ElGamal crypto implementation I tested several libraries with the following results:

I recommend this one: Tom Wu's jsbn.js (http://www-cs-students.stanford.edu/~tjw/jsbn/)

• Comprehensive set of functions and fast

Leemon Baird's big integer library (http://www.leemon.com/crypto/BigInt.js)

• Comprehensive set of functions and pretty fast
• BUT: Negative number representation is buggy!

bignumber.js (https://github.com/MikeMcl/bignumber.js)

• Pretty complete set of functions
• BUT: Converting really big numbers from strings into BigNumber objects result in INFINITY

Scheme arithmetic library for JavaScript (https://github.com/jtobey/javascript-bignum)

• JS-Implementation of Scheme arithmetic functions
• BUT: No function for y= x^e mod n

I haven't tested this by myself: BigNumber (http://jsfromhell.com/classes/bignumber)

• Functions for high precision claculations
• BUT: It's said to be slow due to internal representation of numbers as strings

How do I deal with number greater than 2^53 in Javascript?

Javascript numbers are represented internally as IEEE 754 double-precision floating point numbers.

On an absolute scale, they can represent numbers from -2¹⁰²³ to 2¹⁰²³. For small numbers like 1, they have a very high precision, down to steps of 2^-52. However, as the magnitude of a number increases, the precision of the representation decreases. The ±2⁵³ range you've read about is the maximum range of integer representations — once a number exceeds 2⁵³, the minimum "step" increases from 1 to 2.

If you need to exactly represent integers greater than 2⁵³, you will need to use a Javascript bignum library. However, if you just need to represent floating-point values, you're OK; the default number type will do just fine.

is there any JavaScript interpretor that can handle very large numbers?

To actually explain the Uncaught SyntaxError: Unexpected token ILLEGAL.

The cause of this is actually that...

...20752963450.toString();
              ^-------- ...the dot after a number is treated as a decimal point
                        Therefore this doesn't make sense.
                        But if you add a space in front of the dot, then it will work because
                        now JavaScript uses it to access the toString() method.

12323 .toString() // this will work as you'd expect it to if you come from Ruby or the like

Still, if you add the space num will be infinity. So you'll have to look at awoodland's answer for a BigNum implementation.

How do I process enormous numbers?

See

Most efficient implementation of a large number class

for some leads.

How come I can't add 1 to a large number in javascript

You can't use a Date that big in javascript, without making a bigDay library to handle your bignums.

/*

from 'https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Date':

The JavaScript date is measured in milliseconds since midnight 01 January, 1970 UTC. A day holds 86,400,000 milliseconds. The JavaScript Date object range is -100,000,000 days to 100,000,000 days relative to 01 January, 1970 UTC.
*/

var firstday=new Date(1970,0,1),lastday=new Date(1969,11,31);

firstday.setDate(firstday.getDate()-100000000);

lastday.setDate(lastday.getDate()+100000000);

firstday.toUTCString()+'; timestamp: '+firstday.getTime()+'\n'+
lastday.toUTCString()+'; timestamp: '+lastday.getTime();

/* returned value: (largest and smallest Dates in JS)

Tue, 20 Apr -271821 04:00:00 GMT; timestamp: -8639999985600000

Fri, 12 Sep 275760 04:00:00 GMT; timestamp: 8639999928000000
*/

Javascript - get very big number as string containing all digits

You could use toLocaleString method (with some options, if needed):

const s = Number.MAX_VALUE.toLocaleString(undefined, {

  style: 'decimal',

  useGrouping: false //Flip to true if you want to include commas

});

console.log(s)

JavaScript large number library?

As its author, I recommend big.js, 'a small, fast Javascript library for arbitrary-precision arithmetic with decimal numbers'.

---

Related Topics