nerdamer 1.1.13 → 2.0.0-rc.2

package/output/core/functions/bigint/bigint.js

@@ -0,0 +1,444 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.factorial = void 0;
+exports.abs = abs;
+exports.uniqueSortedArray = uniqueSortedArray;
+exports.GCD = GCD;
+exports.LCM = LCM;
+exports.simplifyRatio = simplifyRatio;
+exports.convert = convert;
+exports.sign = sign;
+exports.isEven = isEven;
+exports.integerSquareRoot = integerSquareRoot;
+exports.ceilIntegerSquareRoot = ceilIntegerSquareRoot;
+exports.fibonacci = fibonacci;
+exports.mod = mod;
+exports.powMod = powMod;
+exports.invMod = invMod;
+exports.productInRange = productInRange;
+exports.max = max;
+exports.min = min;
+exports.recoverCoeffsZ = recoverCoeffsZ;
+exports.binom = binom;
+exports.bigintLCM = bigintLCM;
+const errors_1 = require("../../errors");
+const string_1 = require("../string");
+const utils_1 = require("../utils");
+/**
+ * Returns the absolute value of a bigint
+ *
+ * @param x
+ * @returns
+ */
+function abs(x) {
+    return x < 0n ? -x : x;
+}
+/**
+ * Returns an array with unique values, sorted, and in reverse order.
+ *
+ * @param array
+ * @returns
+ */
+function uniqueSortedArray(array) {
+    return (0, utils_1.arrayUnique)([].slice.call(array).map(function (x) {
+        return abs(x);
+    })).sort();
+}
+/**
+ * Calculates the gcd of a set of bigints
+ *
+ * @returns
+ */
+function GCD(...args) {
+    // Get a unique set and convert to absolute values
+    args = uniqueSortedArray(args);
+    // Point to the first element
+    let a = args[0];
+    for (let i = 1; i < args.length; i++) {
+        let b = args[i];
+        while (true) {
+            a %= b;
+            if (a === 0n) {
+                a = b;
+                break;
+            }
+            b %= a;
+            if (b === 0n) {
+                break;
+            }
+        }
+    }
+    return a;
+}
+/**
+ * Calculates the LCM of a set of bigints
+ *
+ * @param args
+ */
+function LCM(...args) {
+    // Get a unique set and convert to absolute values
+    args = uniqueSortedArray(args);
+    let a = args[0];
+    for (let i = 1; i < args.length; i++) {
+        const b = args[i];
+        // Get the LCM of that of the last calculated LCM and the new number
+        a = (a * b) / GCD(a, b);
+    }
+    return a;
+}
+/**
+ * Simplifies a ratio of two bigints
+ *
+ * @param numerator
+ * @param denominator
+ * @returns
+ */
+function simplifyRatio(numerator, denominator) {
+    if (denominator !== 1n) {
+        const gcd = GCD(denominator, numerator);
+        return [numerator / gcd, denominator / gcd];
+    }
+    return [numerator, denominator];
+}
+/**
+ * Converts a decimal number to a rational
+ *
+ * @param numStr
+ * @returns
+ */
+function convert(numStr) {
+    //Split the whole and decimal
+    const [w, d] = (0, string_1.decimalSplit)(numStr);
+    //Create the denominator based on the number of decimal places
+    const denominator = 10n ** BigInt(d.length);
+    const numerator = BigInt(w + d);
+    return simplifyRatio(numerator, denominator);
+}
+/**
+ * Returns the sign of a bigint
+ *
+ * @param n
+ * @returns -1 if negative and 1 for positive and 0 for zero
+ */
+function sign(n) {
+    return n === 0n ? 0 : n < 0n ? -1 : 1;
+}
+/**
+ * Checks if a bigint is an even number
+ *
+ * @param n
+ * @returns
+ */
+function isEven(n) {
+    return n % 2n === 0n;
+}
+/**
+ * Returns the floor of the exact square root of a non-negative bigint.
+ */
+function integerSquareRoot(value) {
+    if (value < 0n) {
+        throw new RangeError((0, errors_1.message)('integerSqrtNonnegative'));
+    }
+    if (value < 2n) {
+        return value;
+    }
+    let root = 1n << ((BigInt(value.toString(2).length) + 1n) >> 1n);
+    while (true) {
+        const next = (root + value / root) >> 1n;
+        if (next >= root) {
+            return root;
+        }
+        root = next;
+    }
+}
+/** Returns the least bigint whose square is at least value. */
+function ceilIntegerSquareRoot(value) {
+    const root = integerSquareRoot(value);
+    return root * root === value ? root : root + 1n;
+}
+/**
+ * Computes the nth Fibonacci number exactly using fast doubling.
+ *
+ * Negative indices use the negafibonacci identity F(-n) = (-1)^(n+1)F(n).
+ *
+ * @param n - Integer index.
+ * @returns The exact Fibonacci number.
+ */
+function fibonacci(n) {
+    const isNegative = n < 0n;
+    const index = isNegative ? -n : n;
+    let a = 0n;
+    let b = 1n;
+    for (const bit of index.toString(2)) {
+        const c = a * (2n * b - a);
+        const d = a * a + b * b;
+        if (bit === '0') {
+            a = c;
+            b = d;
+        }
+        else {
+            a = d;
+            b = c + d;
+        }
+    }
+    let retval = a;
+    if (isNegative && isEven(index)) {
+        retval = -retval;
+    }
+    return retval;
+}
+/**
+ * The big number version
+ */
+exports.factorial = (function () {
+    const factorialCache = [1n, 1n];
+    let i = 2;
+    /**
+     * Leverages JavaScript's native bigInt and the solution provide here:
+     * https://stackoverflow.com/questions/3959211/what-is-the-fastest-factorial-function-in-javascript
+     * to provide a fast factorial function capable of calculating large numbers.
+     *
+     * @remarks
+     *
+     * This is limited to Number.MAX_SAFE_INTEGER since n is of type number since for loop requires it
+     *
+     * @param n - The factorial of the number being calculated
+     * @returns The computed factorial
+     * @throws RangeError If `n` is negative.
+     */
+    function bigFactorial(n) {
+        if (typeof n === 'bigint') {
+            n = Number(n);
+        }
+        if (n < 0) {
+            throw new RangeError((0, errors_1.message)('factorialNegativeUndefined'));
+        }
+        // If there's a cached version return that instead
+        if (typeof factorialCache[n] != 'undefined') {
+            return factorialCache[n];
+        }
+        let result = factorialCache[i - 1];
+        for (; i <= n; i++) {
+            factorialCache[i] = result = result * BigInt(i);
+        }
+        return result;
+    }
+    bigFactorial(100);
+    return bigFactorial;
+})();
+// Cache the first 100
+/**
+ * Calculates the modulo of two numbers
+ *
+ * @param a
+ * @param b
+ * @returns
+ */
+function mod(a, b) {
+    const signA = sign(a);
+    const signB = sign(b);
+    let retval;
+    if (signA === signB) {
+        retval = a % b;
+    }
+    else {
+        // https://stackoverflow.com/questions/4467539/javascript-modulo-gives-a-negative-result-for-negative-numbers
+        retval = ((a % b) + b) % b;
+    }
+    return retval;
+}
+/**
+ * Raises a bigint base to a non-negative bigint exponent modulo a positive modulus.
+ *
+ * Binary exponentiation keeps every intermediate value in bigint modular arithmetic.
+ */
+function powMod(base, exponent, modulus) {
+    if (modulus <= 0n) {
+        throw new RangeError((0, errors_1.message)('modularExponentiationPositiveModulus'));
+    }
+    if (exponent < 0n) {
+        throw new RangeError((0, errors_1.message)('modularExponentiationNonnegativeExponent'));
+    }
+    let result = 1n % modulus;
+    let factor = mod(base, modulus);
+    let power = exponent;
+    while (power > 0n) {
+        if (power % 2n === 1n) {
+            result = (result * factor) % modulus;
+        }
+        factor = (factor * factor) % modulus;
+        power /= 2n;
+    }
+    return result;
+}
+/**
+ * Finds the multiplicative inverse of a modulo m.
+ *
+ * Returns -1 when the inverse does not exist. The extended Euclidean algorithm keeps
+ * the operation exact for bigint inputs without scanning every possible residue.
+ *
+ * @param a
+ * @param m
+ * @returns
+ */
+function invMod(a, m) {
+    let retval = -1n;
+    const modulus = abs(m);
+    if (modulus !== 0n) {
+        let t = 0n;
+        let nextT = 1n;
+        let r = modulus;
+        let nextR = mod(a, modulus);
+        while (nextR !== 0n) {
+            const q = r / nextR;
+            [t, nextT] = [nextT, t - q * nextT];
+            [r, nextR] = [nextR, r - q * nextR];
+        }
+        if (r === 1n) {
+            retval = mod(t, modulus);
+        }
+    }
+    return retval;
+}
+/**
+ * Gets the product given a number range start and finish
+ *
+ * @param start The start of the range
+ * @param end The end of the range
+ * @param step The increment step
+ */
+function productInRange(start, end, step = 1) {
+    let retval = BigInt(start);
+    let n = BigInt(start);
+    const i = BigInt(step);
+    while (n < end) {
+        n += i;
+        retval *= n;
+    }
+    return retval;
+}
+/**
+ * Returns the largest of a set of bigints
+ * @param args
+ * @returns
+ */
+function max(...args) {
+    if (args.length < 1) {
+        // Math.max() for Number returns -Infinity for empty lists,
+        // but BigInt can't represent Infinity, so throwing an error or
+        // handling as per application logic is necessary.
+        throw new Error((0, errors_1.message)('maxBigIntRequiresArgument'));
+    }
+    let max = args[0];
+    for (let i = 1; i < args.length; i++) {
+        if (args[i] > max) {
+            max = args[i];
+        }
+    }
+    return max;
+}
+/**
+ * Returns the smallest of a set of bigints
+ * @param args
+ * @returns
+ */
+function min(...args) {
+    if (args.length === 0) {
+        // Math.min() returns Infinity for no arguments, but BigInt cannot represent Infinity.
+        // It's often better to throw an error or handle the empty case explicitly.
+        throw new Error((0, errors_1.message)('minBigIntEmpty'));
+    }
+    let min = args[0];
+    for (let i = 1; i < args.length; i++) {
+        if (args[i] < min) {
+            min = args[i];
+        }
+    }
+    return min;
+}
+function recoverCoeffsZ(num, primes) {
+    const variables = Object.keys(primes).sort((a, b) => {
+        if (/\w+[-+]\w+/.test(a)) {
+            return 1;
+        }
+        return a.localeCompare(b);
+    });
+    const map = {};
+    // Loop though the variables
+    for (const v of variables) {
+        const prime = primes[v];
+        let n = 0;
+        let canDivide = true;
+        // Divide out the max until you hit a remainder
+        do {
+            const q = num / prime;
+            if (q === 0n) {
+                break;
+            }
+            const r = num % q;
+            if (r === 0n) {
+                n++;
+                num = q;
+            }
+            else {
+                canDivide = false;
+            }
+        } while (canDivide);
+        // Mark the power of the variable found
+        map[v] = n;
+    }
+    // Put the rest to the coefficient
+    map['coeff'] = num;
+    return map;
+}
+/**
+ * The binomial function using bigint
+ * @param n
+ * @param k
+ * @returns
+ */
+function binom(n, k) {
+    if (n < 0n) {
+        throw new RangeError((0, errors_1.message)('binomBigIntNonnegativeN'));
+    }
+    if (k < 0n || k > n) {
+        return 0n;
+    }
+    if (k === 0n || k === n) {
+        return 1n;
+    }
+    let kk = k;
+    const nMinusK = n - k;
+    if (nMinusK < kk) {
+        kk = nMinusK;
+    }
+    let result = 1n;
+    for (let i = 1n; i <= kk; i++) {
+        result = (result * (n - kk + i)) / i;
+    }
+    return result;
+}
+/**
+ * Computes the LCM of an array of positive bigints.
+ */
+function bigintLCM(values) {
+    if (values.length === 0) {
+        return 1n;
+    }
+    function gcd(a, b) {
+        a = a < 0n ? -a : a;
+        b = b < 0n ? -b : b;
+        while (b !== 0n) {
+            [a, b] = [b, a % b];
+        }
+        return a;
+    }
+    function lcm(a, b) {
+        return (a / gcd(a, b)) * b;
+    }
+    let result = values[0];
+    for (let i = 1; i < values.length; i++) {
+        result = lcm(result, values[i]);
+    }
+    return result;
+}

