nerdamer 1.1.13 → 2.0.0-rc.1

package/output/math/defint/defintNative.js

@@ -0,0 +1,292 @@
+"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 DEFAULT_TOL = 1e-12;
+const DEFAULT_MAX_DEPTH = 50;
+const DEFAULT_MAX_EVALUATIONS = 100_000;
+const MAX_SINGULAR_TRIES = 8;
+const INFINITE_BOUND_ENDPOINT_EPSILON = 1e-15;
+// ── Helpers ──────────────────────────────────────────────────────────
+function simpson(a, b, fa, fm, fb) {
+    return ((b - a) / 6) * (fa + 4 * fm + fb);
+}
+// ── Core: finite-bounds adaptive Simpson ─────────────────────────────
+function withFiniteBounds(f, aIn, bIn, tolAbs, tolRel, maxDepth, maxEvals, singular) {
+    let a = aIn;
+    let b = bIn;
+    if (a === b) {
+        return 0;
+    }
+    let sign = 1;
+    if (b < a) {
+        sign = -1;
+        const t = a;
+        a = b;
+        b = t;
+    }
+    let evals = 0;
+    const evalF = (x) => {
+        if (++evals > maxEvals) {
+            throw new Error(`defint: maxEvals exceeded (${maxEvals}).`);
+        }
+        const y = f(x);
+        if (singular === 'strict' && !isFinite(y)) {
+            throw new Error(`defint: non-finite f(x) at x=${x}`);
+        }
+        return y;
+    };
+    const m0 = (a + b) / 2;
+    const fa = evalF(a);
+    const fm = evalF(m0);
+    const fb = evalF(b);
+    if (singular === 'ignore' && (isNaN(fa) || isNaN(fm) || isNaN(fb))) {
+        return NaN;
+    }
+    // Auto-split if initial evaluations hit non-finite values
+    if (singular === 'auto' && (!isFinite(fa) || !isFinite(fm) || !isFinite(fb))) {
+        const leftEndpointSingular = !isFinite(fa) && isFinite(fm) && isFinite(fb);
+        const rightEndpointSingular = isFinite(fa) && isFinite(fm) && !isFinite(fb);
+        if (leftEndpointSingular || rightEndpointSingular) {
+            const span = b - a;
+            const endpointProbe = Math.sqrt(Number.EPSILON);
+            const singularAtLeft = leftEndpointSingular;
+            // A quadratic substitution removes the common integrable endpoint singularities
+            // without evaluating the original function at the singular endpoint. Clamping the
+            // transformed endpoint inward also avoids roundoff mapping tiny t values back to it.
+            const transformed = t => {
+                const u = Math.max(t, endpointProbe);
+                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}`);
+                }
+                return y;
+            };
+            return (sign *
+                withFiniteBounds(transformed, 0, 1, tolAbs, tolRel, maxDepth, maxEvals, singular));
+        }
+        return sign * autoSplitFinite(f, a, b, tolAbs, tolRel, maxDepth, maxEvals, singular);
+    }
+    const S0 = simpson(a, b, fa, fm, fb);
+    const stack = [
+        {
+            a,
+            b,
+            m: m0,
+            fa,
+            fm,
+            fb,
+            S: S0,
+            depth: 0,
+            tolAbs,
+            tolRel,
+            singularTries: 0,
+        },
+    ];
+    let acc = 0;
+    while (stack.length > 0) {
+        const fr = stack[stack.length - 1];
+        stack.pop();
+        const { a: a0, b: b0, m } = fr;
+        // Absolute tolerance is budgeted across child intervals. Relative tolerance stays
+        // relative to each child estimate rather than tightening again at every depth.
+        const childTolRel = fr.tolRel;
+        const lm = (a0 + m) / 2;
+        const rm = (m + b0) / 2;
+        const fLM = evalF(lm);
+        const fRM = evalF(rm);
+        if (singular === 'ignore' && (isNaN(fLM) || isNaN(fRM))) {
+            return NaN;
+        }
+        // Auto: bisect around non-finite values
+        if (singular === 'auto' &&
+            (!isFinite(fLM) ||
+                !isFinite(fRM) ||
+                !isFinite(fr.fa) ||
+                !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}]`);
+            }
+            const nextDepth = fr.depth + 1;
+            const childTolAbs = fr.tolAbs / 2;
+            stack.push({
+                a: m,
+                b: b0,
+                m: rm,
+                fa: fr.fm,
+                fm: fRM,
+                fb: fr.fb,
+                S: simpson(m, b0, fr.fm, fRM, fr.fb),
+                depth: nextDepth,
+                tolAbs: childTolAbs,
+                tolRel: childTolRel,
+                singularTries: fr.singularTries + 1,
+            });
+            stack.push({
+                a: a0,
+                b: m,
+                m: lm,
+                fa: fr.fa,
+                fm: fLM,
+                fb: fr.fm,
+                S: simpson(a0, m, fr.fa, fLM, fr.fm),
+                depth: nextDepth,
+                tolAbs: childTolAbs,
+                tolRel: childTolRel,
+                singularTries: fr.singularTries + 1,
+            });
+            continue;
+        }
+        const Sleft = simpson(a0, m, fr.fa, fLM, fr.fm);
+        const Sright = simpson(m, b0, fr.fm, fRM, fr.fb);
+        const S2 = Sleft + Sright;
+        const err = Math.abs(S2 - fr.S) / 15;
+        const scale = fr.tolAbs + fr.tolRel * Math.abs(S2);
+        if (err <= scale || fr.depth >= maxDepth) {
+            // Richardson extrapolation
+            acc += S2 + (S2 - fr.S) / 15;
+            continue;
+        }
+        const nextDepth = fr.depth + 1;
+        const childTolAbs = fr.tolAbs / 2;
+        // Push right then left so left is processed first (LIFO)
+        stack.push({
+            a: m,
+            b: b0,
+            m: rm,
+            fa: fr.fm,
+            fm: fRM,
+            fb: fr.fb,
+            S: Sright,
+            depth: nextDepth,
+            tolAbs: childTolAbs,
+            tolRel: childTolRel,
+            singularTries: fr.singularTries,
+        });
+        stack.push({
+            a: a0,
+            b: m,
+            m: lm,
+            fa: fr.fa,
+            fm: fLM,
+            fb: fr.fm,
+            S: Sleft,
+            depth: nextDepth,
+            tolAbs: childTolAbs,
+            tolRel: childTolRel,
+            singularTries: fr.singularTries,
+        });
+    }
+    return acc * sign;
+}
+// ── Auto-split helper for singular endpoints ─────────────────────────
+function autoSplitFinite(f, a, b, tolAbs, tolRel, maxDepth, maxEvals, singular) {
+    const m = (a + b) / 2;
+    const q1 = (a + m) / 2;
+    const q3 = (m + b) / 2;
+    const segTol = tolAbs / 4;
+    return (withFiniteBounds(f, a, q1, segTol, tolRel, maxDepth, maxEvals, singular) +
+        withFiniteBounds(f, q1, m, segTol, tolRel, maxDepth, maxEvals, singular) +
+        withFiniteBounds(f, m, q3, segTol, tolRel, maxDepth, maxEvals, singular) +
+        withFiniteBounds(f, q3, b, segTol, tolRel, maxDepth, maxEvals, singular));
+}
+// ── Public API ───────────────────────────────────────────────────────
+/**
+ * Definite integral of `f` from `a` to `b` using adaptive Simpson's rule
+ * with Richardson extrapolation, native `number` arithmetic.
+ *
+ * @example
+ * ```ts
+ * // ∫₀^π sin(x) dx = 2
+ * definiteIntegrate(Math.sin, 0, Math.PI);
+ *
+ * // With breakpoints for |x|
+ * definiteIntegrate(x => Math.abs(x), -1, 1, { breakpoints: [0] });
+ *
+ * // Improper integral ∫₁^∞ 1/x² dx = 1
+ * definiteIntegrate(x => 1/(x*x), 1, Infinity, { allowInfinite: true });
+ * ```
+ */
+function definiteIntegrateNative(f, a, b, options = {}) {
+    if (a === b) {
+        return 0;
+    }
+    const tolAbs = options.tolAbs ?? DEFAULT_TOL;
+    const tolRel = options.tolRel ?? DEFAULT_TOL;
+    const maxDepth = options.maxDepth ?? DEFAULT_MAX_DEPTH;
+    const maxEvals = options.maxEvals ?? DEFAULT_MAX_EVALUATIONS;
+    const singular = options.singular ?? 'auto';
+    const allowInfinite = options.allowInfinite ?? false;
+    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');
+    }
+    // ── Infinite-bound substitutions ─────────────────────────────
+    if (allowInfinite && (isInfA || isInfB)) {
+        // Guard against very small eps clamping to 0 in float64
+        const eps = INFINITE_BOUND_ENDPOINT_EPSILON;
+        if (!isInfA && isInfB && b > 0) {
+            // ∫_a^∞  →  t ∈ [0, 1-eps], x = a + t/(1-t), dx = 1/(1-t)²
+            const a0 = a;
+            const g = t => {
+                const u = 1 - t;
+                const x = a0 + t / u;
+                return f(x) / (u * u);
+            };
+            return withFiniteBounds(g, 0, 1 - eps, tolAbs, tolRel, maxDepth, maxEvals, singular);
+        }
+        if (isInfA && a < 0 && !isInfB) {
+            // ∫_{-∞}^b  →  t ∈ [0, 1-eps], x = b - t/(1-t)
+            const b0 = b;
+            const g = t => {
+                const u = 1 - t;
+                const x = b0 - t / u;
+                return f(x) / (u * u);
+            };
+            return withFiniteBounds(g, 0, 1 - eps, tolAbs, tolRel, maxDepth, maxEvals, singular);
+        }
+        if (isInfA && a < 0 && isInfB && b > 0) {
+            // ∫_{-∞}^{∞}  →  t ∈ [eps, 1-eps], x = tan(π(t - ½))
+            const g = t => {
+                const u = Math.PI * (t - 0.5);
+                const cosU = Math.cos(u);
+                // dx/dt = π / cos²(u)
+                return (f(Math.tan(u)) * Math.PI) / (cosU * cosU);
+            };
+            return withFiniteBounds(g, eps, 1 - eps, tolAbs, tolRel, maxDepth, maxEvals, singular);
+        }
+        throw new Error('defint: unsupported infinite bound configuration');
+    }
+    // ── Finite bounds with optional breakpoints ──────────────────
+    const lo = Math.min(a, b);
+    const hi = Math.max(a, b);
+    const bps = (options.breakpoints ?? []).filter(x => x > lo && x < hi).sort((x, y) => x - y);
+    if (bps.length === 0) {
+        return withFiniteBounds(f, a, b, tolAbs, tolRel, maxDepth, maxEvals, singular);
+    }
+    // Segment integration with tolerance budget split across segments
+    const nSeg = bps.length + 1;
+    const segTolAbs = tolAbs / nSeg;
+    // Determine integration direction
+    const forward = a <= b;
+    const points = forward ? [a, ...bps, b] : [a, ...bps.reverse(), b];
+    let total = 0;
+    for (let i = 0; i < points.length - 1; i++) {
+        total += withFiniteBounds(f, points[i], points[i + 1], segTolAbs, tolRel, maxDepth, maxEvals, singular);
+    }
+    return total;
+}

