nerdamer 1.1.13 → 2.0.0-rc.2

package/output/math/defint/defintNative.js

@@ -0,0 +1,281 @@
+"use strict";
+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;
+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((0, errors_1.message)('defintMaxEvals', { max: String(maxEvals) }));
+        }
+        const y = f(x);
+        if (singular === 'strict' && !isFinite(y)) {
+            throw new Error((0, errors_1.message)('defintNonFiniteValue', { x: String(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((0, errors_1.message)('defintEndpointSingularity', { x: String(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((0, errors_1.message)('defintSingularity', { a: String(a0), b: String(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((0, errors_1.message)('defintInfiniteBounds'));
+    }
+    // ── 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((0, errors_1.message)('defintUnsupportedInfiniteBounds'));
+    }
+    // ── 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/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 dispatch_1 = require("../core/dispatch");
+const constants_1 = require("../core/classes/parser/constants");
+const evaluate_1 = require("../core/classes/parser/scripting/evaluate");
+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

@@ -0,0 +1,12 @@
+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.
+ *
+ * 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;
+/** 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

@@ -0,0 +1,55 @@
+"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.
+ *
+ * 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;
+}
+/** 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)));
+}