Big number implementation in pure javascript
npm install bn.js
> BigNum in pure javascript

npm install --save bn.js``js
const BN = require('bn.js');
var a = new BN('dead', 16);
var b = new BN('101010', 2);
var res = a.add(b);
console.log(res.toString(10)); // 57047
`
Note: decimals are not supported in this library.
There are several prefixes to instructions that affect the way the work. Here
is the list of them in the order of appearance in the function name:
* i - perform operation in-place, storing the result in the host object (onu
which the method was invoked). Might be used to avoid number allocation costs
* - unsigned, ignore the sign of operands when performing operation, ormod()
always return positive value. Second case applies to reduction operations
like . In such cases if the result will be negative - modulo will be
added to the result to make it positive
The only available postfix at the moment is:
* n - which means that the argument of the function must be a plain JavaScript
Number. Decimals are not supported.
* a.iadd(b) - perform addition on a and b, storing the result in aa.umod(b)
* - reduce a modulo b, returning positive valuea.iushln(13)
* - shift bits of a left by 13
Prefixes/postfixes are put in parens at the of the line. endian - could bele
either (little-endian) or be (big-endian).
* a.clone() - clone numbera.toString(base, length)
* - convert to base-string and pad with zeroesa.toNumber()
* - convert to Javascript Number (limited to 53 bits)a.toJSON()
* - convert to JSON compatible hex string (alias of toString(16))a.toArray(endian, length)
* - convert to byte Array, and optionally zeroa.toArrayLike(type, endian, length)
pad to length, throwing if already exceeding
* - convert to an instance of type,Array
which must behave like an a.toBuffer(endian, length)
* - convert to Node.js Buffer (if available). Fora.toArrayLike(Buffer, endian, length)
compatibility with browserify and similar tools, use this instead:
a.bitLength()
* - get number of bits occupieda.zeroBits()
* - return number of less-significant consequent zero bits1010000
(example: has 4 zero bits)a.byteLength()
* - return number of bytes occupieda.isNeg()
* - true if the number is negativea.isEven()
* - no commentsa.isOdd()
* - no commentsa.isZero()
* - no commentsa.cmp(b)
* - compare numbers and return -1 (a < b), 0 (a == b), or 1 (a > b)ucmp
depending on the comparison result (, cmpn)a.lt(b)
* - a less than b (n)a.lte(b)
* - a less than or equals b (n)a.gt(b)
* - a greater than b (n)a.gte(b)
* - a greater than or equals b (n)a.eq(b)
* - a equals b (n)a.toTwos(width)
* - convert to two's complement representation, where width is bit widtha.fromTwos(width)
* - convert from two's complement representation, where width is the bit widthBN.isBN(object)
* - returns true if the supplied object is a BN.js instance
* a.neg() - negate sign (i)a.abs()
* - absolute value (i)a.add(b)
* - addition (i, n, in)a.sub(b)
* - subtraction (i, n, in)a.mul(b)
* - multiply (i, n, in)a.sqr()
* - square (i)a.pow(b)
* - raise a to the power of ba.div(b)
* - divide (divn, idivn)a.mod(b)
* - reduct (u, n) (but no umodn)a.divRound(b)
* - rounded division
* a.or(b) - or (i, u, iu)a.and(b)
* - and (i, u, iu, andln) (NOTE: andln is going to be replacedandn
with in future)a.xor(b)
* - xor (i, u, iu)a.setn(b)
* - set specified bit to 1a.shln(b)
* - shift left (i, u, iu)a.shrn(b)
* - shift right (i, u, iu)a.testn(b)
* - test if specified bit is seta.maskn(b)
* - clear bits with indexes higher or equal to b (i)a.bincn(b)
* - add 1 << b to the numbera.notn(w)
* - not (for the width specified by w) (i)
* a.gcd(b) - GCDa.egcd(b)
* - Extended GCD results ({ a: ..., b: ..., gcd: ... })a.invm(b)
* - inverse a modulo b
When doing lots of reductions using the same modulo, it might be beneficial to
use some tricks: like [Montgomery multiplication][0], or using special algorithm
for [Mersenne Prime][1].
To enable this tricks one should create a reduction context:
`js`
var red = BN.red(num);num
where is just a BN instance.
Or:
`js`
var red = BN.red(primeName);
Where primeName is either of these [Mersenne Primes][1]:
* 'k256''p224'
* 'p192'
* 'p25519'
*
Or:
`js`
var red = BN.mont(num);
To reduce numbers with [Montgomery trick][0]. .mont() is generally faster than.red(num), but slower than BN.red(primeName).
Before performing anything in reduction context - numbers should be converted
to it. Usually, this means that one should:
* Convert inputs to reducted ones
* Operate on them in reduction context
* Convert outputs back from the reduction context
Here is how one may convert numbers to red:
`js`
var redA = a.toRed(red);red
Where is a reduction context created using instructions above
Here is how to convert them back:
`js`
var a = redA.fromRed();
Most of the instructions from the very start of this readme have their
counterparts in red context:
* a.redAdd(b), a.redIAdd(b)a.redSub(b)
* , a.redISub(b)a.redShl(num)
* a.redMul(b)
* , a.redIMul(b)a.redSqr()
* , a.redISqr()a.redSqrt()
* - square root modulo reduction context's primea.redInvm()
* - modular inverse of the numbera.redNeg()
* a.redPow(b)` - modular exponentiation
*
This software is licensed under the MIT License.
[0]: https://en.wikipedia.org/wiki/Montgomery_modular_multiplication
[1]: https://en.wikipedia.org/wiki/Mersenne_prime