nerdamer 2.0.0-rc.1 → 2.0.0

package/output/math/defint/defintNative.js

@@ -1,18 +1,7 @@
 "use strict";
-/**
- * Adaptive Simpson definite integration using native `number` arithmetic.
- *
- * Same algorithm as the Decimal.js version (adaptive Simpson with Richardson
- * extrapolation, iterative stack) but 50-100x faster for typical integrands.
- *
- * Features:
- * - Adaptive error control with combined absolute + relative tolerance
- * - Breakpoint segmentation for piecewise/abs/kink functions
- * - Infinite bounds via variable substitution
- * - Best-effort singularity handling
- */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.definiteIntegrateNative = definiteIntegrateNative;
+const errors_1 = require("../../core/errors");
 const DEFAULT_TOL = 1e-12;
 const DEFAULT_MAX_DEPTH = 50;
 const DEFAULT_MAX_EVALUATIONS = 100_000;
@@ -39,11 +28,11 @@ function withFiniteBounds(f, aIn, bIn, tolAbs, tolRel, maxDepth, maxEvals, singu
     let evals = 0;
     const evalF = (x) => {
         if (++evals > maxEvals) {
-            throw new Error(`defint: maxEvals exceeded (${maxEvals}).`);
+            throw new Error((0, errors_1.message)('defintMaxEvals', { max: String(maxEvals) }));
         }
         const y = f(x);
         if (singular === 'strict' && !isFinite(y)) {
-            throw new Error(`defint: non-finite f(x) at x=${x}`);
+            throw new Error((0, errors_1.message)('defintNonFiniteValue', { x: String(x) }));
         }
         return y;
     };
@@ -70,7 +59,7 @@ function withFiniteBounds(f, aIn, bIn, tolAbs, tolRel, maxDepth, maxEvals, singu
                 const x = singularAtLeft ? a + span * u * u : b - span * u * u;
                 const y = f(x) * 2 * span * u;
                 if (!isFinite(y)) {
-                    throw new Error(`defint: endpoint singularity could not be regularized near x=${x}`);
+                    throw new Error((0, errors_1.message)('defintEndpointSingularity', { x: String(x) }));
                 }
                 return y;
             };
@@ -118,7 +107,7 @@ function withFiniteBounds(f, aIn, bIn, tolAbs, tolRel, maxDepth, maxEvals, singu
                 !isFinite(fr.fm) ||
                 !isFinite(fr.fb))) {
             if (fr.depth >= maxDepth || fr.singularTries >= MAX_SINGULAR_TRIES) {
-                throw new Error(`defint: singular/non-finite encountered near [${a0}, ${b0}]`);
+                throw new Error((0, errors_1.message)('defintSingularity', { a: String(a0), b: String(b0) }));
             }
             const nextDepth = fr.depth + 1;
             const childTolAbs = fr.tolAbs / 2;
@@ -233,7 +222,7 @@ function definiteIntegrateNative(f, a, b, options = {}) {
     const isInfA = !isFinite(a) && !isNaN(a);
     const isInfB = !isFinite(b) && !isNaN(b);
     if ((isInfA || isInfB) && !allowInfinite) {
-        throw new Error('defint: infinite bounds require allowInfinite: true');
+        throw new Error((0, errors_1.message)('defintInfiniteBounds'));
     }
     // ── Infinite-bound substitutions ─────────────────────────────
     if (allowInfinite && (isInfA || isInfB)) {
@@ -269,7 +258,7 @@ function definiteIntegrateNative(f, a, b, options = {}) {
             };
             return withFiniteBounds(g, eps, 1 - eps, tolAbs, tolRel, maxDepth, maxEvals, singular);
         }
-        throw new Error('defint: unsupported infinite bound configuration');
+        throw new Error((0, errors_1.message)('defintUnsupportedInfiniteBounds'));
     }
     // ── Finite bounds with optional breakpoints ──────────────────
     const lo = Math.min(a, b);

package/output/math/dispatch.d.ts

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

package/output/math/dispatch.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadMathFunctions = loadMathFunctions;
+const constants_1 = require("../core/classes/parser/constants");
+const evaluate_1 = require("../core/classes/parser/scripting/evaluate");
+const dispatch_1 = require("../core/dispatch");
+const expand_1 = require("../core/functions/expand/expand");
+const subst_1 = require("../core/functions/subst");
+const geometry_1 = require("./geometry");
+const math_1 = require("./math");
+const trig_1 = require("./trig");
+const trunc_1 = require("./trunc");
+const utils_1 = require("./utils");
+function loadMathFunctions() {
+    Object.assign(dispatch_1.mathFunctionRegistry, {
+        cos: (0, dispatch_1.systemFunction)({ fn: trig_1.cos, minArgs: 1, maxArgs: 1, distElWise: true }),
+        sin: (0, dispatch_1.systemFunction)({ fn: trig_1.sin, minArgs: 1, maxArgs: 1, distElWise: true }),
+        tan: (0, dispatch_1.systemFunction)({ fn: trig_1.tan, minArgs: 1, maxArgs: 1, distElWise: true }),
+        sec: (0, dispatch_1.systemFunction)({ fn: trig_1.sec, minArgs: 1, maxArgs: 1, distElWise: true }),
+        csc: (0, dispatch_1.systemFunction)({ fn: trig_1.csc, minArgs: 1, maxArgs: 1, distElWise: true }),
+        cot: (0, dispatch_1.systemFunction)({ fn: trig_1.cot, minArgs: 1, maxArgs: 1, distElWise: true }),
+        acos: (0, dispatch_1.systemFunction)({ fn: trig_1.acos, minArgs: 1, maxArgs: 1, distElWise: true }),
+        asin: (0, dispatch_1.systemFunction)({ fn: trig_1.asin, minArgs: 1, maxArgs: 1, distElWise: true }),
+        atan: (0, dispatch_1.systemFunction)({ fn: trig_1.atan, minArgs: 1, maxArgs: 1, distElWise: true }),
+        asec: (0, dispatch_1.systemFunction)({ fn: trig_1.asec, minArgs: 1, maxArgs: 1, distElWise: true }),
+        acsc: (0, dispatch_1.systemFunction)({ fn: trig_1.acsc, minArgs: 1, maxArgs: 1, distElWise: true }),
+        acot: (0, dispatch_1.systemFunction)({ fn: trig_1.acot, minArgs: 1, maxArgs: 1, distElWise: true }),
+        atan2: (0, dispatch_1.systemFunction)({ fn: trig_1.atan2, minArgs: 2, maxArgs: 2, distElWise: true }),
+        cosh: (0, dispatch_1.systemFunction)({ fn: trig_1.cosh, minArgs: 1, maxArgs: 1, distElWise: true }),
+        sinh: (0, dispatch_1.systemFunction)({ fn: trig_1.sinh, minArgs: 1, maxArgs: 1, distElWise: true }),
+        tanh: (0, dispatch_1.systemFunction)({ fn: trig_1.tanh, minArgs: 1, maxArgs: 1, distElWise: true }),
+        sech: (0, dispatch_1.systemFunction)({ fn: trig_1.sech, minArgs: 1, maxArgs: 1, distElWise: true }),
+        csch: (0, dispatch_1.systemFunction)({ fn: trig_1.csch, minArgs: 1, maxArgs: 1, distElWise: true }),
+        coth: (0, dispatch_1.systemFunction)({ fn: trig_1.coth, minArgs: 1, maxArgs: 1, distElWise: true }),
+        acosh: (0, dispatch_1.systemFunction)({ fn: trig_1.acosh, minArgs: 1, maxArgs: 1, distElWise: true }),
+        asinh: (0, dispatch_1.systemFunction)({ fn: trig_1.asinh, minArgs: 1, maxArgs: 1, distElWise: true }),
+        atanh: (0, dispatch_1.systemFunction)({ fn: trig_1.atanh, minArgs: 1, maxArgs: 1, distElWise: true }),
+        asech: (0, dispatch_1.systemFunction)({ fn: trig_1.asech, minArgs: 1, maxArgs: 1, distElWise: true }),
+        acsch: (0, dispatch_1.systemFunction)({ fn: trig_1.acsch, minArgs: 1, maxArgs: 1, distElWise: true }),
+        acoth: (0, dispatch_1.systemFunction)({ fn: trig_1.acoth, minArgs: 1, maxArgs: 1, distElWise: true }),
+        line: (0, dispatch_1.systemFunction)({ fn: geometry_1.line, minArgs: 2, maxArgs: 3, distElWise: false }),
+        abs: (0, dispatch_1.systemFunction)({ fn: math_1.abs, minArgs: 1, maxArgs: 1, distElWise: true }),
+        sqrt: (0, dispatch_1.systemFunction)({ fn: math_1.sqrt, minArgs: 1, maxArgs: 1, distElWise: true }),
+        nthroot: (0, dispatch_1.systemFunction)({ fn: math_1.nthroot, minArgs: 2, maxArgs: 2, distElWise: true }),
+        cbrt: (0, dispatch_1.systemFunction)({ fn: math_1.cbrt, minArgs: 1, maxArgs: 1, distElWise: true }),
+        subst: (0, dispatch_1.systemFunction)({ fn: subst_1.subst, minArgs: 3, maxArgs: 3, distElWise: true }),
+        log: (0, dispatch_1.systemFunction)({ fn: math_1.log, minArgs: 1, maxArgs: 2, distElWise: true }),
+        log10: (0, dispatch_1.systemFunction)({ fn: math_1.log10, minArgs: 1, maxArgs: 1, distElWise: true }),
+        radians: (0, dispatch_1.systemFunction)({ fn: math_1.radians, minArgs: 1, maxArgs: 1, distElWise: true }),
+        degrees: (0, dispatch_1.systemFunction)({ fn: math_1.degrees, minArgs: 1, maxArgs: 1, distElWise: true }),
+        exp: (0, dispatch_1.systemFunction)({ fn: math_1.exp, minArgs: 1, maxArgs: 1, distElWise: true }),
+        erf: (0, dispatch_1.systemFunction)({ fn: math_1.erf, minArgs: 1, maxArgs: 1, distElWise: true }),
+        erfc: (0, dispatch_1.systemFunction)({ fn: math_1.erfc, minArgs: 1, maxArgs: 1, distElWise: true }),
+        gamma: (0, dispatch_1.systemFunction)({ fn: math_1.gamma, minArgs: 1, maxArgs: 1, distElWise: true }),
+        gamma_incomplete: (0, dispatch_1.systemFunction)({ fn: math_1.gammaIncomplete, minArgs: 2, maxArgs: 2, distElWise: true }),
+        gamma_incomplete_lower: (0, dispatch_1.systemFunction)({ fn: math_1.gammaIncompleteLower, minArgs: 2, maxArgs: 2, distElWise: true }),
+        [constants_1.DIRAC]: (0, dispatch_1.systemFunction)({ fn: math_1.dirac, minArgs: 1, maxArgs: 1, distElWise: true }),
+        [constants_1.HEAVISIDE]: (0, dispatch_1.systemFunction)({ fn: math_1.heaviside, minArgs: 1, maxArgs: 1, distElWise: true }),
+        step: (0, dispatch_1.systemFunction)({ fn: math_1.step, minArgs: 1, maxArgs: 1, distElWise: true }),
+        rect: (0, dispatch_1.systemFunction)({ fn: math_1.rect, minArgs: 1, maxArgs: 1, distElWise: true }),
+        tri: (0, dispatch_1.systemFunction)({ fn: math_1.tri, minArgs: 1, maxArgs: 1, distElWise: true }),
+        continued_fraction: (0, dispatch_1.systemFunction)({ fn: utils_1.continuedFraction, minArgs: 1, maxArgs: 2, distElWise: false }),
+        scientific: (0, dispatch_1.systemFunction)({ fn: math_1.scientific, minArgs: 1, maxArgs: 2, distElWise: true }),
+        hypot: (0, dispatch_1.systemFunction)({ fn: geometry_1.hypot, minArgs: 2, maxArgs: 2, distElWise: true }),
+        [constants_1.FACTORIAL]: (0, dispatch_1.systemFunction)({ fn: math_1.factorial, minArgs: 1, maxArgs: 1, distElWise: true }),
+        factorial: (0, dispatch_1.systemFunction)({ fn: math_1.factorial, minArgs: 1, maxArgs: 1, distElWise: true }),
+        [constants_1.DOUBLE_FACTORIAL]: (0, dispatch_1.systemFunction)({ fn: math_1.doubleFactorial, minArgs: 1, maxArgs: 1, distElWise: true }),
+        expand: (0, dispatch_1.systemFunction)({ fn: expand_1.expand, minArgs: 1, maxArgs: 1, distElWise: true }),
+        numeric: (0, dispatch_1.systemFunction)({
+            fn: evaluate_1.numeric,
+            minArgs: 1,
+            maxArgs: 2,
+            equationArgs: [0],
+            distElWise: false,
+            deferArguments: true,
+        }),
+        round: (0, dispatch_1.systemFunction)({ fn: math_1.round, minArgs: 1, maxArgs: 2, distElWise: true }),
+        sign: (0, dispatch_1.systemFunction)({ fn: math_1.sign, minArgs: 1, maxArgs: 1, distElWise: true }),
+        floor: (0, dispatch_1.systemFunction)({ fn: math_1.floor, minArgs: 1, maxArgs: 1, distElWise: true }),
+        ceil: (0, dispatch_1.systemFunction)({ fn: math_1.ceiling, minArgs: 1, maxArgs: 1, distElWise: true }),
+        ceiling: (0, dispatch_1.systemFunction)({ fn: math_1.ceiling, minArgs: 1, maxArgs: 1, distElWise: true }),
+        trunc: (0, dispatch_1.systemFunction)({ fn: trunc_1.trunc, minArgs: 1, maxArgs: 1, distElWise: true }),
+        mod: (0, dispatch_1.systemFunction)({ fn: math_1.mod, minArgs: 2, maxArgs: 2, distElWise: true }),
+        modinv: (0, dispatch_1.systemFunction)({ fn: math_1.modInv, minArgs: 2, maxArgs: 2, distElWise: true }),
+        parens: (0, dispatch_1.systemFunction)({ fn: math_1.parens, minArgs: 1, maxArgs: 1, distElWise: true }),
+        count: (0, dispatch_1.systemFunction)({ fn: utils_1.count, minArgs: 1, maxArgs: 1, distElWise: false }),
+        size: (0, dispatch_1.systemFunction)({ fn: utils_1.size, minArgs: 1, maxArgs: 1, distElWise: false }),
+        contains: (0, dispatch_1.systemFunction)({ fn: math_1.contains, minArgs: 2, maxArgs: 2, distElWise: false }),
+        max: (0, dispatch_1.systemFunction)({ fn: math_1.max, minArgs: 2, maxArgs: -1, distElWise: true }),
+        min: (0, dispatch_1.systemFunction)({ fn: math_1.min, minArgs: 2, maxArgs: -1, distElWise: true }),
+        isprime: (0, dispatch_1.systemFunction)({ fn: utils_1.isprime, minArgs: 1, maxArgs: 1, distElWise: true }),
+        fib: (0, dispatch_1.systemFunction)({ fn: math_1.fibonacci, minArgs: 1, maxArgs: 1, distElWise: true }),
+        sinc: (0, dispatch_1.systemFunction)({ fn: math_1.sinc, minArgs: 1, maxArgs: 1, distElWise: true }),
+        Shi: (0, dispatch_1.systemFunction)({ fn: math_1.Shi, minArgs: 1, maxArgs: 1, distElWise: true }),
+        Si: (0, dispatch_1.systemFunction)({ fn: math_1.Si, minArgs: 1, maxArgs: 1, distElWise: true }),
+        Chi: (0, dispatch_1.systemFunction)({ fn: math_1.Chi, minArgs: 1, maxArgs: 1, distElWise: true }),
+        Ci: (0, dispatch_1.systemFunction)({ fn: math_1.Ci, minArgs: 1, maxArgs: 1, distElWise: true }),
+        Ei: (0, dispatch_1.systemFunction)({ fn: math_1.Ei, minArgs: 1, maxArgs: 1, distElWise: true }),
+        [constants_1.LI]: (0, dispatch_1.systemFunction)({ fn: math_1.Li, minArgs: 1, maxArgs: 1, distElWise: true }),
+    });
+}

package/output/math/geometry.d.ts

@@ -1,4 +1,6 @@
 import { Expression } from '../core/classes/expression/Expression';
+import type { Vector } from '../core/classes/vector/Vector';
+import type { ExpressionInput } from '../core/types';
 /**
  * Returns the symbolic hypotenuse of two expressions.
  *
@@ -6,3 +8,5 @@ import { Expression } from '../core/classes/expression/Expression';
  * otherwise the result is the principal square root of the sum of squares.
  */
 export declare function hypot(a: Expression, b: Expression): Expression;
+/** Returns the line through two two-dimensional points, evaluated at `dimension`. */
+export declare function line(p1: Vector, p2: Vector, dimension?: ExpressionInput): Expression;

package/output/math/geometry.js

@@ -1,11 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.hypot = hypot;
+exports.line = line;
 const Expression_1 = require("../core/classes/expression/Expression");
 const shortcuts_1 = require("../core/classes/expression/shortcuts");
 const constants_1 = require("../core/classes/parser/constants");
 const add_1 = require("../core/classes/parser/operations/add");
 const power_1 = require("../core/classes/parser/operations/power");
+const errors_1 = require("../core/errors");
 /**
  * Returns the symbolic hypotenuse of two expressions.
  *
@@ -30,3 +32,24 @@ function hypot(a, b) {
     }
     return retval;
 }
+/** Returns the line through two two-dimensional points, evaluated at `dimension`. */
+function line(p1, p2, dimension = 'x') {
+    if (!p1 || !p2 || p1.dataType !== constants_1.VECTOR || p2.dataType !== constants_1.VECTOR || p1.count() !== 2 || p2.count() !== 2) {
+        throw new errors_1.DimensionError((0, errors_1.message)('mismatchedDimensions', { function: 'line' }));
+    }
+    const x1 = p1.elements[0];
+    const y1 = p1.elements[1];
+    const x2 = p2.elements[0];
+    const y2 = p2.elements[1];
+    if (!Expression_1.Expression.isExpression(x1) ||
+        !Expression_1.Expression.isExpression(y1) ||
+        !Expression_1.Expression.isExpression(x2) ||
+        !Expression_1.Expression.isExpression(y2)) {
+        throw new errors_1.UnexpectedInputError((0, errors_1.message)('wrongInput', {
+            expected: 'two-dimensional vectors of scalar expressions',
+            received: `${p1.text()}, ${p2.text()}`,
+        }));
+    }
+    const variable = Expression_1.Expression.create(dimension);
+    return y1.plus(y2.minus(y1).div(x2.minus(x1)).times(variable.minus(x1)));
+}

package/output/math/math.d.ts

@@ -26,6 +26,15 @@ import type { SolutionSet } from '../solve/classes/SolutionSet';
  * ```
  */
 export declare function sqrt(x: ExpressionInput): Expression;
+/**
+ * Returns a copy that renders numeric values in scientific notation.
+ *
+ * The legacy implementation stored a formatting flag that its formatter did not
+ * consume. Nerdamer 2.0 keeps the expression exact and records the requested number
+ * of significant digits for formatting. Precision validation follows decimal.js and accepts
+ * integer values from 1 through 1e9.
+ */
+export declare function scientific(x: ExpressionInput, significantDigits?: ExpressionInput): Expression;
 /**
  * Computes the nth root of an expression as its principal power.
  *
@@ -34,6 +43,12 @@ export declare function sqrt(x: ExpressionInput): Expression;
  * @returns `x^(1/n)`.
  */
 export declare function nthroot(x: ExpressionInput, n: ExpressionInput): Expression;
+/** Converts degrees to radians exactly. */
+export declare function radians(x: ExpressionInput): Expression;
+/** Converts radians to degrees exactly. */
+export declare function degrees(x: ExpressionInput): Expression;
+/** Returns the base-10 logarithm using the ordinary logarithm implementation. */
+export declare function log10(x: ExpressionInput): Expression;
 /**
  * Computes the cube root of an expression.
  *
@@ -67,7 +82,7 @@ export declare function cbrt(x: ExpressionInput): Expression;
  * parens(Expression.create('x+1')).text()  // "(x+1)"
  * ```
  */
-export declare function parens(x: Expression): Expression;
+export declare function parens(x: ExpressionInput): Expression;
 /**
  * Computes the Fibonacci number for an integer index.
  *
@@ -150,6 +165,18 @@ export declare function doubleFactorial(x: Expression): Expression;
  * ```
  */
 export declare function heaviside(x: Expression): Expression;
+/**
+ * Legacy unit-step function. Unlike {@link heaviside}, the value at zero is 1.
+ */
+export declare function step(x: ExpressionInput): Expression;
+/**
+ * Rectangular pulse with unit width centered at zero.
+ *
+ * Returns 1 for |x| < 1/2, 1/2 at |x| = 1/2, and 0 for |x| > 1/2.
+ */
+export declare function rect(x: ExpressionInput): Expression;
+/** Triangular pulse: max(1 - |x|, 0) when the comparison can be resolved. */
+export declare function tri(x: ExpressionInput): Expression;
 /**
  * Computes the Dirac delta function (distribution).
  *
@@ -284,6 +311,17 @@ export declare function modInv(a: Expression, p: Expression): Expression;
 /**
  * Computes the modulo (remainder) of `x` divided by `y`.
  *
+ * Exact Gaussian integers use the same quotient rule as Wolfram Language:
+ * divide, round the real and imaginary quotient components independently to
+ * the nearest integers with midpoint ties going to even, then subtract
+ * `y * quotient` from `x`.
+ *
+ * Complex values outside the Gaussian integers remain symbolic.
+ *
+ * @see https://reference.wolfram.com/language/ref/Mod.html
+ * @see https://reference.wolfram.com/language/ref/Quotient.html
+ * @see https://reference.wolfram.com/language/ref/Round.html
+ *
  * @param x - The dividend.
  * @param y - The divisor.
  * @returns The remainder of `x / y`.
@@ -291,11 +329,29 @@ export declare function modInv(a: Expression, p: Expression): Expression;
  *
  * @example
  * ```ts
- * mod(Expression.create(10), Expression.create(3)).text()   // "1"
- * mod(Expression.create(7), Expression.create(2)).text()    // "1"
+ * mod(Expression.create(10), Expression.create(3)).text()          // "1"
+ * mod(Expression.create('5+3*i'), Expression.create('2+i')).text() // "-1"
  * ```
  */
 export declare function mod(x: Expression, y: Expression): Expression;
+/**
+ * Upper incomplete gamma Γ(a, z).
+ *
+ * Positive integer first arguments are expanded exactly using the finite-sum formula.
+ * Other inputs remain symbolic.
+ *
+ * @see https://dlmf.nist.gov/8.4.E8
+ */
+export declare function gammaIncomplete(a: ExpressionInput, z: ExpressionInput): Expression;
+/**
+ * Lower incomplete gamma γ(a, z).
+ *
+ * Positive integer first arguments use γ(a,z) = Γ(a) - Γ(a,z).
+ * Other inputs remain symbolic.
+ *
+ * @see https://dlmf.nist.gov/8.2.E3
+ */
+export declare function gammaIncompleteLower(a: ExpressionInput, z: ExpressionInput): Expression;
 /**
  * Computes the gamma function Γ(x).
  *
@@ -615,22 +671,6 @@ export declare function sum(expr: Expression, index: Expression, lower: Expressi
  * ```
  */
 export declare function product(expr: Expression, index: Expression, lower: Expression, upper: Expression): Expression;
-/**
- * Calculates the definite integral using Adaptive Simpson. Note that this function uses
- * native JS number due to severe computational overhead when implemented with Decimal.js.
- *
- * @param f The function being integrated
- * @param dx The variable of integration
- * @param from The lower limit of the integral
- * @param to The upper limit of the integral
- * @returns The numeric value if possible else a symbolic function
- *
- * @example
- * ```ts
- * defint('cos(x)-x^2+6', 'x', 1, 6); // -42.787553149673464
- * ```
- */
-export declare function defint(f: ExpressionInput, dx: ExpressionInput, from: ExpressionInput, to: ExpressionInput): Expression;
 /**
  * Tests whether a value is present in a supported finite container.
  *