bigfloat/dist/browser.js

System.register("bigfloat", [], function(exports_1) {
    "use strict";
    var dblEpsilon, limbSize, BigFloat;
    /** Create a string with the given number of zero digits. */
    function zeroes(count) {
        return (new Array(count + 1).join('0'));
    }
    return {
        setters:[],
        execute: function() {
            /** Difference between closest possible IEEE 754 doubles between 1 and 2. */
            exports_1("dblEpsilon", dblEpsilon = Math.pow(2, -52));
            /** Base for calculations, the bigger the better but must fit in 32 bits. */
            limbSize = Math.pow(2, 32);
            BigFloat = (function () {
                function BigFloat(dbl) {
                    if (dbl)
                        this.setDouble(dbl);
                    else {
                        this.fractionLen = 0;
                        this.limbList = [];
                    }
                }
                /** Output EXACT value of an IEEE 754 double in base 2, 10 or 16.
                  * Exponent must be between -2 and 61, and last 3 bits of mantissa must be 0.
                  * Useful for debugging. */
                BigFloat.doubleToString = function (dbl, base) {
                    if (base === void 0) { base = 10; }
                    var pad = BigFloat.padTbl[base];
                    var sign = '';
                    var out = '';
                    var limb;
                    var limbStr;
                    var groupSize = limbSize;
                    if (isNaN(dbl))
                        return ('NaN');
                    // For negative numbers, output sign and get absolute value.
                    if (dbl < 0) {
                        sign = '-';
                        dbl = -dbl;
                    }
                    if (!isFinite(dbl))
                        return (sign + 'Inf');
                    if (dbl < 1) {
                        out += '0';
                    }
                    else {
                        var iPart = Math.floor(dbl);
                        dbl -= iPart;
                        if (base == 10)
                            groupSize = 1000000000;
                        while (iPart) {
                            // Extract groups of digits starting from the least significant.
                            limb = iPart % groupSize;
                            iPart = (iPart - limb) / groupSize;
                            limbStr = limb.toString(base);
                            // Prepend digits to result.
                            out = limbStr + out;
                            // If more limbs remain, pad with zeroes to group length.
                            if (iPart)
                                out = pad.substr(limbStr.length) + out;
                        }
                    }
                    // Is there a fractional part remaining?
                    if (dbl > 0) {
                        out += '.';
                        if (base == 10) {
                            groupSize = 10;
                            pad = '';
                        }
                        while (dbl) {
                            // Extract groups of digits starting from the most significant.
                            dbl *= groupSize;
                            limb = dbl >>> 0;
                            dbl -= limb;
                            limbStr = limb.toString(base);
                            // Append digits to result and pad with zeroes to group length.
                            out += pad.substr(limbStr.length) + limbStr;
                        }
                    }
                    // Remove trailing zeroes.
                    return (sign + out.replace(/(\.[0-9a-z]*[1-9a-z])0+$/, '$1'));
                };
                /** Set value from a floating point number (probably IEEE 754 double). */
                BigFloat.prototype.setDouble = function (dbl) {
                    if (dbl < 0) {
                        dbl = -dbl;
                        this.isNegative = 1;
                    }
                    else
                        this.isNegative = 0;
                    var iPart = Math.floor(dbl);
                    var fPart = dbl - iPart;
                    var fractionLen = 0;
                    var limbList = [];
                    var limb;
                    // Handle fractional part.
                    while (fPart) {
                        // Extract limbs starting from the most significant.
                        fPart *= limbSize;
                        limb = fPart >>> 0;
                        fPart -= limb;
                        // Append limb to value (limbs are reversed later).
                        limbList.push(limb);
                        ++fractionLen;
                    }
                    limbList.reverse();
                    // Handle integer part.
                    while (iPart) {
                        // Extract limbs starting from the least significant.
                        limb = iPart % limbSize; // Could also be iPart >>> 0
                        iPart = (iPart - limb) / limbSize;
                        // Append limb to value.
                        limbList.push(limb);
                    }
                    this.limbList = limbList;
                    this.fractionLen = fractionLen;
                    return (this);
                };
                /** Multiply by an integer and write output limbs to another list. */
                BigFloat.prototype.mulInt = function (factor, dstLimbList, srcPos, dstPos, overwriteMask) {
                    if (!factor)
                        return (0);
                    var limbList = this.limbList;
                    var limbCount = limbList.length;
                    var limb;
                    var lo;
                    var carry = 0;
                    // limbList is an array of 32-bit ints but split here into 16-bit low
                    // and high words for multiplying by a 32-bit term, so the intermediate
                    // 48-bit multiplication results fit into 53 bits of IEEE 754 mantissa.
                    while (srcPos < limbCount) {
                        limb = limbList[srcPos++];
                        // Multiply lower half of limb with factor, making carry temporarily take 48 bits.
                        carry += factor * (limb & 0xffff);
                        // Get lowest 16 bits of full product.
                        lo = carry & 0xffff;
                        // Right shift by dividing because >> and >>> truncate to 32 bits before shifting.
                        carry = (carry - lo) / 65536;
                        // Multiply higher half of limb and combine with lowest 16 bits of full product.
                        carry += factor * (limb >>> 16);
                        lo |= carry << 16;
                        // Lowest 32 bits of full product are added to output limb.
                        limb = ((dstLimbList[dstPos] & overwriteMask) + lo) >>> 0;
                        dstLimbList[dstPos++] = limb;
                        // Highest 32 bits of full product stay in carry, also increment by 1 if previous sum overflowed.
                        carry = (carry / 65536) >>> 0;
                        // Bit twiddle equivalent to: if(limb < (lo >>> 0)) ++carry;
                        carry += (lo ^ (((limb - lo) ^ lo) & ~(limb ^ lo))) >>> 31;
                    }
                    // Extend result by one more limb if it overflows.
                    if (carry)
                        dstLimbList[dstPos] = carry;
                    return (carry);
                };
                BigFloat.prototype.mulBig = function (multiplier) {
                    var multiplierLimbs = multiplier.limbList;
                    var lenMultiplier = multiplierLimbs.length;
                    var product = new BigFloat();
                    var productLimbs = product.limbList;
                    for (var posMultiplier = 0; posMultiplier < lenMultiplier; ++posMultiplier) {
                        this.mulInt(multiplierLimbs[posMultiplier], productLimbs, 0, posMultiplier, 0xffffffff);
                    }
                    product.isNegative = this.isNegative ^ multiplier.isNegative;
                    product.fractionLen = this.fractionLen + multiplier.fractionLen;
                    return (product);
                };
                /** Multiply and return product in a new BigFloat. */
                BigFloat.prototype.mul = function (multiplier) {
                    if (typeof (multiplier) == 'number') {
                        multiplier = BigFloat.tempFloat.setDouble(multiplier);
                    }
                    return (this.mulBig(multiplier));
                };
                BigFloat.prototype.absDeltaFrom = function (other) {
                    var limbList = this.limbList;
                    var otherList = other.limbList;
                    var limbCount = limbList.length;
                    var otherCount = otherList.length;
                    // Compare lengths.
                    var d = (limbCount - this.fractionLen) - (otherCount - other.fractionLen);
                    // If lengths are equal, compare each limb from most to least significant.
                    while (!d && limbCount && otherCount)
                        d = limbList[--limbCount] - otherList[--otherCount];
                    if (d)
                        return (d);
                    if (limbCount) {
                        do
                            d = limbList[--limbCount];
                        while (!d && limbCount);
                    }
                    else if (otherCount) {
                        do
                            d = -otherList[--otherCount];
                        while (!d && otherCount);
                    }
                    return (d);
                };
                BigFloat.prototype.isZero = function () {
                    var limbList = this.limbList;
                    var limbCount = limbList.length;
                    var d;
                    if (!limbCount)
                        return (true);
                    do
                        d = limbList[--limbCount];
                    while (!d && limbCount);
                    return (!d);
                };
                /** Return an arbitrary number with sign matching the result of this - other. */
                BigFloat.prototype.deltaFrom = function (other) {
                    var isNegative = this.isNegative;
                    var d = other.isNegative - isNegative;
                    // Check if signs are different.
                    if (d) {
                        // Make sure positive and negative zero have no difference.
                        if (this.isZero() && other.isZero())
                            return (0);
                        // Return difference of signs.
                        return (d);
                    }
                    if (isNegative) {
                        return (-this.absDeltaFrom(other));
                    }
                    else {
                        return (this.absDeltaFrom(other));
                    }
                };
                BigFloat.prototype.addBig = function (addend) {
                    var augend = this;
                    var sum = new BigFloat();
                    var fractionLen = augend.fractionLen;
                    var len = fractionLen - addend.fractionLen;
                    if (len < 0) {
                        len = -len;
                        fractionLen += len;
                        augend = addend;
                        addend = this;
                    }
                    sum.isNegative = this.isNegative;
                    sum.fractionLen = fractionLen;
                    var sumLimbs = sum.limbList;
                    var augendLimbs = augend.limbList;
                    var addendLimbs = addend.limbList;
                    var posAugend = 0;
                    var posAddend = 0;
                    var carry = 0;
                    var limbSum;
                    // If one input has more fractional limbs, just copy the leftovers to output.
                    while (posAugend < len) {
                        sumLimbs[posAugend] = augendLimbs[posAugend];
                        ++posAugend;
                    }
                    var lenAddend = addendLimbs.length;
                    len = augendLimbs.length - posAugend;
                    if (len > lenAddend)
                        len = lenAddend;
                    // Calculate sum where input numbers overlap.
                    while (posAddend < len) {
                        carry += augendLimbs[posAugend] + addendLimbs[posAddend++];
                        limbSum = carry >>> 0;
                        carry = carry - limbSum && 1;
                        sumLimbs[posAugend++] = limbSum;
                    }
                    var posSum = posAugend;
                    if (len < lenAddend) {
                        len = lenAddend;
                        augend = addend;
                        posAugend = posAddend;
                        augendLimbs = addendLimbs;
                    }
                    else
                        len = augendLimbs.length;
                    // Copy leftover most significant limbs to output, propagating carry.
                    while (posAugend < len) {
                        carry += augendLimbs[posAugend++];
                        limbSum = carry >>> 0;
                        carry = carry - limbSum && 1;
                        sumLimbs[posSum++] = limbSum;
                    }
                    if (carry)
                        sumLimbs[posSum] = carry;
                    return (sum);
                };
                BigFloat.prototype.subBig = function (subtrahend) {
                    var minuend = this;
                    var difference = new BigFloat();
                    difference.isNegative = this.isNegative;
                    // Make sure the subtrahend is the smaller number.
                    if (minuend.absDeltaFrom(subtrahend) < 0) {
                        minuend = subtrahend;
                        subtrahend = this;
                        difference.isNegative ^= 1;
                    }
                    var fractionLen = minuend.fractionLen;
                    var len = fractionLen - subtrahend.fractionLen;
                    var differenceLimbs = difference.limbList;
                    var minuendLimbs = minuend.limbList;
                    var subtrahendLimbs = subtrahend.limbList;
                    var lenMinuend = minuendLimbs.length;
                    var lenSubtrahend = subtrahendLimbs.length;
                    var lenFinal = lenMinuend;
                    var posMinuend = 0;
                    var posSubtrahend = 0;
                    var posDifference = 0;
                    var carry = 0;
                    var limbDiff;
                    if (len >= 0) {
                        while (posMinuend < len) {
                            differenceLimbs[posMinuend] = minuendLimbs[posMinuend];
                            ++posMinuend;
                        }
                        len += lenSubtrahend;
                        if (len > lenMinuend)
                            len = lenMinuend;
                        posDifference = posMinuend;
                    }
                    else {
                        len = -len;
                        fractionLen += len;
                        lenFinal += len;
                        while (posSubtrahend < len) {
                            carry -= subtrahendLimbs[posSubtrahend];
                            limbDiff = carry >>> 0;
                            carry = -(carry < 0);
                            differenceLimbs[posSubtrahend++] = limbDiff;
                        }
                        len += lenMinuend;
                        if (len > lenSubtrahend)
                            len = lenSubtrahend;
                        posDifference = posSubtrahend;
                    }
                    difference.fractionLen = fractionLen;
                    // Calculate difference where input numbers overlap.
                    while (posDifference < len) {
                        carry += minuendLimbs[posMinuend++] - subtrahendLimbs[posSubtrahend++];
                        limbDiff = carry >>> 0;
                        carry = -(carry < 0);
                        differenceLimbs[posDifference++] = limbDiff;
                    }
                    // Copy leftover most significant limbs to output, propagating carry.
                    while (posDifference < lenFinal) {
                        carry += minuendLimbs[posMinuend++];
                        limbDiff = carry >>> 0;
                        carry = -(carry < 0);
                        differenceLimbs[posDifference++] = limbDiff;
                    }
                    return (difference);
                };
                BigFloat.prototype.addSub = function (addend, flip) {
                    if (typeof (addend) == 'number') {
                        addend = BigFloat.tempFloat.setDouble(addend);
                    }
                    if (this.isNegative ^ addend.isNegative ^ flip) {
                        return (this.subBig(addend));
                    }
                    else {
                        return (this.addBig(addend));
                    }
                };
                /** Add and return sum in a new BigFloat. */
                BigFloat.prototype.add = function (addend) {
                    return (this.addSub(addend, 0));
                };
                /** Subtract and return difference in a new BigFloat. */
                BigFloat.prototype.sub = function (subtrahend) {
                    return (this.addSub(subtrahend, 1));
                };
                /** Divide by integer, replacing current value by quotient. Return integer remainder. */
                BigFloat.prototype.divInt = function (divisor) {
                    var limbList = this.limbList;
                    var limbNum = limbList.length;
                    var limb;
                    var hi, lo;
                    var carry = 0;
                    // If most significant limb is zero after dividing, decrement number of limbs remaining.
                    if (limbList[limbNum - 1] < divisor) {
                        carry = limbList[--limbNum];
                        limbList.length = limbNum;
                    }
                    while (limbNum--) {
                        limb = limbList[limbNum];
                        carry = carry * 0x10000 + (limb >>> 16);
                        hi = (carry / divisor) >>> 0;
                        carry = carry - hi * divisor;
                        carry = carry * 0x10000 + (limb & 0xffff);
                        lo = (carry / divisor) >>> 0;
                        carry = carry - lo * divisor;
                        limbList[limbNum] = ((hi << 16) | lo) >>> 0;
                    }
                    return (carry);
                };
                BigFloat.prototype.fractionToString = function (base, groupSize, digitList) {
                    var pad = BigFloat.padTbl[base];
                    var limbList = this.limbList;
                    var limbCount = this.fractionLen;
                    var limbNum = 0;
                    var limbStr;
                    // Skip least significant limbs that equal zero.
                    while (1) {
                        if (limbNum >= limbCount)
                            return;
                        if (limbList[limbNum])
                            break;
                        ++limbNum;
                    }
                    digitList.push('.');
                    var fPart = BigFloat.tempFloat;
                    fPart.limbList = limbList.slice(limbNum, limbCount);
                    limbCount -= limbNum;
                    limbNum = 0;
                    while (1) {
                        if (fPart.limbList[limbNum]) {
                            var carry = fPart.mulInt(groupSize, fPart.limbList, limbNum, limbNum, 0);
                            if (carry)
                                fPart.limbList.pop();
                            limbStr = '' + carry;
                            digitList.push(pad.substr(limbStr.length) + limbStr);
                        }
                        else if (++limbNum >= limbCount)
                            break;
                    }
                };
                /** Convert to string in base 2, 10 or 16. */
                BigFloat.prototype.toString = function (base) {
                    if (base === void 0) { base = 10; }
                    var pad = BigFloat.padTbl[base];
                    var digitList = [];
                    var limbList = this.limbList;
                    var limb;
                    var limbStr;
                    if (base == 10) {
                        var groupSize = 1000000000;
                        var iPart = BigFloat.tempFloat;
                        iPart.limbList = limbList.slice(this.fractionLen);
                        // Loop while 2 or more limbs remain, requiring arbitrary precision division to extract digits.
                        while (iPart.limbList.length) {
                            limbStr = '' + iPart.divInt(groupSize);
                            // Prepend digits into final result, padded with zeroes to 9 digits.
                            // Since more limbs still remain, whole result will not have extra padding.
                            digitList.push(pad.substr(limbStr.length) + limbStr);
                        }
                        // Prepend last remaining limb and sign to result.
                        digitList.push('' + (iPart.limbList[0] || 0));
                        if (this.isNegative)
                            digitList.push('-');
                        digitList.reverse();
                        // Handle fractional part.
                        this.fractionToString(base, groupSize, digitList);
                    }
                    else {
                        var limbNum = limbList.length;
                        var fractionPos = this.fractionLen;
                        if (this.isNegative)
                            digitList.push('-');
                        if (limbNum == fractionPos)
                            digitList.push('0');
                        while (limbNum--) {
                            limbStr = limbList[limbNum].toString(base);
                            if (limbNum == fractionPos - 1)
                                digitList.push('.');
                            digitList.push(pad.substr(limbStr.length) + limbStr);
                        }
                    }
                    // Remove leading and trailing zeroes.
                    return (BigFloat.trim(digitList.join('')));
                };
                /** Remove leading and trailing insignificant zero digits. */
                BigFloat.trim = function (str) {
                    return (str
                        .replace(/^(-?)0+([1-9a-z]|0(\.|$))/, '$1$2')
                        .replace(/(\.|(\.[0-9a-z]*[1-9a-z]))0+$/, '$2'));
                };
                BigFloat.padTbl = {
                    2: zeroes(32),
                    10: zeroes(9),
                    16: zeroes(8)
                };
                BigFloat.tempFloat = new BigFloat();
                return BigFloat;
            })();
            exports_1("BigFloat", BigFloat);
        }
    }
});