		// Generate two primes p and q to the Digital Signature Standard (DSS)
		// http://www.itl.nist.gov/fipspubs/fip186.htm appendix 2.2

		var bignum = require('../');
		var assert = require('assert');
		var bignum = require('../')
		var assert = require('assert')

		var q = bignum(2).pow(159).add(1).rand(bignum(2).pow(160)).nextPrime();
		var L = 512 + 64 * Math.floor(Math.random() * 8);
		var q = bignum(2).pow(159).add(1).rand(bignum(2).pow(160)).nextPrime()
		var L = 512 + 64 * Math.floor(Math.random() * 8)

		do {
		var X = bignum(2).pow(L-1).add(1).rand(bignum(2).pow(L));
		var c = X.mod(q.mul(2));
		var p = X.sub(c.sub(1)); // p is congruent to 1 % 2q somehow!
		var X = bignum(2).pow(L - 1).add(1).rand(bignum(2).pow(L))
		var c = X.mod(q.mul(2))
		var p = X.sub(c.sub(1)) // p is congruent to 1 % 2q somehow!
		} while (p.lt(bignum.pow(2, L - 1)) \|\| p.probPrime(50) === false)

		assert.ok(q.gt(bignum.pow(2,159)), 'q > 2**159');
		assert.ok(q.lt(bignum.pow(2,160)), 'q < 2**160');
		assert.ok(p.gt(bignum.pow(2,L-1)), 'p > 2**(L-1)');
		assert.ok(q.lt(bignum.pow(2,L)), 'p < 2**L');
		assert.ok(q.mul(p.sub(1).div(q)).add(1).eq(p), 'q divides p - 1');
		assert.ok(q.gt(bignum.pow(2, 159)), 'q > 2**159')
		assert.ok(q.lt(bignum.pow(2, 160)), 'q < 2**160')
		assert.ok(p.gt(bignum.pow(2, L - 1)), 'p > 2**(L-1)')
		assert.ok(q.lt(bignum.pow(2, L)), 'p < 2**L')
		assert.ok(q.mul(p.sub(1).div(q)).add(1).eq(p), 'q divides p - 1')

		assert.ok(p.probPrime(50), 'p is not prime!');
		assert.ok(q.probPrime(50), 'q is not prime!');
		assert.ok(p.probPrime(50), 'p is not prime!')
		assert.ok(q.probPrime(50), 'q is not prime!')

		console.dir({ p : p, q : q });
		console.dir({ p: p, q: q })

examples/perfect.js

		// If 2n-1 is prime, then (2n-1) * 2**(n-1) is perfect.
		var bignum = require('../');
		var bignum = require('../')

		for (var n = 0; n < 100; n++) {
		var p = bignum.pow(2, n).sub(1);
		if (p.probPrime(50)) {
		var perfect = p.mul(bignum.pow(2, n - 1));
		console.log(perfect.toString());
		}
		var p = bignum.pow(2, n).sub(1)
		if (p.probPrime(50)) {
		var perfect = p.mul(bignum.pow(2, n - 1))
		console.log(perfect.toString())
		}
		}

examples/simple.js

		@@ -1,7 +0,7 @@
		var bignum = require('../');
		var bignum = require('../')

		var b = bignum('782910138827292261791972728324982')
		.sub('182373273283402171237474774728373')
		.div(8)
		;
		console.log(b);
		.sub('182373273283402171237474774728373')
		.div(8)

		console.log(b)

654

