nerdamer 2.0.0-rc.1 → 2.0.0

package/output/core/fullFunctions.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Registers the complete Nerdamer parser function surface.
+ *
+ * Core parser modules do not import higher-level mathematical domains. Entry points
+ * and consumers that require the complete Nerdamer notation surface call this registration function.
+ */
+export declare function registerNerdamerFunctions(): void;

package/output/core/fullFunctions.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerNerdamerFunctions = registerNerdamerFunctions;
+const dispatch_1 = require("../algebra/dispatch");
+const dispatch_2 = require("../calculus/dispatch");
+const dispatch_3 = require("../math/dispatch");
+const dispatch_4 = require("../solve/dispatch");
+const dispatch_5 = require("./classes/assumption/dispatch");
+const dispatch_6 = require("./classes/matrix/dispatch");
+const dispatch_7 = require("./classes/parser/scripting/dispatch");
+const dispatch_8 = require("./classes/polynomial/dispatch");
+const dispatch_9 = require("./classes/vector/dispatch");
+const complex_dispatch_1 = require("./functions/complex.dispatch");
+/**
+ * Registers the complete Nerdamer parser function surface.
+ *
+ * Core parser modules do not import higher-level mathematical domains. Entry points
+ * and consumers that require the complete Nerdamer notation surface call this registration function.
+ */
+function registerNerdamerFunctions() {
+    (0, dispatch_7.loadScriptingFunctions)();
+    (0, dispatch_5.loadAssumptionFunctions)();
+    (0, dispatch_6.loadMatrixFunctions)();
+    (0, dispatch_9.loadVectorFunctions)();
+    (0, complex_dispatch_1.loadComplexFunctions)();
+    (0, dispatch_8.loadPolynomialFunctions)();
+    (0, dispatch_3.loadMathFunctions)();
+    (0, dispatch_1.loadAlgebraFunctions)();
+    (0, dispatch_2.loadCalculusFunctions)();
+    (0, dispatch_4.loadSolveFunctions)();
+}

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

@@ -45,7 +45,7 @@ export declare function convert(numStr: string): [bigint, bigint];
  * @param n
  * @returns -1 if negative and 1 for positive and 0 for zero
  */
-export declare function sign(n: bigint): 0 | 1 | -1;
+export declare function sign(n: bigint): 1 | 0 | -1;
 /**
  * Checks if a bigint is an even number
  *
@@ -53,6 +53,12 @@ export declare function sign(n: bigint): 0 | 1 | -1;
  * @returns
  */
 export declare function isEven(n: bigint): boolean;
+/**
+ * Returns the floor of the exact square root of a non-negative bigint.
+ */
+export declare function integerSquareRoot(value: bigint): bigint;
+/** Returns the least bigint whose square is at least value. */
+export declare function ceilIntegerSquareRoot(value: bigint): bigint;
 /**
  * Computes the nth Fibonacci number exactly using fast doubling.
  *
@@ -74,6 +80,12 @@ export declare const factorial: (n: number | bigint) => bigint;
  * @returns
  */
 export declare function mod(a: bigint, b: bigint): bigint;
