bigfloat/dist/bigfloat.js

"use strict";
/** Difference between closest possible IEEE 754 doubles between 1 and 2. */
exports.dblEpsilon = Math.pow(2, -52);
/** Base for calculations, the bigger the better but must fit in 32 bits. */
var limbSize = Math.pow(2, 32);
/** Create a string with the given number of zero digits. */
function zeroes(count) {
    return (new Array(count + 1).join('0'));
}
var 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.BigFloat = BigFloat;