index.js

		@@ -1,449 +0,409 @@
		try {
		var cc = new require('./build/Debug/bignum');
		} catch(e) {
		var cc = new require('./build/Release/bignum');
		}
		var BigNum = cc.BigNum;
		var bin = require('bindings')('bignum.node')
		var BigNum = bin.BigNum

		module.exports = BigNum;
		module.exports = BigNum

		BigNum.conditionArgs = function(num, base) {
		if (typeof num !== 'string') num = num.toString(base \|\| 10);
		BigNum.conditionArgs = function (num, base) {
		if (typeof num !== 'string') num = num.toString(base \|\| 10)

		if (num.match(/e\+/)) { // positive exponent
		if (!Number(num).toString().match(/e\+/)) {
		return {
		num: Math.floor(Number(num)).toString(),
		base: 10
		};
		}
		else {
		var pow = Math.ceil(Math.log(num) / Math.log(2));
		var n = (num / Math.pow(2, pow)).toString(2)
		.replace(/^0/,'');
		var i = n.length - n.indexOf('.');
		n = n.replace(/\./,'');
		if (num.match(/e\+/)) { // positive exponent
		if (!Number(num).toString().match(/e+/)) {
		return {
		num: Math.floor(Number(num)).toString(),
		base: 10
		}
		} else {
		var pow = Math.ceil(Math.log(num) / Math.log(2))
		var n = (num / Math.pow(2, pow)).toString(2)
		.replace(/^0/, '')
		var i = n.length - n.indexOf('.')
		n = n.replace(/\./, '')

		for (; i <= pow; i++) n += '0';
		return {
		num : n,
		base : 2,
		};
		}
		for (; i <= pow; i++) n += '0'
		return {
		num: n,
		base: 2
		}
		}
		else if (num.match(/e\-/)) { // negative exponent
		return {
		num : Math.floor(Number(num)).toString(),
		base : base \|\| 10
		};
		} else if (num.match(/e\-/)) { // negative exponent
		return {
		num: Math.floor(Number(num)).toString(),
		base: base \|\| 10
		}
		else {
		return {
		num : num,
		base : base \|\| 10,
		};
		} else {
		return {
		num: num,
		base: base \|\| 10
		}
		};
		}
		}

		cc.setJSConditioner(BigNum.conditionArgs);
		bin.setJSConditioner(BigNum.conditionArgs)

		BigNum.isBigNum = function(num) {
		if (!num) {
		return false;
		BigNum.isBigNum = function (num) {
		if (!num) {
		return false
		}
		for (var key in BigNum.prototype) {
		if (!num[key]) {
		return false
		}
		for(var key in BigNum.prototype) {
		if (!num[key]) {
		return false;
		}
		}
		return true;
		};
		}
		return true
		}

		BigNum.prototype.inspect = function () {
		return '<BigNum ' + this.toString(10) + '>';
		};
		return '<BigNum ' + this.toString(10) + '>'
		}

		BigNum.prototype.toString = function (base) {
		var value;
		if (base) {
		value = this.tostring(base);
		} else {
		value = this.tostring();
		}
		if (base > 10 && "string" === typeof value) {
		value = value.toLowerCase();
		}
		return value;
		};
		var value
		if (base) {
		value = this.tostring(base)
		} else {
		value = this.tostring()
		}
		if (base > 10 && typeof value === 'string') {
		value = value.toLowerCase()
		}
		return value
		}

		BigNum.prototype.toNumber = function () {
		return parseInt(this.toString(), 10);
		};
		return parseInt(this.toString(), 10)
		}

		[ 'add', 'sub', 'mul', 'div', 'mod' ].forEach(function (op) {
		BigNum.prototype[op] = function (num) {
		if (BigNum.isBigNum(num)) {
		return this['b'+op](num);
		}
		else if (typeof num === 'number') {
		if (num >= 0) {
		return this['u'+op](num);
		}
		else if (op === 'add') {
		return this.usub(-num);
		}
		else if (op === 'sub') {
		return this.uadd(-num);
		}
		else {
		var x = BigNum(num);
		return this['b'+op](x);
		}
		}
		else if (typeof num === 'string') {
		var x = BigNum(num);
		return this['b'+op](x);
		}
		else {
		throw new TypeError('Unspecified operation for type '
		+ (typeof num) + ' for ' + op);
		}
		};
		});
		;[ 'add', 'sub', 'mul', 'div', 'mod' ].forEach(function (op) {
		BigNum.prototype[op] = function (num) {
		var x
		if (BigNum.isBigNum(num)) {
		return this['b' + op](num)
		} else if (typeof num === 'number') {
		if (num >= 0) {
		return this['u' + op](num)
		} else if (op === 'add') {
		return this.usub(-num)
		} else if (op === 'sub') {
		return this.uadd(-num)
		} else {
		x = BigNum(num)
		return this['b' + op](x)
		}
		} else if (typeof num === 'string') {
		x = BigNum(num)
		return this['b' + op](x)
		} else {
		throw new TypeError('Unspecified operation for type ' +
		(typeof num) + ' for ' + op)
		}
		}
		})

		BigNum.prototype.abs = function () {
		return this.babs();
		};
		return this.babs()
		}

		BigNum.prototype.neg = function () {
		return this.bneg();
		};
		return this.bneg()
		}

		BigNum.prototype.powm = function (num, mod) {
		var m, res;
		var m

		if ((typeof mod) === 'number' \|\| (typeof mod) === 'string') {
		m = BigNum(mod);
		}
		else if (BigNum.isBigNum(mod)) {
		m = mod;
		}
		if ((typeof mod) === 'number' \|\| (typeof mod) === 'string') {
		m = BigNum(mod)
		} else if (BigNum.isBigNum(mod)) {
		m = mod
		}

		if ((typeof num) === 'number') {
		return this.upowm(num, m);
		}
		else if ((typeof num) === 'string') {
		var n = BigNum(num);
		return this.bpowm(n, m);
		}
		else if (BigNum.isBigNum(num)) {
		return this.bpowm(num, m);
		}
		};
		if ((typeof num) === 'number') {
		return this.upowm(num, m)
		} else if ((typeof num) === 'string') {
		var n = BigNum(num)
		return this.bpowm(n, m)
		} else if (BigNum.isBigNum(num)) {
		return this.bpowm(num, m)
		}
		}

		BigNum.prototype.mod = function (num, mod) {
		var m, res;
		var m

		if ((typeof mod) === 'number' \|\| (typeof mod) === 'string') {
		m = BigNum(mod);
		}
		else if (BigNum.isBigNum(mod)) {
		m = mod;
		}
		if ((typeof mod) === 'number' \|\| (typeof mod) === 'string') {
		m = BigNum(mod)
		} else if (BigNum.isBigNum(mod)) {
		m = mod
		}

		if ((typeof num) === 'number') {
		return this.umod(num, m);
		}
		else if ((typeof num) === 'string') {
		var n = BigNum(num);
		return this.bmod(n, m);
		}
		else if (BigNum.isBigNum(num)) {
		return this.bmod(num, m);
		}
		};
		if ((typeof num) === 'number') {
		return this.umod(num, m)
		} else if ((typeof num) === 'string') {
		var n = BigNum(num)
		return this.bmod(n, m)
		} else if (BigNum.isBigNum(num)) {
		return this.bmod(num, m)
		}
		}


		BigNum.prototype.pow = function (num) {
		if (typeof num === 'number') {
		if (num >= 0) {
		return this.upow(num);
		}
		else {
		return BigNum.prototype.powm.call(this, num, this);
		}
		if (typeof num === 'number') {
		if (num >= 0) {
		return this.upow(num)
		} else {
		return BigNum.prototype.powm.call(this, num, this)
		}
		else {
		var x = parseInt(num.toString(), 10);
		return BigNum.prototype.pow.call(this, x);
		}
		};
		} else {
		var x = parseInt(num.toString(), 10)
		return BigNum.prototype.pow.call(this, x)
		}
		}

		BigNum.prototype.shiftLeft = function (num) {
		if (typeof num === 'number') {
		if (num >= 0) {
		return this.umul2exp(num);
		}
		else {
		return this.shiftRight(-num);
		}
		if (typeof num === 'number') {
		if (num >= 0) {
		return this.umul2exp(num)
		} else {
		return this.shiftRight(-num)
		}
		else {
		var x = parseInt(num.toString(), 10);
		return BigNum.prototype.shiftLeft.call(this, x);
		}
		};
		} else {
		var x = parseInt(num.toString(), 10)
		return BigNum.prototype.shiftLeft.call(this, x)
		}
		}

		BigNum.prototype.shiftRight = function (num) {
		if (typeof num === 'number') {
		if (num >= 0) {
		return this.udiv2exp(num);
		}
		else {
		return this.shiftLeft(-num);
		}
		if (typeof num === 'number') {
		if (num >= 0) {
		return this.udiv2exp(num)
		} else {
		return this.shiftLeft(-num)
		}
		else {
		var x = parseInt(num.toString(), 10);
		return BigNum.prototype.shiftRight.call(this, x);
		}
		};
		} else {
		var x = parseInt(num.toString(), 10)
		return BigNum.prototype.shiftRight.call(this, x)
		}
		}

		BigNum.prototype.cmp = function (num) {
		if (BigNum.isBigNum(num)) {
		return this.bcompare(num);
		if (BigNum.isBigNum(num)) {
		return this.bcompare(num)
		} else if (typeof num === 'number') {
		if (num < 0) {
		return this.scompare(num)
		} else {
		return this.ucompare(num)
		}
		else if (typeof num === 'number') {
		if (num < 0) {
		return this.scompare(num);
		}
		else {
		return this.ucompare(num);
		}
		}
		else {
		var x = BigNum(num);
		return this.bcompare(x);
		}
		};
		} else {
		var x = BigNum(num)
		return this.bcompare(x)
		}
		}

		BigNum.prototype.gt = function (num) {
		return this.cmp(num) > 0;
		};
		return this.cmp(num) > 0
		}

		BigNum.prototype.ge = function (num) {
		return this.cmp(num) >= 0;
		};
		return this.cmp(num) >= 0
		}

		BigNum.prototype.eq = function (num) {
		return this.cmp(num) === 0;
		};
		return this.cmp(num) === 0
		}

		BigNum.prototype.ne = function (num) {
		return this.cmp(num) !== 0;
		};
		return this.cmp(num) !== 0
		}

		BigNum.prototype.lt = function (num) {
		return this.cmp(num) < 0;
		};
		return this.cmp(num) < 0
		}

		BigNum.prototype.le = function (num) {
		return this.cmp(num) <= 0;
		};
		return this.cmp(num) <= 0
		}

		'and or xor'.split(' ').forEach(function (name) {
		BigNum.prototype[name] = function (num) {
		if (BigNum.isBigNum(num)) {
		return this['b' + name](num);
		}
		else {
		var x = BigNum(num);
		return this['b' + name](x);
		}
		};
		});

		BigNum.prototype.sqrt = function() {
		return this.bsqrt();
		};

		BigNum.prototype.root = function(num) {
		BigNum.prototype[name] = function (num) {
		if (BigNum.isBigNum(num)) {
		return this.broot(num);
		return this['b' + name](num)
		} else {
		var x = BigNum(num)
		return this['b' + name](x)
		}
		else {
		var x = BigNum(num);
		return this.broot(num);
		}
		};
		}
		})

		BigNum.prototype.sqrt = function () {
		return this.bsqrt()
		}

		BigNum.prototype.root = function (num) {
		if (BigNum.isBigNum(num)) {
		return this.broot(num)
		} else {
		return this.broot(num)
		}
		}

		BigNum.prototype.rand = function (to) {
		if (to === undefined) {
		if (this.toString() === '1') {
		return BigNum(0);
		}
		else {
		return this.brand0();
		}
		if (to === undefined) {
		if (this.toString() === '1') {
		return BigNum(0)
		} else {
		return this.brand0()
		}
		else {
		var x = BigNum.isBigNum(to)
		? to.sub(this)
		: BigNum(to).sub(this);
		return x.brand0().add(this);
		}
		};
		} else {
		var x = BigNum.isBigNum(to)
		? to.sub(this)
		: BigNum(to).sub(this)
		return x.brand0().add(this)
		}
		}

		BigNum.prototype.invertm = function (mod) {
		if (BigNum.isBigNum(mod)) {
		return this.binvertm(mod);
		}
		else {
		var x = BigNum(mod);
		return this.binvertm(x);
		}
		};
		if (BigNum.isBigNum(mod)) {
		return this.binvertm(mod)
		} else {
		var x = BigNum(mod)
		return this.binvertm(x)
		}
		}

		BigNum.prime = function (bits, safe) {
		if ("undefined" === typeof safe) {
		safe = true;
		if (typeof safe === 'undefined') {
		safe = true
		}

		// Force uint32
		bits >>>= 0;
		bits >>>= 0

		return BigNum.uprime0(bits, !!safe);
		};
		return BigNum.uprime0(bits, !!safe)
		}

		BigNum.prototype.probPrime = function (reps) {
		var n = this.probprime(reps \|\| 10);
		return { 1 : true, 0 : false }[n];
		};
		var n = this.probprime(reps \|\| 10)
		return { 1: true, 0: false }[n]
		}

		BigNum.prototype.nextPrime = function () {
		var num = this;
		do {
		num = num.add(1);
		} while (!num.probPrime());
		return num;
		};
		var num = this
		do {
		num = num.add(1)
		} while (!num.probPrime())
		return num
		}

		BigNum.prototype.isBitSet = function (n) {
		return this.isbitset(n) === 1;
		};
		return this.isbitset(n) === 1
		}

		BigNum.fromBuffer = function (buf, opts) {
		if (!opts) opts = {};
		if (!opts) opts = {}

		var endian = { 1 : 'big', '-1' : 'little' }[opts.endian]
		\|\| opts.endian \|\| 'big'
		;
		var endian = { 1: 'big', '-1': 'little' }[opts.endian] \|\|
		opts.endian \|\| 'big'

		var size = opts.size === 'auto' ? Math.ceil(buf.length) : (opts.size \|\| 1);
		var size = opts.size === 'auto' ? Math.ceil(buf.length) : (opts.size \|\| 1)

		if (buf.length % size !== 0) {
		throw new RangeError('Buffer length (' + buf.length + ')'
		+ ' must be a multiple of size (' + size + ')'
		);
		if (buf.length % size !== 0) {
		throw new RangeError('Buffer length (' + buf.length + ')' +
		' must be a multiple of size (' + size + ')'
		)
		}

		var hex = []
		for (var i = 0; i < buf.length; i += size) {
		var chunk = []
		for (var j = 0; j < size; j++) {
		chunk.push(buf[i + (endian === 'big' ? j : (size - j - 1))])
		}

		var hex = [];
		for (var i = 0; i < buf.length; i += size) {
		var chunk = [];
		for (var j = 0; j < size; j++) {
		chunk.push(buf[
		i + (endian === 'big' ? j : (size - j - 1))
		]);
		}
		hex.push(chunk
		.map(function (c) {
		return (c < 16 ? '0' : '') + c.toString(16)
		})
		.join('')
		)
		}

		hex.push(chunk
		.map(function (c) {
		return (c < 16 ? '0' : '') + c.toString(16);
		})
		.join('')
		);
		}
		return BigNum(hex.join(''), 16)
		}

		return BigNum(hex.join(''), 16);
		};

		BigNum.prototype.toBuffer = function (opts) {
		if (typeof opts === 'string') {
		if (opts !== 'mpint') return 'Unsupported Buffer representation';
		if (typeof opts === 'string') {
		if (opts !== 'mpint') return 'Unsupported Buffer representation'

		var abs = this.abs();
		var buf = abs.toBuffer({ size : 1, endian : 'big' });
		var len = buf.length === 1 && buf[0] === 0 ? 0 : buf.length;
		if (buf[0] & 0x80) len ++;
		var abs = this.abs()
		var buf = abs.toBuffer({ size: 1, endian: 'big' })
		var len = buf.length === 1 && buf[0] === 0 ? 0 : buf.length
		if (buf[0] & 0x80) len++

		var ret = new Buffer(4 + len);
		if (len > 0) buf.copy(ret, 4 + (buf[0] & 0x80 ? 1 : 0));
		if (buf[0] & 0x80) ret[4] = 0;
		var ret = new Buffer(4 + len)
		if (len > 0) buf.copy(ret, 4 + (buf[0] & 0x80 ? 1 : 0))
		if (buf[0] & 0x80) ret[4] = 0

		ret[0] = len & (0xff << 24);
		ret[1] = len & (0xff << 16);
		ret[2] = len & (0xff << 8);
		ret[3] = len & (0xff << 0);
		ret[0] = len & (0xff << 24)
		ret[1] = len & (0xff << 16)
		ret[2] = len & (0xff << 8)
		ret[3] = len & (0xff << 0)

		// two's compliment for negative integers:
		var isNeg = this.lt(0);
		if (isNeg) {
		for (var i = 4; i < ret.length; i++) {
		ret[i] = 0xff - ret[i];
		}
		}
		ret[4] = (ret[4] & 0x7f) \| (isNeg ? 0x80 : 0);
		if (isNeg) ret[ret.length - 1] ++;

		return ret;
		// two's compliment for negative integers:
		var isNeg = this.lt(0)
		if (isNeg) {
		for (var i = 4; i < ret.length; i++) {
		ret[i] = 0xff - ret[i]
		}
		}
		ret[4] = (ret[4] & 0x7f) \| (isNeg ? 0x80 : 0)
		if (isNeg) ret[ret.length - 1]++

		if (!opts) opts = {};
		return ret
		}

		var endian = { 1 : 'big', '-1' : 'little' }[opts.endian]
		\|\| opts.endian \|\| 'big'
		;
		if (!opts) opts = {}

		var hex = this.toString(16);
		if (hex.charAt(0) === '-') throw new Error(
		'converting negative numbers to Buffers not supported yet'
		);
		var endian = { 1: 'big', '-1': 'little' }[opts.endian] \|\|
		opts.endian \|\| 'big'

		var size = opts.size === 'auto' ? Math.ceil(hex.length / 2) : (opts.size \|\| 1);
		var hex = this.toString(16)
		if (hex.charAt(0) === '-') {
		throw new Error('converting negative numbers to Buffers not supported yet')
		}

		var len = Math.ceil(hex.length / (2 * size)) * size;
		var buf = new Buffer(len);
		var size = opts.size === 'auto' ? Math.ceil(hex.length / 2) : (opts.size \|\| 1)

		// zero-pad the hex string so the chunks are all `size` long
		while (hex.length < 2 * len) hex = '0' + hex;
		len = Math.ceil(hex.length / (2 * size)) * size
		buf = new Buffer(len)

		var hx = hex
		.split(new RegExp('(.{' + (2 * size) + '})'))
		.filter(function (s) { return s.length > 0 })
		;
		// zero-pad the hex string so the chunks are all `size` long
		while (hex.length < 2 * len) hex = '0' + hex

		hx.forEach(function (chunk, i) {
		for (var j = 0; j < size; j++) {
		var ix = i * size + (endian === 'big' ? j : size - j - 1);
		buf[ix] = parseInt(chunk.slice(j2,j2+2), 16);
		}
		});
		var hx = hex
		.split(new RegExp('(.{' + (2 * size) + '})'))
		.filter(function (s) { return s.length > 0 })

		return buf;
		};
		hx.forEach(function (chunk, i) {
		for (var j = 0; j < size; j++) {
		var ix = i * size + (endian === 'big' ? j : size - j - 1)
		buf[ix] = parseInt(chunk.slice(j * 2, j * 2 + 2), 16)
		}
		})

		return buf
		}

		Object.keys(BigNum.prototype).forEach(function (name) {
		if (name === 'inspect' \|\| name === 'toString') return;
		if (name === 'inspect' \|\| name === 'toString') return

		BigNum[name] = function (num) {
		var args = [].slice.call(arguments, 1);
		BigNum[name] = function (num) {
		var args = [].slice.call(arguments, 1)

		if (BigNum.isBigNum(num)) {
		return num[name].apply(num, args);
		}
		else {
		var bigi = BigNum(num);
		return bigi[name].apply(bigi, args);
		}
		};
		});
		if (BigNum.isBigNum(num)) {
		return num[name].apply(num, args)
		} else {
		var bigi = BigNum(num)
		return bigi[name].apply(bigi, args)
		}
		}
		})

