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, 648 insertions, 0 deletions
diff --git a/school/node_modules/cuint/lib/uint64.js b/school/node_modules/cuint/lib/uint64.js new file mode 100644 index 0000000..bb90522 --- /dev/null +++ b/school/node_modules/cuint/lib/uint64.js @@ -0,0 +1,648 @@ +/** + 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) |