package/output/math/geometry.d.ts

@@ -0,0 +1,8 @@
+import { Expression } from '../core/classes/expression/Expression';
+/**
+ * Returns the symbolic hypotenuse of two expressions.
+ *
+ * Matching linear sine and cosine terms collapse through the Pythagorean identity;
+ * otherwise the result is the principal square root of the sum of squares.
+ */
+export declare function hypot(a: Expression, b: Expression): Expression;

package/output/math/geometry.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hypot = hypot;
+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");
+/**
+ * Returns the symbolic hypotenuse of two expressions.
+ *
+ * Matching linear sine and cosine terms collapse through the Pythagorean identity;
+ * otherwise the result is the principal square root of the sum of squares.
+ */
+function hypot(a, b) {
+    const fns = [constants_1.SIN, constants_1.COS];
+    let retval;
+    if (a.isFunction(fns) &&
+        b.isFunction(fns) &&
+        a.name !== b.name &&
+        a.isLinear() &&
+        b.isLinear() &&
+        a.getMultiplier().eq(b.getMultiplier())) {
+        retval = Expression_1.Expression.fromRational(a.getMultiplier());
+    }
+    else {
+        const aSquared = (0, power_1.power)(a, (0, shortcuts_1.two)());
+        const bSquared = (0, power_1.power)(b, (0, shortcuts_1.two)());
+        retval = (0, power_1.power)((0, add_1.add)(aSquared, bSquared), (0, shortcuts_1.half)());
+    }
+    return retval;
+}