package.json

		{
		"name": "bignum",
		"version": "0.12.0",
		"version": "0.12.1",
		"description": "Arbitrary-precision integer arithmetic using OpenSSL",
		@@ -25,16 +25,14 @@ "main": "./index.js",
		"dependencies": {
		"bindings": "~1.2.1",
		"nan": "^2.3.4"
		},
		"devDependencies": {
		"expresso": ">=0.6.0",
		"binary": ">=0.1.7",
		"put": ">=0.0.5"
		"put": "~0.0.5",
		"standard": "~7.1.2",
		"tap": "~5.7.2"
		},
		"license": "MIT",
		"engine": {
		"node": ">=0.8.0"
		},
		"scripts": {
		"install": "node-gyp configure build",
		"test": "expresso"
		"test": "standard && tap --cov test/*.js"
		},
		@@ -41,0 +39,0 @@ "contributors": [

1005

test/big.js

		@@ -1,540 +0,569 @@
		var assert = require('assert');
		var bignum = require('../');
		var BigNum = require('../')
		var test = require('tap').test

		exports.create = function () {
		assert.eql(bignum(1337).toString(), '1337');
		assert.eql(bignum('1337').toString(), '1337');
		assert.eql(new bignum('100').toString(), '100');
		assert.eql(
		new bignum('55555555555555555555555555').toString(),
		'55555555555555555555555555'
		);

		assert.eql(Number(bignum('1e+100').toString()), 1e+100);
		assert.eql(bignum('1e+100').bitLength(), 333);
		assert.eql(Number(bignum('1.23e+45').toString()), 1.23e+45);
		for (var i = 0; i < 10; i++) {
		assert.eql(
		bignum('1.23456e+' + i).toString(),
		Math.floor(1.23456 * Math.pow(10,i))
		);
		}

		assert.eql(bignum('1.23e-45').toString(), '0');
		test('create', function (t) {
		t.deepEqual(BigNum(1337).toString(), '1337')
		t.deepEqual(BigNum('1337').toString(), '1337')
		t.deepEqual(new BigNum('100').toString(), '100')

		assert.throws(function() { bignum(undefined); });
		assert.throws(function() { bignum(null); });
		};
		t.deepEqual(
		new BigNum('55555555555555555555555555').toString(),
		'55555555555555555555555555'
		)

		exports.add = function () {
		for (var i = -10; i < 10; i++) {
		for (var j = -10; j < 10; j++) {
		var is = i.toString();
		var js = j.toString();
		var ks = (i + j).toString();
		assert.eql(bignum(i).add(j).toString(), ks);
		assert.eql(bignum(i).add(js).toString(), ks);
		assert.eql(bignum(i).add(bignum(j)).toString(), ks);
		assert.eql(bignum.add(i, j).toString(), ks);
		}
		}

		assert.eql(
		bignum(
		'201781752444966478956292456789265633588628356858680927185287861892'
		+ '9889675589272409635031813235465496971529430565627918846694860512'
		+ '1492948268400884893722767401972695174353441'
		).add(
		'939769862972759638577945343130228368606420083646071622223953046277'
		+ '3784500359975110887672142614667937014937371109558223563373329424'
		+ '0624814097369771481147215472578762824607080'
		).toString(),
		'1141551615417726117534237799919494002195048440504752549409240908170367'
		+ '41759492475205227039558501334339864668016751861424100681899362117762'
		+ '365770656374869982874551457998960521'
		);
		};
		t.deepEqual(Number(BigNum('1e+100').toString()), 1e+100)
		t.deepEqual(Number(BigNum('1e+100').bitLength()), 333)
		t.deepEqual(Number(BigNum('1.23e+45').toString()), 1.23e+45)

		exports.sub = function () {
		for (var i = -10; i < 10; i++) {
		for (var j = -10; j < 10; j++) {
		var is = i.toString();
		var js = j.toString();
		var ks = (i - j).toString();
		assert.eql(bignum(i).sub(j).toString(), ks);
		assert.eql(bignum(i).sub(js).toString(), ks);
		assert.eql(bignum(i).sub(bignum(j)).toString(), ks);
		assert.eql(bignum.sub(i, j).toString(), ks);
		}
		}

		assert.eql(
		bignum(
		'635849762218952604062459342660379446997761295162166888134051068531'
		+ '9813941775949841573516110003093332652267534768664621969514455380'
		+ '8051168706779408804756208386011014197185296'
		).sub(
		'757617343536280696839135295661092954931163607913400460585109207644'
		+ '7966483882748233585856350085641718822741649072106343655764769889'
		+ '6399869016678013515043471880323279258685478'
		).toString(),
		'-121767581317328092776675953000713507933402312751233572451058139112815'
		+ '25421067983920123402400825483861704741143034417216862503145088348700'
		+ '309898604710287263494312265061500182'
		);
		};
		for (var i = 0; i < 10; i++) {
		t.deepEqual(
		BigNum('1.23456e+' + i).toString(),
		Math.floor(1.23456 * Math.pow(10, i))
		)
		}

		exports.mul = function () {
		for (var i = -10; i < 10; i++) {
		for (var j = -10; j < 10; j++) {
		var is = i.toString();
		var js = j.toString();
		var ks = (i * j).toString();
		assert.eql(bignum(i).mul(j).toString(), ks);
		assert.eql(bignum(i).mul(js).toString(), ks);
		assert.eql(bignum(i).mul(bignum(j)).toString(), ks);
		assert.eql(bignum.mul(i, j).toString(), ks);
		}
		t.deepEqual(BigNum('1.23e-45').toString(), '0')

		t.throws(function () { BigNum(undefined) })
		t.throws(function () { BigNum(null) })

		t.end()
		})

		test('add', function (t) {
		for (var i = -10; i < 10; i++) {
		for (var j = -10; j < 10; j++) {
		var js = j.toString()
		var ks = (i + j).toString()
		t.deepEqual(BigNum(i).add(j).toString(), ks)
		t.deepEqual(BigNum(i).add(js).toString(), ks)
		t.deepEqual(BigNum(i).add(BigNum(j)).toString(), ks)
		t.deepEqual(BigNum.add(i, j).toString(), ks)
		}

		assert.eql(
		bignum(
		'433593290010590489671135819286259593426549306666324008679782084292'
		+ '2446494189019075159822930571858728009485237489829138626896756141'
		+ '8738958337632249177044975686477011571044266'
		).mul(
		'127790264841901718791915669264129510947625523373763053776083279450'
		+ '3886212911067061184379695097643279217271150419129022856601771338'
		+ '794256383410400076210073482253089544155377'
		).toString(),
		'5540900136412485758752141142221047463857522755277604708501015732755989'
		+ '17659432099233635577634197309727815375309484297883528869192732141328'
		+ '99346769031695550850320602049507618052164677667378189154076988316301'
		+ '23719953859959804490669091769150047414629675184805332001182298088891'
		+ '58079529848220802017396422115936618644438110463469902675126288489182'
		+ '82'
		);

		assert.eql(
		bignum('10000000000000000000000000000').mul(-123).toString(),
		'-1230000000000000000000000000000'
		);
		};
		}

		exports.div = function () {
		for (var i = -10; i < 10; i++) {
		for (var j = -10; j < 10; j++) {
		var is = i.toString();
		var js = j.toString();
		var round = ((i/j) < 0) ? Math.ceil : Math.floor;
		var ks = round(i / j).toString();
		if (ks.match(/^-?\d+$/)) { // ignore exceptions
		assert.eql(bignum(i).div(j).toString(), ks);
		assert.eql(bignum(i).div(js).toString(), ks);
		assert.eql(bignum(i).div(bignum(j)).toString(), ks);
		assert.eql(bignum.div(i, j).toString(), ks);
		}
		}
		t.deepEqual(
		BigNum(
		'201781752444966478956292456789265633588628356858680927185287861892' +
		'9889675589272409635031813235465496971529430565627918846694860512' +
		'1492948268400884893722767401972695174353441'
		).add(
		'939769862972759638577945343130228368606420083646071622223953046277' +
		'3784500359975110887672142614667937014937371109558223563373329424' +
		'0624814097369771481147215472578762824607080'
		).toString(),
		'1141551615417726117534237799919494002195048440504752549409240908170367' +
		'41759492475205227039558501334339864668016751861424100681899362117762' +
		'365770656374869982874551457998960521'
		)

		t.end()
		})

		test('sub', function (t) {
		for (var i = -10; i < 10; i++) {
		for (var j = -10; j < 10; j++) {
		var js = j.toString()
		var ks = (i - j).toString()
		t.deepEqual(BigNum(i).sub(j).toString(), ks)
		t.deepEqual(BigNum(i).sub(js).toString(), ks)
		t.deepEqual(BigNum(i).sub(BigNum(j)).toString(), ks)
		t.deepEqual(BigNum.sub(i, j).toString(), ks)
		}

		assert.eql(
		bignum(
		'433593290010590489671135819286259593426549306666324008679782084292'
		+ '2446494189019075159822930571858728009485237489829138626896756141'
		+ '8738958337632249177044975686477011571044266'
		).div(
		'127790264841901718791915669264129510947625523373763053776083279450'
		+ '3886212911067061184379695097643279217271150419129022856601771338'
		+ '794256383410400076210073482253089544155377'
		).toString(),
		'33'
		);
		};
		}

		exports.abs = function () {
		assert.eql(
		bignum(
		'433593290010590489671135819286259593426549306666324008679782084292'
		+ '2446494189019075159822930571858728009485237489829138626896756141'
		+ '8738958337632249177044975686477011571044266'
		).abs().toString(),
		'4335932900105904896711358192862595934265493066663240086797820842922446'
		+ '49418901907515982293057185872800948523748982913862689675614187389583'
		+ '37632249177044975686477011571044266'
		);

		assert.eql(
		bignum(
		'-43359329001059048967113581928625959342654930666632400867978208429'
		+ '2244649418901907515982293057185872800948523748982913862689675614'
		+ '18738958337632249177044975686477011571044266'
		).abs().toString(),
		'4335932900105904896711358192862595934265493066663240086797820842922446'
		+ '49418901907515982293057185872800948523748982913862689675614187389583'
		+ '37632249177044975686477011571044266'
		);
		};
		t.deepEqual(
		BigNum(
		'635849762218952604062459342660379446997761295162166888134051068531' +
		'9813941775949841573516110003093332652267534768664621969514455380' +
		'8051168706779408804756208386011014197185296'
		).sub(
		'757617343536280696839135295661092954931163607913400460585109207644' +
		'7966483882748233585856350085641718822741649072106343655764769889' +
		'6399869016678013515043471880323279258685478'
		).toString(),
		'-121767581317328092776675953000713507933402312751233572451058139112815' +
		'25421067983920123402400825483861704741143034417216862503145088348700' +
		'309898604710287263494312265061500182'
		)

		exports.neg = function () {
		assert.eql(
		bignum(
		'433593290010590489671135819286259593426549306666324008679782084292'
		+ '2446494189019075159822930571858728009485237489829138626896756141'
		+ '8738958337632249177044975686477011571044266'
		).neg().toString(),
		'-433593290010590489671135819286259593426549306666324008679782084292244'
		+ '64941890190751598229305718587280094852374898291386268967561418738958'
		+ '337632249177044975686477011571044266'
		);

		assert.eql(
		bignum(
		'-43359329001059048967113581928625959342654930666632400867978208429'
		+ '2244649418901907515982293057185872800948523748982913862689675614'
		+ '18738958337632249177044975686477011571044266'
		).neg().toString(),
		'4335932900105904896711358192862595934265493066663240086797820842922446'
		+ '49418901907515982293057185872800948523748982913862689675614187389583'
		+ '37632249177044975686477011571044266'
		);
		};
		t.end()
		})

		exports.mod = function () {
		for (var i = 0; i < 10; i++) {
		for (var j = 0; j < 10; j++) {
		var is = i.toString();
		var js = j.toString();
		if (!isNaN(i % j)) {
		var ks = (i % j).toString();
		assert.eql(bignum(i).mod(j).toString(), ks);
		assert.eql(bignum(i).mod(js).toString(), ks);
		assert.eql(bignum(i).mod(bignum(j)).toString(), ks);
		assert.eql(bignum.mod(i, j).toString(), ks);
		}
		}
		test('mul', function (t) {
		for (var i = -10; i < 10; i++) {
		for (var j = -10; j < 10; j++) {
		var js = j.toString()
		var ks = (i * j).toString()
		t.deepEqual(BigNum(i).mul(j).toString(), ks)
		t.deepEqual(BigNum(i).mul(js).toString(), ks)
		t.deepEqual(BigNum(i).mul(BigNum(j)).toString(), ks)
		t.deepEqual(BigNum.mul(i, j).toString(), ks)
		}

		assert.eql(
		bignum('486541542410442549118519277483401413')
		.mod('1802185856709793916115771381388554')
		.toString()
		,
		'1753546955507985683376775889880387'
		);
		};
		}

		exports.cmp = function () {
		for (var i = -10; i <= 10; i++) {
		var bi = bignum(i);

		for (var j = -10; j <= 10; j++) {
		[ j, bignum(j) ].forEach(function (jj) {
		assert.eql(bi.lt(jj), i < j);
		assert.eql(bi.le(jj), i <= j);
		assert.eql(bi.eq(jj), i === j);
		assert.eql(bi.ne(jj), i !== j);
		assert.eql(bi.gt(jj), i > j);
		assert.eql(bi.ge(jj), i >= j);
		});
		}
		t.deepEqual(
		BigNum(
		'433593290010590489671135819286259593426549306666324008679782084292' +
		'2446494189019075159822930571858728009485237489829138626896756141' +
		'8738958337632249177044975686477011571044266'
		).mul(
		'127790264841901718791915669264129510947625523373763053776083279450' +
		'3886212911067061184379695097643279217271150419129022856601771338' +
		'794256383410400076210073482253089544155377'
		).toString(),
		'5540900136412485758752141142221047463857522755277604708501015732755989' +
		'17659432099233635577634197309727815375309484297883528869192732141328' +
		'99346769031695550850320602049507618052164677667378189154076988316301' +
		'23719953859959804490669091769150047414629675184805332001182298088891' +
		'58079529848220802017396422115936618644438110463469902675126288489182' +
		'82'
		)

		t.deepEqual(
		BigNum('10000000000000000000000000000').mul(-123).toString(),
		'-1230000000000000000000000000000'
		)

		t.end()
		})

		test('div', function (t) {
		for (var i = -10; i < 10; i++) {
		for (var j = -10; j < 10; j++) {
		var js = j.toString()
		var round = ((i / j) < 0) ? Math.ceil : Math.floor
		var ks = round(i / j).toString()
		if (ks.match(/^-?\d+$/)) { // ignore exceptions
		t.deepEqual(BigNum(i).div(j).toString(), ks)
		t.deepEqual(BigNum(i).div(js).toString(), ks)
		t.deepEqual(BigNum(i).div(BigNum(j)).toString(), ks)
		t.deepEqual(BigNum.div(i, j).toString(), ks)
		}
		}
		};
		}

		exports.powm = function () {
		var twos = [ 2, '2', bignum(2), bignum('2') ]
		var tens = [ 100000, '100000', bignum(100000), bignum(100000) ];
		twos.forEach(function (two) {
		tens.forEach(function (t) {
		assert.eql(
		bignum('111111111').powm(two, t).toString(),
		'54321'
		);
		});
		});

		assert.eql(
		bignum('624387628734576238746587435')
		.powm(2732, '457676874367586')
		.toString()
		,
		'335581885073251'
		);
		};
		t.deepEqual(
		BigNum(
		'433593290010590489671135819286259593426549306666324008679782084292' +
		'2446494189019075159822930571858728009485237489829138626896756141' +
		'8738958337632249177044975686477011571044266'
		).div(
		'127790264841901718791915669264129510947625523373763053776083279450' +
		'3886212911067061184379695097643279217271150419129022856601771338' +
		'794256383410400076210073482253089544155377'
		).toString(),
		'33'
		)

		exports.pow = function () {
		[ 2, '2', bignum(2), bignum('2') ].forEach(function (two) {
		assert.eql(
		bignum('111111111').pow(two).toString(),
		'12345678987654321'
		);
		});

		assert.eql(
		bignum('3487438743234789234879').pow(22).toString(),
		'861281136448465709000943928980299119292959327175552412961995332536782980636409994680542395362634321718164701236369695670918217801815161694902810780084448291245512671429670376051205638247649202527956041058237646154753587769450973231275642223337064356190945030999709422512682440247294915605076918925272414789710234097768366414400280590151549041536921814066973515842848197905763447515344747881160891303219471850554054186959791307149715821010152303317328860351766337716947079041'
		);
		};
		t.end()
		})

		exports.and = function () {
		for (var i = 0; i < 256; i += 7) {
		for (var j = 0; j < 256; j += 7) {
		var is = i.toString();
		var js = j.toString();
		var ks = (i & j).toString();
		assert.eql(bignum(i).and(j).toString(), ks);
		assert.eql(bignum(i).and(js).toString(), ks);
		assert.eql(bignum(i).and(bignum(j)).toString(), ks);
		assert.eql(bignum.and(i, j).toString(), ks);
		test('abs', function (t) {
		t.deepEqual(
		BigNum(
		'433593290010590489671135819286259593426549306666324008679782084292' +
		'2446494189019075159822930571858728009485237489829138626896756141' +
		'8738958337632249177044975686477011571044266'
		).abs().toString(),
		'4335932900105904896711358192862595934265493066663240086797820842922446' +
		'49418901907515982293057185872800948523748982913862689675614187389583' +
		'37632249177044975686477011571044266'
		)

		assert.eql(bignum(-1 * i).and(j).toString(), (-1 * i) & j);
		assert.eql(bignum(i).and(-1 * j).toString(), i & (-1 * j));
		assert.eql(bignum(-1 * i).and(-1 * j).toString(), (-1 * i) & (-1 * j));
		}
		t.deepEqual(
		BigNum(
		'-43359329001059048967113581928625959342654930666632400867978208429' +
		'2244649418901907515982293057185872800948523748982913862689675614' +
		'18738958337632249177044975686477011571044266'
		).abs().toString(),
		'4335932900105904896711358192862595934265493066663240086797820842922446' +
		'49418901907515982293057185872800948523748982913862689675614187389583' +
		'37632249177044975686477011571044266'
		)

		t.end()
		})

		test('neg', function (t) {
		t.deepEqual(
		BigNum(
		'433593290010590489671135819286259593426549306666324008679782084292' +
		'2446494189019075159822930571858728009485237489829138626896756141' +
		'8738958337632249177044975686477011571044266'
		).neg().toString(),
		'-433593290010590489671135819286259593426549306666324008679782084292244' +
		'64941890190751598229305718587280094852374898291386268967561418738958' +
		'337632249177044975686477011571044266'
		)

		t.deepEqual(
		BigNum(
		'-43359329001059048967113581928625959342654930666632400867978208429' +
		'2244649418901907515982293057185872800948523748982913862689675614' +
		'18738958337632249177044975686477011571044266'
		).neg().toString(),
		'4335932900105904896711358192862595934265493066663240086797820842922446' +
		'49418901907515982293057185872800948523748982913862689675614187389583' +
		'37632249177044975686477011571044266'
		)

		t.end()
		})

		test('mod', function (t) {
		for (var i = 0; i < 10; i++) {
		for (var j = 0; j < 10; j++) {
		var js = j.toString()
		if (!isNaN(i % j)) {
		var ks = (i % j).toString()
		t.deepEqual(BigNum(i).mod(j).toString(), ks)
		t.deepEqual(BigNum(i).mod(js).toString(), ks)
		t.deepEqual(BigNum(i).mod(BigNum(j)).toString(), ks)
		t.deepEqual(BigNum.mod(i, j).toString(), ks)
		}
		}
		assert.eql(bignum.and(bignum('111111', 16), bignum('111111', 16)).toString(16), '111111');
		assert.eql(bignum.and(bignum('111110', 16), bignum('111111', 16)).toString(16), '111110');
		assert.eql(bignum.and(bignum('111112', 16), bignum('111111', 16)).toString(16), '111110');
		assert.eql(bignum.and(bignum('111121', 16), bignum('111111', 16)).toString(16), '111101');
		assert.eql(bignum.and(bignum('111131', 16), bignum('111111', 16)).toString(16), '111111');
		}

		assert.eql(bignum.and(bignum('-111111', 16), bignum('111111', 16)).toString(16), '01');
		assert.eql(bignum.and(bignum('111111', 16), bignum('-111111', 16)).toString(16), '01');
		assert.eql(bignum.and(bignum('-111111', 16), bignum('-111111', 16)).toString(16), '-111111');
		};
		t.deepEqual(
		BigNum('486541542410442549118519277483401413')
		.mod('1802185856709793916115771381388554')
		.toString()
		, '1753546955507985683376775889880387'
		)

		exports.or = function () {
		for (var i = 0; i < 256; i += 7) {
		for (var j = 0; j < 256; j += 7) {
		var is = i.toString();
		var js = j.toString();
		var ks = (i \| j).toString();
		assert.eql(bignum(i).or(j).toString(), ks);
		assert.eql(bignum(i).or(js).toString(), ks);
		assert.eql(bignum(i).or(bignum(j)).toString(), ks);
		assert.eql(bignum.or(i, j).toString(), ks);
		t.end()
		})

		assert.eql(bignum(-1 * i).or(j).toString(), (-1 * i) \| j);
		assert.eql(bignum(i).or(-1 * j).toString(), i \| (-1 * j));
		assert.eql(bignum(-1 * i).or(-1 * j).toString(), (-1 * i) \| (-1 * j));
		}
		test('cmp', function (t) {
		for (var i = -10; i <= 10; i++) {
		var bi = BigNum(i)

		for (var j = -10; j <= 10; j++) {
		[ j, BigNum(j) ].forEach(function (jj) {
		t.deepEqual(bi.lt(jj), i < j)
		t.deepEqual(bi.le(jj), i <= j)
		t.deepEqual(bi.eq(jj), i === j)
		t.deepEqual(bi.ne(jj), i !== j)
		t.deepEqual(bi.gt(jj), i > j)
		t.deepEqual(bi.ge(jj), i >= j)
		})
		}
		assert.eql(bignum.or(bignum('111111', 16), bignum('111111', 16)).toString(16), '111111');
		assert.eql(bignum.or(bignum('111110', 16), bignum('111111', 16)).toString(16), '111111');
		assert.eql(bignum.or(bignum('111112', 16), bignum('111111', 16)).toString(16), '111113');
		assert.eql(bignum.or(bignum('111121', 16), bignum('111111', 16)).toString(16), '111131');
		}

		assert.eql(bignum.or(bignum('-111111', 16), bignum('111111', 16)).toString(16), '-01');
		assert.eql(bignum.or(bignum('111111', 16), bignum('-111111', 16)).toString(16), '-01');
		assert.eql(bignum.or(bignum('-111111', 16), bignum('-111111', 16)).toString(16), '-111111');
		};
		t.end()
		})

		exports.xor = function () {
		for (var i = 0; i < 256; i += 7) {
		for (var j = 0; j < 256; j += 7) {
		var is = i.toString();
		var js = j.toString();
		var ks = (i ^ j).toString();
		assert.eql(bignum(i).xor(j).toString(), ks);
		assert.eql(bignum(i).xor(js).toString(), ks);
		assert.eql(bignum(i).xor(bignum(j)).toString(), ks);
		assert.eql(bignum.xor(i, j).toString(), ks);
		test('powm', function (t) {
		var twos = [ 2, '2', BigNum(2), BigNum('2') ]
		var tens = [ 100000, '100000', BigNum(100000), BigNum(100000) ]
		twos.forEach(function (two) {
		tens.forEach(function (ten) {
		t.deepEqual(
		BigNum('111111111').powm(two, ten).toString(),
		'54321'
		)
		})
		})

		assert.eql(bignum(-1 * i).xor(j).toString(), (-1 * i) ^ j);
		assert.eql(bignum(i).xor(-1 * j).toString(), i ^ (-1 * j));
		assert.eql(bignum(-1 * i).xor(-1 * j).toString(), (-1 * i) ^ (-1 * j));
		}
		t.deepEqual(
		BigNum('624387628734576238746587435')
		.powm(2732, '457676874367586')
		.toString()
		, '335581885073251'
		)

		t.end()
		})

		test('pow', function (t) {
		[ 2, '2', BigNum(2), BigNum('2') ].forEach(function (two) {
		t.deepEqual(
		BigNum('111111111').pow(two).toString(),
		'12345678987654321'
		)
		})

		t.deepEqual(
		BigNum('3487438743234789234879').pow(22).toString(),
		'861281136448465709000943928980299119292959327175552412961995332536782980636409994680542395362634321718164701236369695670918217801815161694902810780084448291245512671429670376051205638247649202527956041058237646154753587769450973231275642223337064356190945030999709422512682440247294915605076918925272414789710234097768366414400280590151549041536921814066973515842848197905763447515344747881160891303219471850554054186959791307149715821010152303317328860351766337716947079041'
		)

		t.end()
		})

		test('and', function (t) {
		for (var i = 0; i < 256; i += 7) {
		for (var j = 0; j < 256; j += 7) {
		var js = j.toString()
		var ks = (i & j).toString()
		t.deepEqual(BigNum(i).and(j).toString(), ks)
		t.deepEqual(BigNum(i).and(js).toString(), ks)
		t.deepEqual(BigNum(i).and(BigNum(j)).toString(), ks)
		t.deepEqual(BigNum.and(i, j).toString(), ks)

		t.deepEqual(BigNum(-1 * i).and(j).toString(), ((-1 * i) & j).toString())
		t.deepEqual(BigNum(i).and(-1 * j).toString(), (i & (-1 * j)).toString())
		t.deepEqual(BigNum(-1 * i).and(-1 * j).toString(), ((-1 * i) & (-1 * j)).toString())
		}
		assert.eql(bignum.xor(bignum('111111', 16), bignum('111111', 16)).toString(), 0);
		assert.eql(bignum.xor(bignum('111110', 16), bignum('111111', 16)).toString(), 1);
		assert.eql(bignum.xor(bignum('111112', 16), bignum('111111', 16)).toString(), 3);
		assert.eql(bignum.xor(bignum('111121', 16), bignum('111111', 16)).toString(), 0x30);
		}
		t.deepEqual(BigNum.and(BigNum('111111', 16), BigNum('111111', 16)).toString(16), '111111')
		t.deepEqual(BigNum.and(BigNum('111110', 16), BigNum('111111', 16)).toString(16), '111110')
		t.deepEqual(BigNum.and(BigNum('111112', 16), BigNum('111111', 16)).toString(16), '111110')
		t.deepEqual(BigNum.and(BigNum('111121', 16), BigNum('111111', 16)).toString(16), '111101')
		t.deepEqual(BigNum.and(BigNum('111131', 16), BigNum('111111', 16)).toString(16), '111111')

		assert.eql(bignum.xor(bignum('-111111', 16), bignum('111111', 16)).toString(), -2);
		assert.eql(bignum.xor(bignum('111111', 16), bignum('-111111', 16)).toString(), -2);
		assert.eql(bignum.xor(bignum('-111111', 16), bignum('-111111', 16)).toString(), 0);
		};
		t.deepEqual(BigNum.and(BigNum('-111111', 16), BigNum('111111', 16)).toString(16), '01')
		t.deepEqual(BigNum.and(BigNum('111111', 16), BigNum('-111111', 16)).toString(16), '01')
		t.deepEqual(BigNum.and(BigNum('-111111', 16), BigNum('-111111', 16)).toString(16), '-111111')

		exports.rand = function () {
		for (var i = 1; i < 1000; i++) {
		var x = bignum(i).rand().toNumber();
		assert.ok(0 <= x && x < i);

		var y = bignum(i).rand(i + 10).toNumber();
		assert.ok(i <= y && y < i + 10);

		var z = bignum.rand(i, i + 10).toNumber();
		assert.ok(i <= z && z < i + 10);
		t.end()
		})

		test('or', function (t) {
		for (var i = 0; i < 256; i += 7) {
		for (var j = 0; j < 256; j += 7) {
		var js = j.toString()
		var ks = (i \| j).toString()
		t.deepEqual(BigNum(i).or(j).toString(), ks)
		t.deepEqual(BigNum(i).or(js).toString(), ks)
		t.deepEqual(BigNum(i).or(BigNum(j)).toString(), ks)
		t.deepEqual(BigNum.or(i, j).toString(), ks)

		t.deepEqual(BigNum(-1 * i).or(j).toString(), ((-1 * i) \| j).toString())
		t.deepEqual(BigNum(i).or(-1 * j).toString(), (i \| (-1 * j)).toString())
		t.deepEqual(BigNum(-1 * i).or(-1 * j).toString(), ((-1 * i) \| (-1 * j)).toString())
		}
		};
		}
		t.deepEqual(BigNum.or(BigNum('111111', 16), BigNum('111111', 16)).toString(16), '111111')
		t.deepEqual(BigNum.or(BigNum('111110', 16), BigNum('111111', 16)).toString(16), '111111')
		t.deepEqual(BigNum.or(BigNum('111112', 16), BigNum('111111', 16)).toString(16), '111113')
		t.deepEqual(BigNum.or(BigNum('111121', 16), BigNum('111111', 16)).toString(16), '111131')

		exports.primes = function () {
		var ps = { 2 : true, 3 : true, 5 : true, 7 : true };
		for (var i = 0; i <= 10; i++) {
		assert.eql(bignum(i).probPrime(), ps[i] ? true : false);
		t.deepEqual(BigNum.or(BigNum('-111111', 16), BigNum('111111', 16)).toString(16), '-01')
		t.deepEqual(BigNum.or(BigNum('111111', 16), BigNum('-111111', 16)).toString(16), '-01')
		t.deepEqual(BigNum.or(BigNum('-111111', 16), BigNum('-111111', 16)).toString(16), '-111111')

		t.end()
		})

		test('xor', function (t) {
		for (var i = 0; i < 256; i += 7) {
		for (var j = 0; j < 256; j += 7) {
		var js = j.toString()
		var ks = (i ^ j).toString()
		t.deepEqual(BigNum(i).xor(j).toString(), ks)
		t.deepEqual(BigNum(i).xor(js).toString(), ks)
		t.deepEqual(BigNum(i).xor(BigNum(j)).toString(), ks)
		t.deepEqual(BigNum.xor(i, j).toString(), ks)

		t.deepEqual(BigNum(-1 * i).xor(j).toString(), ((-1 * i) ^ j).toString())
		t.deepEqual(BigNum(i).xor(-1 * j).toString(), (i ^ (-1 * j)).toString())
		t.deepEqual(BigNum(-1 * i).xor(-1 * j).toString(), ((-1 * i) ^ (-1 * j)).toString())
		}

		var ns = {
		2 : 3,
		3 : 5,
		15313 : 15319,
		222919 : 222931,
		611939 : 611951,
		334214459 : '334214467',
		961748927 : '961748941',
		9987704933 : '9987704953',
		};

		Object.keys(ns).forEach(function (n) {
		assert.eql(
		bignum(n).nextPrime().toString(),
		ns[n].toString()
		);
		});

		var uniques = [
		'3', '11', '37', '101', '9091', '9901', '333667', '909091', '99990001',
		'999999000001', '9999999900000001', '909090909090909091',
		'1111111111111111111', '11111111111111111111111',
		'900900900900990990990991',
		];

		var wagstaff = [
		'3', '11', '43', '683', '2731', '43691', '174763', '2796203',
		'715827883', '2932031007403', '768614336404564651',
		'201487636602438195784363', '845100400152152934331135470251',
		'56713727820156410577229101238628035243',
		];

		var big = [
		'4669523849932130508876392554713407521319117239637943224980015676156491',
		'54875133386847519273109693154204970395475080920935355580245252923343305939004903',
		'204005728266090048777253207241416669051476369216501266754813821619984472224780876488344279',
		'2074722246773485207821695222107608587480996474721117292752992589912196684750549658310084416732550077',
		'5628290459057877291809182450381238927697314822133923421169378062922140081498734424133112032854812293',
		];

		[ uniques, wagstaff, big ].forEach(function (xs) {
		xs.forEach(function (x) {
		var p = bignum(x).probPrime();
		assert.ok(p === true \|\| p === 'maybe');
		});
		});
		};
		}
		t.deepEqual(BigNum.xor(BigNum('111111', 16), BigNum('111111', 16)).toString(), 0)
		t.deepEqual(BigNum.xor(BigNum('111110', 16), BigNum('111111', 16)).toString(), 1)
		t.deepEqual(BigNum.xor(BigNum('111112', 16), BigNum('111111', 16)).toString(), 3)
		t.deepEqual(BigNum.xor(BigNum('111121', 16), BigNum('111111', 16)).toString(), 0x30)

		exports.isbitset = function () {
		function mkbin(bn) {
		var bin = '';
		t.deepEqual(BigNum.xor(BigNum('-111111', 16), BigNum('111111', 16)).toString(), -2)
		t.deepEqual(BigNum.xor(BigNum('111111', 16), BigNum('-111111', 16)).toString(), -2)
		t.deepEqual(BigNum.xor(BigNum('-111111', 16), BigNum('-111111', 16)).toString(), 0)

		for (var i = 0; i < bn.bitLength(); ++i) {
		bin += bn.isBitSet(i) ? '1' : '0';
		}
		t.end()
		})

		return bin;
		test('rand', function (t) {
		for (var i = 1; i < 1000; i++) {
		var x = BigNum(i).rand().toNumber()
		t.ok(x >= 0 && x < i)

		var y = BigNum(i).rand(i + 10).toNumber()
		t.ok(i <= y && y < i + 10)

		var z = BigNum.rand(i, i + 10).toNumber()
		t.ok(i <= z && z < i + 10)
		}

		t.end()
		})

		test('primes', function (t) {
		var ps = { 2: true, 3: true, 5: true, 7: true }
		for (var i = 0; i <= 10; i++) {
		t.deepEqual(BigNum(i).probPrime(), Boolean(ps[i]))
		}

		var ns = {
		2: 3,
		3: 5,
		15313: 15319,
		222919: 222931,
		611939: 611951,
		334214459: '334214467',
		961748927: '961748941',
		9987704933: '9987704953'
		}

		Object.keys(ns).forEach(function (n) {
		t.deepEqual(
		BigNum(n).nextPrime().toString(),
		ns[n].toString()
		)
		})

		var uniques = [
		'3', '11', '37', '101', '9091', '9901', '333667', '909091', '99990001',
		'999999000001', '9999999900000001', '909090909090909091',
		'1111111111111111111', '11111111111111111111111',
		'900900900900990990990991'
		]

		var wagstaff = [
		'3', '11', '43', '683', '2731', '43691', '174763', '2796203',
		'715827883', '2932031007403', '768614336404564651',
		'201487636602438195784363', '845100400152152934331135470251',
		'56713727820156410577229101238628035243'
		]

		var big = [
		'4669523849932130508876392554713407521319117239637943224980015676156491',
		'54875133386847519273109693154204970395475080920935355580245252923343305939004903',
		'204005728266090048777253207241416669051476369216501266754813821619984472224780876488344279',
		'2074722246773485207821695222107608587480996474721117292752992589912196684750549658310084416732550077',
		'5628290459057877291809182450381238927697314822133923421169378062922140081498734424133112032854812293'
		]

		;[ uniques, wagstaff, big ].forEach(function (xs) {
		xs.forEach(function (x) {
		var p = BigNum(x).probPrime()
		t.ok(p === true \|\| p === 'maybe')
		})
		})

		t.end()
		})

		test('isbitset', function (t) {
		function mkbin (bn) {
		var bin = ''

		for (var i = 0; i < bn.bitLength(); ++i) {
		bin += bn.isBitSet(i) ? '1' : '0'
		}

		assert.eql(mkbin(bignum( 127)), '1111111');
		assert.eql(mkbin(bignum(-127)), '1111111');
		return bin
		}

		assert.eql(mkbin(bignum( 128)), '00000001');
		assert.eql(mkbin(bignum(-128)), '00000001');
		t.deepEqual(mkbin(BigNum(127)), '1111111')
		t.deepEqual(mkbin(BigNum(-127)), '1111111')

		assert.eql(mkbin(bignum( 129)), '10000001');
		assert.eql(mkbin(bignum(-129)), '10000001');
		};
		t.deepEqual(mkbin(BigNum(128)), '00000001')
		t.deepEqual(mkbin(BigNum(-128)), '00000001')

		exports.invertm = function () {
		// numbers from http://www.itl.nist.gov/fipspubs/fip186.htm appendix 5
		var q = bignum('b20db0b101df0c6624fc1392ba55f77d577481e5', 16);
		var k = bignum('79577ddcaafddc038b865b19f8eb1ada8a2838c6', 16);
		var kinv = k.invertm(q);
		assert.eql(kinv.toString(16), '2784e3d672d972a74e22c67f4f4f726ecc751efa');
		};
		t.deepEqual(mkbin(BigNum(129)), '10000001')
		t.deepEqual(mkbin(BigNum(-129)), '10000001')

		exports.shift = function () {
		assert.eql(bignum(37).shiftLeft(2).toString(), (37 << 2).toString()); // 148
		assert.eql(bignum(37).shiftRight(2).toString(), (37 >> 2).toString()); // 9

		assert.equal(
		bignum(2).pow(Math.pow(2,10)).shiftRight(4).toString(),
		bignum(2).pow(Math.pow(2,10)).div(16).toString()
		);
		};
		t.end()
		})

		exports.mod = function () {
		assert.eql(bignum(55555).mod(2).toString(), '1');
		assert.eql(
		bignum('1234567').mod(
		bignum('4321')
		).toNumber(),
		1234567 % 4321
		);
		};
		test('invertm', function (t) {
		// numbers from http://www.itl.nist.gov/fipspubs/fip186.htm appendix 5
		var q = BigNum('b20db0b101df0c6624fc1392ba55f77d577481e5', 16)
		var k = BigNum('79577ddcaafddc038b865b19f8eb1ada8a2838c6', 16)
		var kinv = k.invertm(q)
		t.deepEqual(kinv.toString(16), '2784e3d672d972a74e22c67f4f4f726ecc751efa')

		exports.endian = function () {
		var a = bignum(0x0102030405);
		assert.eql(a.toBuffer({ endian: 'big', size: 2 }).toString('hex'), '000102030405');
		assert.eql(a.toBuffer({ endian: 'little', size: 2 }).toString('hex'), '010003020504');

		var b = bignum(0x0102030405);
		assert.eql(a.toBuffer({ endian: 'big', size: 'auto' }).toString('hex'), '0102030405');
		assert.eql(a.toBuffer({ endian: 'little', size: 'auto' }).toString('hex'), '0504030201');

		var c = new Buffer("000102030405", 'hex');
		assert.eql(bignum.fromBuffer(c, { endian: 'big', size: 'auto'}).toString(16), "0102030405");
		assert.eql(bignum.fromBuffer(c, { endian: 'little', size: 'auto'}).toString(16), "050403020100");
		};
		t.end()
		})

		exports.bitlength = function () {
		var bl = bignum(
		'433593290010590489671135819286259593426549306666324008679782084292'
		+ '2446494189019075159822930571858728009485237489829138626896756141'
		+ '873895833763224917704497568647701157104426'
		).bitLength();

		assert.equal(bl > 0, true);
		};
		test('shift', function (t) {
		t.deepEqual(BigNum(37).shiftLeft(2).toString(), (37 << 2).toString()) // 148
		t.deepEqual(BigNum(37).shiftRight(2).toString(), (37 >> 2).toString()) // 9

		exports.gcd = function () {
		var b1 = bignum('234897235923342343242');
		var b2 = bignum('234790237101762305340234');
		var expected = bignum('6');
		assert.equal(b1.gcd(b2).toString(), expected.toString());
		};
		t.equal(
		BigNum(2).pow(Math.pow(2, 10)).shiftRight(4).toString(),
		BigNum(2).pow(Math.pow(2, 10)).div(16).toString()
		)

		exports.jacobi = function () {
		// test case from p. 134 of D. R. Stinson
		var b1 = bignum('7411');
		var b2 = bignum('9283');
		assert.equal(b1.jacobi(b2), -1);
		t.end()
		})

		// test case from p. 132 of D. R. Stinson
		b1 = bignum('6278');
		b2 = bignum('9975');
		assert.equal(b1.jacobi(b2), -1);
		test('mod', function (t) {
		t.deepEqual(BigNum(55555).mod(2).toString(), '1')
		t.deepEqual(
		BigNum('1234567').mod(
		BigNum('4321')
		).toNumber(),
		1234567 % 4321
		)

		// test case from p. 74 of Men. Oorsh. Vans.
		b1 = bignum('158');
		b2 = bignum('235');
		assert.equal(b1.jacobi(b2), -1);
		t.end()
		})

		// test case from p. 216 of Kumanduri Romero
		b1 = bignum('4');
		b2 = bignum('7');
		assert.equal(b1.jacobi(b2), 1);
		test('endian', function (t) {
		var a = BigNum(0x0102030405)
		t.deepEqual(a.toBuffer({ endian: 'big', size: 2 }).toString('hex'), '000102030405')
		t.deepEqual(a.toBuffer({ endian: 'little', size: 2 }).toString('hex'), '010003020504')

		// test case from p. 363 of K. R. Rosen
		b1 = bignum('68');
		b2 = bignum('111');
		assert.equal(b1.jacobi(b2), 1);
		};
		var b = BigNum(0x0102030405)
		t.deepEqual(b.toBuffer({ endian: 'big', size: 'auto' }).toString('hex'), '0102030405')
		t.deepEqual(b.toBuffer({ endian: 'little', size: 'auto' }).toString('hex'), '0504030201')

		if (process.argv[1] === __filename) {
		assert.eql = assert.deepEqual;
		Object.keys(exports).forEach(function (ex) {
		exports[ex]();
		});
		var c = new Buffer('000102030405', 'hex')
		t.deepEqual(BigNum.fromBuffer(c, { endian: 'big', size: 'auto' }).toString(16), '0102030405')
		t.deepEqual(BigNum.fromBuffer(c, { endian: 'little', size: 'auto' }).toString(16), '050403020100')

		if ("function" === typeof gc) {
		gc();
		}
		}
		t.end()
		})

		test('bitlength', function (t) {
		var bl = BigNum(
		'433593290010590489671135819286259593426549306666324008679782084292' +
		'2446494189019075159822930571858728009485237489829138626896756141' +
		'873895833763224917704497568647701157104426'
		).bitLength()

		t.equal(bl > 0, true)

		t.end()
		})

		test('gcd', function (t) {
		var b1 = BigNum('234897235923342343242')
		var b2 = BigNum('234790237101762305340234')
		var expected = BigNum('6')
		t.equal(b1.gcd(b2).toString(), expected.toString())

		t.end()
		})

		test('jacobi', function (t) {
		// test case from p. 134 of D. R. Stinson
		var b1 = BigNum('7411')
		var b2 = BigNum('9283')
		t.equal(b1.jacobi(b2), -1)

		// test case from p. 132 of D. R. Stinson
		b1 = BigNum('6278')
		b2 = BigNum('9975')
		t.equal(b1.jacobi(b2), -1)

		// test case from p. 74 of Men. Oorsh. Vans.
		b1 = BigNum('158')
		b2 = BigNum('235')
		t.equal(b1.jacobi(b2), -1)

		// test case from p. 216 of Kumanduri Romero
		b1 = BigNum('4')
		b2 = BigNum('7')
		t.equal(b1.jacobi(b2), 1)

		// test case from p. 363 of K. R. Rosen
		b1 = BigNum('68')
		b2 = BigNum('111')
		t.equal(b1.jacobi(b2), 1)

		t.end()
		})

370

test/buf.js

		@@ -1,196 +0,194 @@
		var assert = require('assert');
		var bignum = require('../');
		var put = require('put');
		var BigNum = require('../')
		var put = require('put')
		var test = require('tap').test

		exports.buf_be = function () {
		var buf1 = new Buffer([1,2,3,4]);
		var num = bignum.fromBuffer(buf1, { size : 4 }).toNumber();
		assert.eql(
		num,
		1*Math.pow(256, 3)
		+ 2 * Math.pow(256, 2)
		+ 3 * 256
		+ 4
		);

		var buf2 = put().word32be(num).buffer();
		assert.eql(buf1, buf2,
		'[ ' + [].slice.call(buf1) + ' ] != [ ' + [].slice.call(buf2) + ' ]'
		);
		};
		test('bufBe', function (t) {
		var buf1 = new Buffer([1, 2, 3, 4])
		var num = BigNum.fromBuffer(buf1, { size: 4 }).toNumber()
		t.deepEqual(
		num,
		1 * Math.pow(256, 3) +
		2 * Math.pow(256, 2) +
		3 * 256 +
		4
		)

		exports.buf_le = function () {
		var buf1 = new Buffer([1,2,3,4]);
		var num = bignum
		.fromBuffer(buf1, { size : 4, endian : 'little' })
		.toNumber()
		;
		var buf2 = put().word32le(num).buffer();
		assert.eql(buf1, buf2,
		'[ ' + [].join.call(buf1, ',')
		+ ' ] != [ '
		+ [].join.call(buf2, ',') + ' ]'
		);
		};
		var buf2 = put().word32be(num).buffer()
		t.deepEqual(buf1, buf2,
		'[ ' + [].slice.call(buf1) + ' ] != [ ' + [].slice.call(buf2) + ' ]'
		)

		exports.buf_be_le = function () {
		var buf_be = new Buffer([1,2,3,4,5,6,7,8]);
		var buf_le = new Buffer([4,3,2,1,8,7,6,5]);

		var num_be = bignum
		.fromBuffer(buf_be, { size : 4, endian : 'big' })
		.toString()
		;
		var num_le = bignum
		.fromBuffer(buf_le, { size : 4, endian : 'little' })
		.toString()
		;

		assert.eql(num_be, num_le);
		};
		t.end()
		})

		exports.buf_high_bits = function () {
		var buf_be = new Buffer([
		201,202,203,204,
		205,206,207,208
		]);
		var buf_le = new Buffer([
		204,203,202,201,
		208,207,206,205
		]);

		var num_be = bignum
		.fromBuffer(buf_be, { size : 4, endian : 'big' })
		.toString()
		;
		var num_le = bignum
		.fromBuffer(buf_le, { size : 4, endian : 'little' })
		.toString()
		;

		assert.eql(num_be, num_le);
		};
		test('bufLe', function (t) {
		var buf1 = new Buffer([1, 2, 3, 4])
		var num = BigNum
		.fromBuffer(buf1, { size: 4, endian: 'little' })
		.toNumber()

		exports.buf_to_from = function () {
		var nums = [
		0, 1, 10, 15, 3, 16,
		7238, 1337, 31337, 505050,
		'172389721984375328763297498273498732984324',
		'32848432742',
		'12988282841231897498217398217398127983721983719283721',
		'718293798217398217312387213972198321'
		];

		nums.forEach(function (num) {
		var b = bignum(num);
		var u = b.toBuffer();

		assert.ok(u);
		assert.eql(
		bignum.fromBuffer(u).toString(),
		b.toString()
		);
		});

		assert.throws(function () {
		bignum(-1).toBuffer(); // can't pack negative numbers yet
		});
		};
		var buf2 = put().word32le(num).buffer()
		t.deepEqual(buf1, buf2,
		'[ ' + [].join.call(buf1, ',') + ' ] != [ ' + [].join.call(buf2, ',') + ' ]'
		)

		exports.toBuf = function () {
		var buf = new Buffer([ 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f ]);
		var b = bignum(
		0x0a * 256256256256256
		+ 0x0b * 256256256*256
		+ 0x0c * 256256256
		+ 0x0d * 256*256
		+ 0x0e * 256
		+ 0x0f
		);

		assert.eql(b.toString(16), '0a0b0c0d0e0f');

		assert.eql(
		[].slice.call(b.toBuffer({ endian : 'big', size : 2 })),
		[ 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f ]
		);

		assert.eql(
		[].slice.call(b.toBuffer({ endian : 'little', size : 2 })),
		[ 0x0b, 0x0a, 0x0d, 0x0c, 0x0f, 0x0e ]
		);

		assert.eql(
		bignum.fromBuffer(buf).toString(16),
		b.toString(16)
		);

		assert.eql(
		[].slice.call(bignum(43135012110).toBuffer({
		endian : 'little', size : 4
		})),
		[ 0x0a, 0x00, 0x00, 0x00, 0x0e, 0x0d, 0x0c, 0x0b ]
		);

		assert.eql(
		[].slice.call(bignum(43135012110).toBuffer({
		endian : 'big', size : 4
		})),
		[ 0x00, 0x00, 0x00, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e ]
		);
		};
		t.end()
		})

		exports.zeroPad = function () {
		var b = bignum(0x123456);

		assert.eql(
		[].slice.call(b.toBuffer({ endian : 'big', size:4 })),
		[ 0x00, 0x12, 0x34, 0x56 ]
		);

		assert.eql(
		[].slice.call(b.toBuffer({ endian : 'little', size:4 })),
		[ 0x56, 0x34, 0x12, 0x00 ]
		);
		};
		test('bufBe_le', function (t) {
		var bufBe = new Buffer([1, 2, 3, 4, 5, 6, 7, 8])
		var bufLe = new Buffer([4, 3, 2, 1, 8, 7, 6, 5])

		exports.toMpint = function () {
		// test values taken directly out of
		// http://tools.ietf.org/html/rfc4251#page-10

		var refs = {
		'0' : new Buffer([ 0x00, 0x00, 0x00, 0x00 ]),
		'9a378f9b2e332a7' : new Buffer([
		0x00, 0x00, 0x00, 0x08,
		0x09, 0xa3, 0x78, 0xf9,
		0xb2, 0xe3, 0x32, 0xa7,
		]),
		'80' : new Buffer([ 0x00, 0x00, 0x00, 0x02, 0x00, 0x80 ]),
		'-1234' : new Buffer([ 0x00, 0x00, 0x00, 0x02, 0xed, 0xcc ]),
		'-deadbeef' : new Buffer([
		0x00, 0x00, 0x00, 0x05, 0xff, 0x21, 0x52, 0x41, 0x11
		]),
		};

		Object.keys(refs).forEach(function (key) {
		var buf0 = bignum(key, 16).toBuffer('mpint');
		var buf1 = refs[key];

		assert.eql(
		buf0, buf1,
		buf0.inspect() + ' != ' + buf1.inspect()
		+ ' for bignum(' + key + ')'
		);
		});
		};
		var numBe = BigNum
		.fromBuffer(bufBe, { size: 4, endian: 'big' })
		.toString()

		if (process.argv[1] === __filename) {
		assert.eql = assert.deepEqual;
		Object.keys(exports).forEach(function (ex) {
		exports[ex]();
		});
		var numLe = BigNum
		.fromBuffer(bufLe, { size: 4, endian: 'little' })
		.toString()

		if ("function" === typeof gc) {
		gc();
		}
		}
		t.deepEqual(numBe, numLe)

		t.end()
		})

		test('buf_high_bits', function (t) {
		var bufBe = new Buffer([
		201, 202, 203, 204,
		205, 206, 207, 208
		])
		var bufLe = new Buffer([
		204, 203, 202, 201,
		208, 207, 206, 205
		])

		var numBe = BigNum
		.fromBuffer(bufBe, { size: 4, endian: 'big' })
		.toString()

		var numLe = BigNum
		.fromBuffer(bufLe, { size: 4, endian: 'little' })
		.toString()

		t.deepEqual(numBe, numLe)

		t.end()
		})

		test('buf_to_from', function (t) {
		var nums = [
		0, 1, 10, 15, 3, 16,
		7238, 1337, 31337, 505050,
		'172389721984375328763297498273498732984324',
		'32848432742',
		'12988282841231897498217398217398127983721983719283721',
		'718293798217398217312387213972198321'
		]

		nums.forEach(function (num) {
		var b = BigNum(num)
		var u = b.toBuffer()

		t.ok(u)
		t.deepEqual(
		BigNum.fromBuffer(u).toString(),
		b.toString()
		)
		})

		t.throws(function () {
		BigNum(-1).toBuffer() // can't pack negative numbers yet
		})

		t.end()
		})

		test('toBuf', function (t) {
		var buf = new Buffer([ 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f ])
		var b = BigNum(
		0x0a * 256 * 256 * 256 * 256 * 256 +
		0x0b * 256 * 256 * 256 * 256 +
		0x0c * 256 * 256 * 256 +
		0x0d * 256 * 256 +
		0x0e * 256 +
		0x0f
		)

		t.deepEqual(b.toString(16), '0a0b0c0d0e0f')

		t.deepEqual(
		[].slice.call(b.toBuffer({ endian: 'big', size: 2 })),
		[ 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f ]
		)

		t.deepEqual(
		[].slice.call(b.toBuffer({ endian: 'little', size: 2 })),
		[ 0x0b, 0x0a, 0x0d, 0x0c, 0x0f, 0x0e ]
		)

		t.deepEqual(
		BigNum.fromBuffer(buf).toString(16),
		b.toString(16)
		)

		t.deepEqual(
		[].slice.call(BigNum(43135012110).toBuffer({
		endian: 'little', size: 4
		})),
		[ 0x0a, 0x00, 0x00, 0x00, 0x0e, 0x0d, 0x0c, 0x0b ]
		)

		t.deepEqual(
		[].slice.call(BigNum(43135012110).toBuffer({
		endian: 'big', size: 4
		})),
		[ 0x00, 0x00, 0x00, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e ]
		)

		t.end()
		})

		test('zeroPad', function (t) {
		var b = BigNum(0x123456)

		t.deepEqual(
		[].slice.call(b.toBuffer({ endian: 'big', size: 4 })),
		[ 0x00, 0x12, 0x34, 0x56 ]
		)

		t.deepEqual(
		[].slice.call(b.toBuffer({ endian: 'little', size: 4 })),
		[ 0x56, 0x34, 0x12, 0x00 ]
		)

		t.end()
		})

		test('toMpint', function (t) {
		// test values taken directly out of
		// http://tools.ietf.org/html/rfc4251#page-10

		var refs = {
		'0': new Buffer([ 0x00, 0x00, 0x00, 0x00 ]),
		'9a378f9b2e332a7': new Buffer([
		0x00, 0x00, 0x00, 0x08,
		0x09, 0xa3, 0x78, 0xf9,
		0xb2, 0xe3, 0x32, 0xa7
		]),
		'80': new Buffer([ 0x00, 0x00, 0x00, 0x02, 0x00, 0x80 ]),
		'-1234': new Buffer([ 0x00, 0x00, 0x00, 0x02, 0xed, 0xcc ]),
		'-deadbeef': new Buffer([ 0x00, 0x00, 0x00, 0x05, 0xff, 0x21, 0x52, 0x41, 0x11 ])
		}

		Object.keys(refs).forEach(function (key) {
		var buf0 = BigNum(key, 16).toBuffer('mpint')
		var buf1 = refs[key]

		t.deepEqual(
		buf0, buf1,
		buf0.inspect() + ' != ' + buf1.inspect() + ' for BigNum(' + key + ')'
		)
		})

		t.end()
		})

test/gh52.js

		@@ -1,20 +0,22 @@
		var assert = require('assert'),
		BigNum = require('../');
		var BigNum = require('../')
		var test = require('tap').test

		exports.github52 = function () {
		// verify that numbers aren't truncated to 32 bits when running on
		// 32-bit platforms (where the OpenSSL sizeof(BN_ULONG) is 32 bits)
		var num = new BigNum(0x100000000);
		assert.equal(num, '4294967296');
		assert.equal(num.add(0x100000000), '8589934592');
		assert.equal(num.sub(0x100000001), '-1');
		assert.equal(num.mul(0x100000000), '18446744073709551616');
		assert.equal(num.div(0x100000002), '0');
		assert.equal(num.mod(0x100000002), '4294967296');
		num = new BigNum(2);
		assert.equal(num.powm(0x100000001, 4), '0');
		num = new BigNum(-0x100000000);
		assert(num.cmp(-0x100000000) === 0);
		num = new BigNum(0x100000000);
		assert(num.cmp(0x100000000) === 0);
		};
		test('github52', function (t) {
		// verify that numbers aren't truncated to 32 bits when running on
		// 32-bit platforms (where the OpenSSL sizeof(BN_ULONG) is 32 bits)
		var num = new BigNum(0x100000000)
		t.equal(num.toString(), '4294967296')
		t.equal(num.add(0x100000000).toString(), '8589934592')
		t.equal(num.sub(0x100000001).toString(), '-1')
		t.equal(num.mul(0x100000000).toString().toString(), '18446744073709551616')
		t.equal(num.div(0x100000002).toString(), '0')
		t.equal(num.mod(0x100000002).toString(), '4294967296')
		num = new BigNum(2)
		t.equal(num.powm(0x100000001, 4).toString(), '0')
		num = new BigNum(-0x100000000)
		t.ok(num.cmp(-0x100000000) === 0)
		num = new BigNum(0x100000000)
		t.ok(num.cmp(0x100000000) === 0)

		t.end()
		})

test/isbignum.js

		@@ -1,47 +0,37 @@
		var assert = require('assert');
		var BigNum = require('../');
		var BigNum = require('../')
		var test = require('tap').test

		exports.create = function () {
		test('create', function (t) {
		var validBn = BigNum('42')
		var testObj

		var validBn = BigNum('42');
		var testObj;
		testObj = BigNum('123')
		t.equal(BigNum.isBigNum(testObj), true)

		testObj = BigNum('123');
		assert.equal(BigNum.isBigNum(testObj), true);
		testObj = {}
		t.equal(BigNum.isBigNum(testObj), false)

		testObj = {};
		assert.equal(BigNum.isBigNum(testObj), false);
		testObj = {}
		t.throws(function () {
		validBn.add(testObj)
		})

		testObj = {};
		assert.throws(function() {
		validBn.add(testObj)
		});
		testObj = falsePositive()
		t.equal(BigNum.isBigNum(testObj), true)

		testObj = falsePositive();
		assert.equal(BigNum.isBigNum(testObj), true);
		// this causes a hard crash, so its disabled for now
		// testObj = falsePositive()
		// t.throws(function() {
		// validBn.add(testObj)
		// })

		// this causes a hard crash, so its disabled for now
		// testObj = falsePositive();
		// assert.throws(function() {
		// validBn.add(testObj)
		// });
		};
		t.end()
		})

		function falsePositive () {
		var obj = {};
		for (var key in BigNum.prototype) {
		obj[key] = true;
		}
		return obj;
		var obj = {}
		for (var key in BigNum.prototype) {
		obj[key] = true
		}
		return obj
		}

		if (process.argv[1] === __filename) {
		assert.eql = assert.deepEqual;
		Object.keys(exports).forEach(function (ex) {
		exports[ex]();
		});

		if ("function" === typeof gc) {
		gc();
		}
		}

test/seed.js

		@@ -1,51 +0,40 @@
		var assert = require('assert');
		var exec = require('child_process').exec;
		var exec = require('child_process').exec
		var test = require('tap').test

		exports.rand = function () {
		var to = setTimeout(function () {
		assert.fail('never executed');
		}, 5000);

		var cmd = 'node -e \'console.log(require('
		+ JSON.stringify(__dirname + '/../')
		+ ').rand(1000).toString())\''
		;
		exec(cmd, function (err1, r1) {
		exec(cmd, function (err2, r2) {
		clearTimeout(to);

		assert.ok(!err1);
		assert.ok(!err2);

		assert.ok(
		r1.match(/^\d+\n/),
		JSON.stringify(r1) + ' is not an integer'
		);
		assert.ok(
		r2.match(/^\d+\n/),
		JSON.stringify(r2) + ' is not an integer'
		);

		var n1 = parseInt(r1.split('\n')[0], 10);
		var n2 = parseInt(r2.split('\n')[0], 10);

		assert.ok(n1 >= 0, 'n1 >= 0');
		assert.ok(n2 >= 0, 'n2 >= 0');
		assert.ok(n1 < 1000, 'n1 < 1000');
		assert.ok(n2 < 1000, 'n2 < 1000');

		assert.ok(n1 != n2, 'n1 != n2');
		})
		});
		}
		test('rand', function (t) {
		var to = setTimeout(function () {
		t.fail('never executed')
		}, 5000)

		if (process.argv[1] === __filename) {
		assert.eql = assert.deepEqual;
		Object.keys(exports).forEach(function (ex) {
		exports[ex]();
		});
		var cmd = 'node -e \'console.log(require("../").rand(1000).toString())\''

		if ("function" === typeof gc) {
		gc();
		}
		}
		exec(cmd, { cwd: __dirname }, function (err1, r1) {
		exec(cmd, { cwd: __dirname }, function (err2, r2) {
		clearTimeout(to)

		t.ok(!err1)
		t.ok(!err2)

		t.ok(
		r1.match(/^\d+\n/),
		JSON.stringify(r1) + ' is not an integer'
		)
		t.ok(
		r2.match(/^\d+\n/),
		JSON.stringify(r2) + ' is not an integer'
		)

		var n1 = parseInt(r1.split('\n')[0], 10)
		var n2 = parseInt(r2.split('\n')[0], 10)

		t.ok(n1 >= 0, 'n1 >= 0')
		t.ok(n2 >= 0, 'n2 >= 0')
		t.ok(n1 < 1000, 'n1 < 1000')
		t.ok(n2 < 1000, 'n2 < 1000')

		t.ok(n1 !== n2, 'n1 != n2')

		t.end()
		})
		})
		})

test/wincrash.js

		@@ -1,7 +0,9 @@
		var assert = require('assert'),
		BigNum = require('../');
		var BigNum = require('../')
		var test = require('tap').test

		exports.windowsCrash = function () {
		var num = new BigNum(1234);
		assert.equal(num.toString(), '1234')
		}
		test('windowsCrash', function (t) {
		var num = new BigNum(1234)
		t.equal(num.toString(), '1234')

		t.end()
		})

.travis.yml

Sorry, the diff of this file is not supported yet

binding.gyp

Sorry, the diff of this file is not supported yet

bignum - npm Package Compare versions

New alerts

Fixed alerts

Improved metrics

Worsened metrics

Dependency changes