diff options
Diffstat (limited to 'school/node_modules/cuint/lib/uint64.js')
| -rw-r--r-- | school/node_modules/cuint/lib/uint64.js | 648 |
1 files changed, 0 insertions, 648 deletions
diff --git a/school/node_modules/cuint/lib/uint64.js b/school/node_modules/cuint/lib/uint64.js deleted file mode 100644 index bb90522..0000000 --- a/school/node_modules/cuint/lib/uint64.js +++ /dev/null @@ -1,648 +0,0 @@ -/** - C-like unsigned 64 bits integers in Javascript - Copyright (C) 2013, Pierre Curto - MIT license - */ -;(function (root) { - - // Local cache for typical radices - var radixPowerCache = { - 16: UINT64( Math.pow(16, 5) ) - , 10: UINT64( Math.pow(10, 5) ) - , 2: UINT64( Math.pow(2, 5) ) - } - var radixCache = { - 16: UINT64(16) - , 10: UINT64(10) - , 2: UINT64(2) - } - - /** - * Represents an unsigned 64 bits integer - * @constructor - * @param {Number} first low bits (8) - * @param {Number} second low bits (8) - * @param {Number} first high bits (8) - * @param {Number} second high bits (8) - * or - * @param {Number} low bits (32) - * @param {Number} high bits (32) - * or - * @param {String|Number} integer as a string | integer as a number - * @param {Number|Undefined} radix (optional, default=10) - * @return - */ - function UINT64 (a00, a16, a32, a48) { - if ( !(this instanceof UINT64) ) - return new UINT64(a00, a16, a32, a48) - - this.remainder = null - if (typeof a00 == 'string') - return fromString.call(this, a00, a16) - - if (typeof a16 == 'undefined') - return fromNumber.call(this, a00) - - fromBits.apply(this, arguments) - } - - /** - * Set the current _UINT64_ object with its low and high bits - * @method fromBits - * @param {Number} first low bits (8) - * @param {Number} second low bits (8) - * @param {Number} first high bits (8) - * @param {Number} second high bits (8) - * or - * @param {Number} low bits (32) - * @param {Number} high bits (32) - * @return ThisExpression - */ - function fromBits (a00, a16, a32, a48) { - if (typeof a32 == 'undefined') { - this._a00 = a00 & 0xFFFF - this._a16 = a00 >>> 16 - this._a32 = a16 & 0xFFFF - this._a48 = a16 >>> 16 - return this - } - - this._a00 = a00 | 0 - this._a16 = a16 | 0 - this._a32 = a32 | 0 - this._a48 = a48 | 0 - - return this - } - UINT64.prototype.fromBits = fromBits - - /** - * Set the current _UINT64_ object from a number - * @method fromNumber - * @param {Number} number - * @return ThisExpression - */ - function fromNumber (value) { - this._a00 = value & 0xFFFF - this._a16 = value >>> 16 - this._a32 = 0 - this._a48 = 0 - - return this - } - UINT64.prototype.fromNumber = fromNumber - - /** - * Set the current _UINT64_ object from a string - * @method fromString - * @param {String} integer as a string - * @param {Number} radix (optional, default=10) - * @return ThisExpression - */ - function fromString (s, radix) { - radix = radix || 10 - - this._a00 = 0 - this._a16 = 0 - this._a32 = 0 - this._a48 = 0 - - /* - In Javascript, bitwise operators only operate on the first 32 bits - of a number, even though parseInt() encodes numbers with a 53 bits - mantissa. - Therefore UINT64(<Number>) can only work on 32 bits. - The radix maximum value is 36 (as per ECMA specs) (26 letters + 10 digits) - maximum input value is m = 32bits as 1 = 2^32 - 1 - So the maximum substring length n is: - 36^(n+1) - 1 = 2^32 - 1 - 36^(n+1) = 2^32 - (n+1)ln(36) = 32ln(2) - n = 32ln(2)/ln(36) - 1 - n = 5.189644915687692 - n = 5 - */ - var radixUint = radixPowerCache[radix] || new UINT64( Math.pow(radix, 5) ) - - for (var i = 0, len = s.length; i < len; i += 5) { - var size = Math.min(5, len - i) - var value = parseInt( s.slice(i, i + size), radix ) - this.multiply( - size < 5 - ? new UINT64( Math.pow(radix, size) ) - : radixUint - ) - .add( new UINT64(value) ) - } - - return this - } - UINT64.prototype.fromString = fromString - - /** - * Convert this _UINT64_ to a number (last 32 bits are dropped) - * @method toNumber - * @return {Number} the converted UINT64 - */ - UINT64.prototype.toNumber = function () { - return (this._a16 * 65536) + this._a00 - } - - /** - * Convert this _UINT64_ to a string - * @method toString - * @param {Number} radix (optional, default=10) - * @return {String} the converted UINT64 - */ - UINT64.prototype.toString = function (radix) { - radix = radix || 10 - var radixUint = radixCache[radix] || new UINT64(radix) - - if ( !this.gt(radixUint) ) return this.toNumber().toString(radix) - - var self = this.clone() - var res = new Array(64) - for (var i = 63; i >= 0; i--) { - self.div(radixUint) - res[i] = self.remainder.toNumber().toString(radix) - if ( !self.gt(radixUint) ) break - } - res[i-1] = self.toNumber().toString(radix) - - return res.join('') - } - - /** - * Add two _UINT64_. The current _UINT64_ stores the result - * @method add - * @param {Object} other UINT64 - * @return ThisExpression - */ - UINT64.prototype.add = function (other) { - var a00 = this._a00 + other._a00 - - var a16 = a00 >>> 16 - a16 += this._a16 + other._a16 - - var a32 = a16 >>> 16 - a32 += this._a32 + other._a32 - - var a48 = a32 >>> 16 - a48 += this._a48 + other._a48 - - this._a00 = a00 & 0xFFFF - this._a16 = a16 & 0xFFFF - this._a32 = a32 & 0xFFFF - this._a48 = a48 & 0xFFFF - - return this - } - - /** - * Subtract two _UINT64_. The current _UINT64_ stores the result - * @method subtract - * @param {Object} other UINT64 - * @return ThisExpression - */ - UINT64.prototype.subtract = function (other) { - return this.add( other.clone().negate() ) - } - - /** - * Multiply two _UINT64_. The current _UINT64_ stores the result - * @method multiply - * @param {Object} other UINT64 - * @return ThisExpression - */ - UINT64.prototype.multiply = function (other) { - /* - a = a00 + a16 + a32 + a48 - b = b00 + b16 + b32 + b48 - a*b = (a00 + a16 + a32 + a48)(b00 + b16 + b32 + b48) - = a00b00 + a00b16 + a00b32 + a00b48 - + a16b00 + a16b16 + a16b32 + a16b48 - + a32b00 + a32b16 + a32b32 + a32b48 - + a48b00 + a48b16 + a48b32 + a48b48 - - a16b48, a32b32, a48b16, a48b32 and a48b48 overflow the 64 bits - so it comes down to: - a*b = a00b00 + a00b16 + a00b32 + a00b48 - + a16b00 + a16b16 + a16b32 - + a32b00 + a32b16 - + a48b00 - = a00b00 - + a00b16 + a16b00 - + a00b32 + a16b16 + a32b00 - + a00b48 + a16b32 + a32b16 + a48b00 - */ - var a00 = this._a00 - var a16 = this._a16 - var a32 = this._a32 - var a48 = this._a48 - var b00 = other._a00 - var b16 = other._a16 - var b32 = other._a32 - var b48 = other._a48 - - var c00 = a00 * b00 - - var c16 = c00 >>> 16 - c16 += a00 * b16 - var c32 = c16 >>> 16 - c16 &= 0xFFFF - c16 += a16 * b00 - - c32 += c16 >>> 16 - c32 += a00 * b32 - var c48 = c32 >>> 16 - c32 &= 0xFFFF - c32 += a16 * b16 - c48 += c32 >>> 16 - c32 &= 0xFFFF - c32 += a32 * b00 - - c48 += c32 >>> 16 - c48 += a00 * b48 - c48 &= 0xFFFF - c48 += a16 * b32 - c48 &= 0xFFFF - c48 += a32 * b16 - c48 &= 0xFFFF - c48 += a48 * b00 - - this._a00 = c00 & 0xFFFF - this._a16 = c16 & 0xFFFF - this._a32 = c32 & 0xFFFF - this._a48 = c48 & 0xFFFF - - return this - } - - /** - * Divide two _UINT64_. The current _UINT64_ stores the result. - * The remainder is made available as the _remainder_ property on - * the _UINT64_ object. It can be null, meaning there are no remainder. - * @method div - * @param {Object} other UINT64 - * @return ThisExpression - */ - UINT64.prototype.div = function (other) { - if ( (other._a16 == 0) && (other._a32 == 0) && (other._a48 == 0) ) { - if (other._a00 == 0) throw Error('division by zero') - - // other == 1: this - if (other._a00 == 1) { - this.remainder = new UINT64(0) - return this - } - } - - // other > this: 0 - if ( other.gt(this) ) { - this.remainder = this.clone() - this._a00 = 0 - this._a16 = 0 - this._a32 = 0 - this._a48 = 0 - return this - } - // other == this: 1 - if ( this.eq(other) ) { - this.remainder = new UINT64(0) - this._a00 = 1 - this._a16 = 0 - this._a32 = 0 - this._a48 = 0 - return this - } - - // Shift the divisor left until it is higher than the dividend - var _other = other.clone() - var i = -1 - while ( !this.lt(_other) ) { - // High bit can overflow the default 16bits - // Its ok since we right shift after this loop - // The overflown bit must be kept though - _other.shiftLeft(1, true) - i++ - } - - // Set the remainder - this.remainder = this.clone() - // Initialize the current result to 0 - this._a00 = 0 - this._a16 = 0 - this._a32 = 0 - this._a48 = 0 - for (; i >= 0; i--) { - _other.shiftRight(1) - // If shifted divisor is smaller than the dividend - // then subtract it from the dividend - if ( !this.remainder.lt(_other) ) { - this.remainder.subtract(_other) - // Update the current result - if (i >= 48) { - this._a48 |= 1 << (i - 48) - } else if (i >= 32) { - this._a32 |= 1 << (i - 32) - } else if (i >= 16) { - this._a16 |= 1 << (i - 16) - } else { - this._a00 |= 1 << i - } - } - } - - return this - } - - /** - * Negate the current _UINT64_ - * @method negate - * @return ThisExpression - */ - UINT64.prototype.negate = function () { - var v = ( ~this._a00 & 0xFFFF ) + 1 - this._a00 = v & 0xFFFF - v = (~this._a16 & 0xFFFF) + (v >>> 16) - this._a16 = v & 0xFFFF - v = (~this._a32 & 0xFFFF) + (v >>> 16) - this._a32 = v & 0xFFFF - this._a48 = (~this._a48 + (v >>> 16)) & 0xFFFF - - return this - } - - /** - - * @method eq - * @param {Object} other UINT64 - * @return {Boolean} - */ - UINT64.prototype.equals = UINT64.prototype.eq = function (other) { - return (this._a48 == other._a48) && (this._a00 == other._a00) - && (this._a32 == other._a32) && (this._a16 == other._a16) - } - - /** - * Greater than (strict) - * @method gt - * @param {Object} other UINT64 - * @return {Boolean} - */ - UINT64.prototype.greaterThan = UINT64.prototype.gt = function (other) { - if (this._a48 > other._a48) return true - if (this._a48 < other._a48) return false - if (this._a32 > other._a32) return true - if (this._a32 < other._a32) return false - if (this._a16 > other._a16) return true - if (this._a16 < other._a16) return false - return this._a00 > other._a00 - } - - /** - * Less than (strict) - * @method lt - * @param {Object} other UINT64 - * @return {Boolean} - */ - UINT64.prototype.lessThan = UINT64.prototype.lt = function (other) { - if (this._a48 < other._a48) return true - if (this._a48 > other._a48) return false - if (this._a32 < other._a32) return true - if (this._a32 > other._a32) return false - if (this._a16 < other._a16) return true - if (this._a16 > other._a16) return false - return this._a00 < other._a00 - } - - /** - * Bitwise OR - * @method or - * @param {Object} other UINT64 - * @return ThisExpression - */ - UINT64.prototype.or = function (other) { - this._a00 |= other._a00 - this._a16 |= other._a16 - this._a32 |= other._a32 - this._a48 |= other._a48 - - return this - } - - /** - * Bitwise AND - * @method and - * @param {Object} other UINT64 - * @return ThisExpression - */ - UINT64.prototype.and = function (other) { - this._a00 &= other._a00 - this._a16 &= other._a16 - this._a32 &= other._a32 - this._a48 &= other._a48 - - return this - } - - /** - * Bitwise XOR - * @method xor - * @param {Object} other UINT64 - * @return ThisExpression - */ - UINT64.prototype.xor = function (other) { - this._a00 ^= other._a00 - this._a16 ^= other._a16 - this._a32 ^= other._a32 - this._a48 ^= other._a48 - - return this - } - - /** - * Bitwise NOT - * @method not - * @return ThisExpression - */ - UINT64.prototype.not = function() { - this._a00 = ~this._a00 & 0xFFFF - this._a16 = ~this._a16 & 0xFFFF - this._a32 = ~this._a32 & 0xFFFF - this._a48 = ~this._a48 & 0xFFFF - - return this - } - - /** - * Bitwise shift right - * @method shiftRight - * @param {Number} number of bits to shift - * @return ThisExpression - */ - UINT64.prototype.shiftRight = UINT64.prototype.shiftr = function (n) { - n %= 64 - if (n >= 48) { - this._a00 = this._a48 >> (n - 48) - this._a16 = 0 - this._a32 = 0 - this._a48 = 0 - } else if (n >= 32) { - n -= 32 - this._a00 = ( (this._a32 >> n) | (this._a48 << (16-n)) ) & 0xFFFF - this._a16 = (this._a48 >> n) & 0xFFFF - this._a32 = 0 - this._a48 = 0 - } else if (n >= 16) { - n -= 16 - this._a00 = ( (this._a16 >> n) | (this._a32 << (16-n)) ) & 0xFFFF - this._a16 = ( (this._a32 >> n) | (this._a48 << (16-n)) ) & 0xFFFF - this._a32 = (this._a48 >> n) & 0xFFFF - this._a48 = 0 - } else { - this._a00 = ( (this._a00 >> n) | (this._a16 << (16-n)) ) & 0xFFFF - this._a16 = ( (this._a16 >> n) | (this._a32 << (16-n)) ) & 0xFFFF - this._a32 = ( (this._a32 >> n) | (this._a48 << (16-n)) ) & 0xFFFF - this._a48 = (this._a48 >> n) & 0xFFFF - } - - return this - } - - /** - * Bitwise shift left - * @method shiftLeft - * @param {Number} number of bits to shift - * @param {Boolean} allow overflow - * @return ThisExpression - */ - UINT64.prototype.shiftLeft = UINT64.prototype.shiftl = function (n, allowOverflow) { - n %= 64 - if (n >= 48) { - this._a48 = this._a00 << (n - 48) - this._a32 = 0 - this._a16 = 0 - this._a00 = 0 - } else if (n >= 32) { - n -= 32 - this._a48 = (this._a16 << n) | (this._a00 >> (16-n)) - this._a32 = (this._a00 << n) & 0xFFFF - this._a16 = 0 - this._a00 = 0 - } else if (n >= 16) { - n -= 16 - this._a48 = (this._a32 << n) | (this._a16 >> (16-n)) - this._a32 = ( (this._a16 << n) | (this._a00 >> (16-n)) ) & 0xFFFF - this._a16 = (this._a00 << n) & 0xFFFF - this._a00 = 0 - } else { - this._a48 = (this._a48 << n) | (this._a32 >> (16-n)) - this._a32 = ( (this._a32 << n) | (this._a16 >> (16-n)) ) & 0xFFFF - this._a16 = ( (this._a16 << n) | (this._a00 >> (16-n)) ) & 0xFFFF - this._a00 = (this._a00 << n) & 0xFFFF - } - if (!allowOverflow) { - this._a48 &= 0xFFFF - } - - return this - } - - /** - * Bitwise rotate left - * @method rotl - * @param {Number} number of bits to rotate - * @return ThisExpression - */ - UINT64.prototype.rotateLeft = UINT64.prototype.rotl = function (n) { - n %= 64 - if (n == 0) return this - if (n >= 32) { - // A.B.C.D - // B.C.D.A rotl(16) - // C.D.A.B rotl(32) - var v = this._a00 - this._a00 = this._a32 - this._a32 = v - v = this._a48 - this._a48 = this._a16 - this._a16 = v - if (n == 32) return this - n -= 32 - } - - var high = (this._a48 << 16) | this._a32 - var low = (this._a16 << 16) | this._a00 - - var _high = (high << n) | (low >>> (32 - n)) - var _low = (low << n) | (high >>> (32 - n)) - - this._a00 = _low & 0xFFFF - this._a16 = _low >>> 16 - this._a32 = _high & 0xFFFF - this._a48 = _high >>> 16 - - return this - } - - /** - * Bitwise rotate right - * @method rotr - * @param {Number} number of bits to rotate - * @return ThisExpression - */ - UINT64.prototype.rotateRight = UINT64.prototype.rotr = function (n) { - n %= 64 - if (n == 0) return this - if (n >= 32) { - // A.B.C.D - // D.A.B.C rotr(16) - // C.D.A.B rotr(32) - var v = this._a00 - this._a00 = this._a32 - this._a32 = v - v = this._a48 - this._a48 = this._a16 - this._a16 = v - if (n == 32) return this - n -= 32 - } - - var high = (this._a48 << 16) | this._a32 - var low = (this._a16 << 16) | this._a00 - - var _high = (high >>> n) | (low << (32 - n)) - var _low = (low >>> n) | (high << (32 - n)) - - this._a00 = _low & 0xFFFF - this._a16 = _low >>> 16 - this._a32 = _high & 0xFFFF - this._a48 = _high >>> 16 - - return this - } - - /** - * Clone the current _UINT64_ - * @method clone - * @return {Object} cloned UINT64 - */ - UINT64.prototype.clone = function () { - return new UINT64(this._a00, this._a16, this._a32, this._a48) - } - - if (typeof define != 'undefined' && define.amd) { - // AMD / RequireJS - define([], function () { - return UINT64 - }) - } else if (typeof module != 'undefined' && module.exports) { - // Node.js - module.exports = UINT64 - } else { - // Browser - root['UINT64'] = UINT64 - } - -})(this) |