package/output/core/functions/bigint/primeFactor.d.ts

@@ -0,0 +1,51 @@
+export type factorCountType = Record<string, bigint>;
+/**
+ * Calculates and array of prime factors
+ *
+ * @see https://stackoverflow.com/questions/39899072/how-can-i-find-the-prime-factors-of-an-integer-in-javascript by @TheChiporpoise
+ * @param num
+ * @returns
+ */
+export declare function isPrimeBig(num: bigint): boolean;
+/** Returns the least prime greater than or equal to start. */
+export declare function nextPrimeBig(start: bigint): bigint;
+/**
+ * Fast prime factorization using trial division with optimizations
+ */
+export declare function trialDivisionBig(n: bigint): bigint[];
+/**
+ * Pollard's rho algorithm for faster factorization of large numbers
+ */
+export declare function pollardRhoBig(n: bigint): bigint;
+/**
+ * Advanced factorization using Pollard's rho for large numbers
+ */
+export declare function primeFactorsBig(n: bigint, toNumbers: true): {
+    sign: number;
+    factors: number[];
+};
+export declare function primeFactorsBig(n: bigint, toNumbers: false | void): {
+    sign: number;
+    factors: bigint[];
+};
+/**
+ * Places the prime factors in an object and counts their occurrences
+ *
+ * @param n
+ */
+export declare function primeFactorCounts(n: bigint): factorCountType;
+/**
+ * Merges two factor counts into one object
+ *
+ * @param a
+ * @param b
+ */
+export declare function mergeFactors(a: factorCountType, b: factorCountType): factorCountType;
+/**
+ * Gets prime factors that can be used to create a number. The number one is
+ * included since 1 * n is a possible combination.
+ *
+ * @param n The number for which the factors are being retrieved
+ * @returns
+ */
+export declare function getFactors(n: number | bigint): number[];