+/**
+ * Raises a bigint base to a non-negative bigint exponent modulo a positive modulus.
+ *
+ * Binary exponentiation keeps every intermediate value in bigint modular arithmetic.
+ */
+export declare function powMod(base: bigint, exponent: bigint, modulus: bigint): bigint;
 /**
  * Finds the multiplicative inverse of a modulo m.
  *

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

@@ -9,8 +9,11 @@ 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;
@@ -18,6 +21,7 @@ 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");
 /**
@@ -128,6 +132,30 @@ function sign(n) {
 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.
  *
@@ -183,7 +211,7 @@ exports.factorial = (function () {
             n = Number(n);
         }
         if (n < 0) {
-            throw new RangeError('Factorial is undefined for negative integers.');
+            throw new RangeError((0, errors_1.message)('factorialNegativeUndefined'));
         }
         // If there's a cached version return that instead
         if (typeof factorialCache[n] != 'undefined') {
@@ -219,6 +247,30 @@ function mod(a, 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.
  *
@@ -275,7 +327,7 @@ function max(...args) {
         // 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('maxBigInt() requires at least one argument');
+        throw new Error((0, errors_1.message)('maxBigIntRequiresArgument'));
     }
     let max = args[0];
     for (let i = 1; i < args.length; i++) {
@@ -294,7 +346,7 @@ 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('Min of empty list is not defined for BigInt.');
+        throw new Error((0, errors_1.message)('minBigIntEmpty'));
     }
     let min = args[0];
     for (let i = 1; i < args.length; i++) {
@@ -347,7 +399,7 @@ function recoverCoeffsZ(num, primes) {
  */
 function binom(n, k) {
     if (n < 0n) {
-        throw new RangeError('binomBigInt: n must be non-negative');
+        throw new RangeError((0, errors_1.message)('binomBigIntNonnegativeN'));
     }
     if (k < 0n || k > n) {
         return 0n;

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

@@ -7,6 +7,8 @@ export type factorCountType = Record<string, bigint>;
  * @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
  */

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isPrimeBig = isPrimeBig;
+exports.nextPrimeBig = nextPrimeBig;
 exports.trialDivisionBig = trialDivisionBig;
 exports.pollardRhoBig = pollardRhoBig;
 exports.primeFactorsBig = primeFactorsBig;
@@ -73,18 +74,6 @@ function isPrimeBig(num) {
         r++;
         d /= 2n;
     }
-    const modPow = (base, exp, mod) => {
-        let result = 1n;
-        base %= mod;
-        while (exp > 0n) {
-            if (exp % 2n === 1n) {
-                result = (result * base) % mod;
-            }
-            base = (base * base) % mod;
-            exp /= 2n;
-        }
-        return result;
-    };
     // These witnesses are deterministic for every unsigned 64-bit integer. For larger
     // BigInts they remain a stable probable-prime test rather than a randomized result.
     const witnesses = num < 18446744073709551616n
@@ -95,7 +84,7 @@ function isPrimeBig(num) {
         if (a < 2n) {
             continue;
         }
-        let x = modPow(a, d, num);
+        let x = (0, bigint_1.powMod)(a, d, num);
         if (x === 1n || x === num - 1n) {
             continue;
         }
@@ -113,6 +102,17 @@ function isPrimeBig(num) {
     }
     return true;
 }
+/** Returns the least prime greater than or equal to start. */
+function nextPrimeBig(start) {
+    let candidate = start <= 2n ? 2n : start;
+    if (candidate > 2n && candidate % 2n === 0n) {
+        candidate++;
+    }
+    while (!isPrimeBig(candidate)) {
+        candidate += candidate === 2n ? 1n : 2n;
+    }
+    return candidate;
+}
 /**
  * Fast prime factorization using trial division with optimizations
  */

package/output/core/functions/build/definitions.js

@@ -69,6 +69,12 @@ exports.definitions = {
     min: [(...args) => Math.min(...args)],
     avg: [(...args) => args.reduce((total, value) => total + value, 0) / args.length],
     heaviside: [numeric_1.heaviside],
+    step: [x => (Number.isNaN(x) ? NaN : x < 0 ? 0 : 1)],
+    rect: [x => {
+            const a = Math.abs(x);
+            return a < 0.5 ? 1 : a === 0.5 ? 0.5 : 0;
+        }],
+    tri: [x => Math.max(1 - Math.abs(x), 0)],
     // Complex-component helpers are limited to real JavaScript-number inputs. This is
     // faithful to buildFunction's scalar runtime function without pretending to provide
     // a JavaScript-number representation for genuinely complex values.

package/output/core/functions/complex.d.ts

@@ -56,7 +56,7 @@ export declare function arg(x: ExpressionInput): Expression;
  * Distributes over sums, products, integer powers, and powers whose
  * constant base is known not to lie on the principal logarithm's branch cut.
  *
- * @param expr - The expression to conjugate
+ * @param x - The expression to conjugate
  * @returns The complex conjugate of the expression
  *
  * @example
@@ -76,7 +76,7 @@ export declare function conjugate(x: ExpressionInput): Expression;
  *
  * Useful for branch cut decisions in sqrt, log, and power simplification.
  *
- * @param expr - The expression to evaluate the complex sign of
+ * @param x - The expression to evaluate the complex sign of
  * @returns 1, -1, 0, or an unevaluated csgn expression
  *
  * @example

package/output/core/functions/complex.dispatch.d.ts

@@ -0,0 +1 @@
+export declare function loadComplexFunctions(): void;

package/output/core/functions/complex.dispatch.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadComplexFunctions = loadComplexFunctions;
+const dispatch_1 = require("../dispatch");
+const complex_1 = require("./complex");
+function loadComplexFunctions() {
+    Object.assign(dispatch_1.mathFunctionRegistry, {
+        imagpart: (0, dispatch_1.systemFunction)({ fn: complex_1.imagPart, minArgs: 1, maxArgs: 1, distElWise: true }),
+        realpart: (0, dispatch_1.systemFunction)({ fn: complex_1.realPart, minArgs: 1, maxArgs: 1, distElWise: true }),
+        polarform: (0, dispatch_1.systemFunction)({ fn: complex_1.polarForm, minArgs: 1, maxArgs: 1, distElWise: true }),
+        rectform: (0, dispatch_1.systemFunction)({ fn: complex_1.rectForm, minArgs: 1, maxArgs: 1, distElWise: true }),
+        arg: (0, dispatch_1.systemFunction)({ fn: complex_1.arg, minArgs: 1, maxArgs: 1, distElWise: true }),
+        csgn: (0, dispatch_1.systemFunction)({ fn: complex_1.csgn, minArgs: 1, maxArgs: 1, distElWise: true }),
+        conjugate: (0, dispatch_1.systemFunction)({ fn: complex_1.conjugate, minArgs: 1, maxArgs: 1, distElWise: true }),
+    });
+}

package/output/core/functions/complex.js

@@ -60,12 +60,12 @@ function realPart(a) {
     // other functions without complex inputs, and keep explicitly complex
     // function components symbolic rather than treating them as zero.
     else if (x.isComplexComponentFunction()) {
-        retval = new Expression_1.Expression(x);
+        retval = x.copy();
     }
     else if (x.isFunction()) {
         retval = x.isComplex()
             ? Expression_1.Expression.toFunction(constants_1.REALPART, [x])
-            : new Expression_1.Expression(x);
+            : x.copy();
     }
     // Decompose products through their complex factors while preserving real
     // factors as an outer scale.
@@ -111,13 +111,13 @@ function realPart(a) {
     else if (x.isConstant() ||
         (x.isVAR() && !x.isI()) ||
         (x.isProduct() && !x.isComplex())) {
-        retval = new Expression_1.Expression(a);
+        retval = a.copy();
     }
     // Deal with x+1, y+y^2, ...
     else if (x.isSum()) {
         // Check if the sum has a power attached - if so, treat as single term
         if (!x.getPower().isOne()) {
-            retval = new Expression_1.Expression(a);
+            retval = a.copy();
         }
         else {
             retval = (0, shortcuts_1.zero)();
@@ -296,7 +296,7 @@ function polarForm(x) {
     let retval;
     if (x.isNUM() || (x.isI() && x.isLinear())) {
         // The polarform of a number is just the number
-        retval = new Expression_1.Expression(x);
+        retval = x.copy();
     }
     else {
         // Get r and theta. Theta will come back as (atan(x) or a*pi/n)
@@ -390,7 +390,7 @@ function arg(x) {
  * Distributes over sums, products, integer powers, and powers whose
  * constant base is known not to lie on the principal logarithm's branch cut.
  *
- * @param expr - The expression to conjugate
+ * @param x - The expression to conjugate
  * @returns The complex conjugate of the expression
  *
  * @example
@@ -452,7 +452,7 @@ function conjugate(x) {
  *
  * Useful for branch cut decisions in sqrt, log, and power simplification.
  *
- * @param expr - The expression to evaluate the complex sign of
+ * @param x - The expression to evaluate the complex sign of
  * @returns 1, -1, 0, or an unevaluated csgn expression
  *
  * @example

package/output/core/functions/decimal.js

@@ -14,6 +14,7 @@ exports.Chi = Chi;
 exports.Ei = Ei;
 exports.Li = Li;
 const decimal_js_1 = __importDefault(require("decimal.js"));
+const errors_1 = require("../errors");
 const bigint_1 = require("./bigint/bigint");
 /*
  * TODO: Currently only up to a 100 digits. This will need to be calculated in the future.
@@ -73,7 +74,7 @@ function erf(x) {
             sum = result;
             k++;
             if (k > max) {
-                throw new Error('erf not converging. Exiting!');
+                throw new Error((0, errors_1.message)('erfConvergenceFailed'));
             }
         }
         let retval = decimal_js_1.default.min(twoOverSqrtPi.times(sum), 1);

package/output/core/functions/expand/expand.js

@@ -326,7 +326,7 @@ function expand(x) {
     x = unwrap(x);
     if (isExpandable(x)) {
         if (x.isNUM() || x.isVAR()) {
-            retval = new Expression_1.Expression(x);
+            retval = x.copy();
         }
         else {
             // At the very least the multiplier must be distributed along the expression
@@ -370,7 +370,7 @@ function expand(x) {
         }
     }
     else {
-        retval = new Expression_1.Expression(x);
+        retval = x.copy();
     }
     return retval;
 }

package/output/core/functions/numeric.d.ts

@@ -65,7 +65,7 @@ export declare function LCM(...args: number[]): number;
 /** Computes the modular multiplicative inverse for integer JavaScript numbers. */
 export declare function modInv(a: number, p: number): number;
 /** Returns `1` for a prime safe integer and `0` otherwise. */
-export declare function isPrime(x: number): 0 | 1;
+export declare function isPrime(x: number): 1 | 0;
 /** Numeric half-maximum convention for the Heaviside step function. */
 export declare function heaviside(x: number): number;
 /**

package/output/core/functions/string.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.scientificToDecimal = scientificToDecimal;
 exports.decimalSplit = decimalSplit;
 exports.format = format;
+const errors_1 = require("../errors");
 /**
  * Removes the minus sign from the beginning of the string
  *
@@ -67,7 +68,7 @@ function scientificToDecimal(str) {
 function decimalSplit(str) {
     const parts = str.split('.');
     if (parts.length > 2) {
-        throw new SyntaxError(`Invalid decimal value: ${str}`);
+        throw new SyntaxError((0, errors_1.message)('invalidDecimalValue', { value: str }));
     }
     if (parts.length === 1) {
         parts.push('');

package/output/core/functions/subst.js

@@ -29,7 +29,7 @@ function prodSubst(expression, value, withValue, includeNumeric) {
             // First check the multipliers. This has to be an integer
             const m = expression.getMultiplier().div(value.getMultiplier());
             if (!m.isInteger() && !Settings_1.Settings.ALLOW_RAT_SUBS) {
-                retval = new Expression_1.Expression(expression);
+                retval = expression.copy();
             }
             else {
                 let power;
@@ -227,7 +227,7 @@ function subst(expression, value, withValue, includeNumeric = false) {
     }
     else if (expression.isFunction()) {
         if (expression.value === value.value) {
-            retval = new Expression_1.Expression(withValue);
+            retval = withValue.copy();
         }
         else {
             retval = Expression_1.Expression.Function(expression.name);
@@ -439,21 +439,29 @@ function uUnSub(expression, map) {
 function uSubConstants(expression, map) {
     map ??= {};
     const constants = new Set();
-    // forEveryElement returns immediately for a VAR root. Check the root first so standalone
-    // mathematical constants and their powers are promoted just like the same constants nested
-    // inside sums and products.
-    if (expression.isVAR() && (expression.isConstant() || expression.isI())) {
-        constants.add(expression.value);
-    }
-    expression.forEveryElement(e => {
+    function collectConstants(current) {
         // The imaginary unit is a mathematical constant, but isConstant() only recognizes parser
         // constants such as pi and e. Promote i here as well so polynomial factorization does not
         // treat it as an ordinary polynomial variable.
-        if (e.isVAR() && (e.isConstant() || e.isI())) {
-            constants.add(e.value);
+        if (current.isVAR() && (current.isConstant() || current.isI())) {
+            constants.add(current.value);
         }
-        return e;
-    });
+        if (current.args) {
+            for (const argument of current.args) {
+                collectConstants(argument);
+            }
+        }
+        if (current.elements) {
+            for (const element of Object.values(current.elements)) {
+                collectConstants(element);
+            }
+        }
+        if (current.isEXP()) {
+            collectConstants(current.getBase());
+            collectConstants(current.getPower());
+        }
+    }
+    collectConstants(expression);
     for (const c of constants) {
         [expression, map] = uSub(expression, (0, helpers_1._)(c), map);
     }

package/output/core/parserFunctions.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Registers the function surface supplied by the parser package.
+ *
+ * Algebra, calculus, and solving are higher-level CAS domains and are composed by
+ * the full package rather than the parser package.
+ */
+export declare function loadParserFunctions(): void;

package/output/core/parserFunctions.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadParserFunctions = loadParserFunctions;
+const dispatch_1 = require("../math/dispatch");
+const dispatch_2 = require("./classes/assumption/dispatch");
+const dispatch_3 = require("./classes/matrix/dispatch");
+const dispatch_4 = require("./classes/parser/scripting/dispatch");
+const dispatch_5 = require("./classes/polynomial/dispatch");
+const dispatch_6 = require("./classes/vector/dispatch");
+const complex_dispatch_1 = require("./functions/complex.dispatch");
+/**
+ * Registers the function surface supplied by the parser package.
+ *
+ * Algebra, calculus, and solving are higher-level CAS domains and are composed by
+ * the full package rather than the parser package.
+ */
+function loadParserFunctions() {
+    (0, dispatch_4.loadScriptingFunctions)();
+    (0, dispatch_2.loadAssumptionFunctions)();
+    (0, dispatch_3.loadMatrixFunctions)();
+    (0, dispatch_6.loadVectorFunctions)();
+    (0, dispatch_5.loadPolynomialFunctions)();
+    (0, complex_dispatch_1.loadComplexFunctions)();
+    (0, dispatch_1.loadMathFunctions)();
+}