nerdamer 1.1.13 → 2.0.0-rc.2

package/output/solve/classes/SymbolicSolver.js

@@ -0,0 +1,601 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SymbolicSolver = void 0;
+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 Polynomial_1 = require("../../core/classes/polynomial/Polynomial");
+const errors_1 = require("../../core/errors");
+const math_1 = require("../../math/math");
+const trig_1 = require("../../math/trig");
+const utils_1 = require("../../math/utils");
+const solve_1 = require("../solve");
+/**
+ * Applies a defined set of exact transformations to one equation in one variable.
+ *
+ * Polynomial equations through degree four use closed-form formulas. Other
+ * recognized forms are solved by isolating and inverting elementary functions,
+ * exponentials, logarithmic sums, or a single square-root term. Unsupported
+ * input is reported by {@link solve} as `unsolved` so a caller can select a
+ * different strategy.
+ *
+ * @remarks
+ * This class is the symbolic strategy used by the ordinary solver; it is not a
+ * general proof procedure. Inverse-function results follow the symbolic forms
+ * implemented here, including parameterized families for direct trigonometric
+ * functions. The supplied Expression is retained, while Polynomial input is
+ * converted to its Expression representation.
+ */
+class SymbolicSolver {
+    static MAX_FN_SOLVE_STEPS = 64;
+    input;
+    x;
+    /**
+     * Creates a symbolic solver for `input = 0`.
+     *
+     * @param input - Polynomial or expression whose zeros are sought.
+     * @param v - Plain variable to solve for.
+     * @throws {@link core!UnexpectedInputError} If `v` is not a plain variable.
+     */
+    constructor(input, v) {
+        v = Expression_1.Expression.create(v);
+        this.x = v.value;
+        if (!v.isPlainVariable()) {
+            throw new errors_1.UnexpectedInputError((0, errors_1.message)('plainVariableExpected', { input: v.text() }));
+        }
+        if (typeof input === 'string') {
+            // Default to Expression
+            this.input = Expression_1.Expression.create(input);
+        }
+        else if (Polynomial_1.Polynomial.isPolynomial(input)) {
+            this.input = input.getExpression();
+        }
+        else {
+            this.input = input;
+        }
+    }
+    /**
+     * Solves `coeffs[3]x^3 + coeffs[2]x^2 + coeffs[1]x + coeffs[0] = 0`
+     * with Cardano's formula.
+     *
+     * @param coeffs - Four coefficients in ascending-power order.
+     * @returns Three symbolic root expressions.
+     */
+    static cubic(coeffs) {
+        const d = coeffs[0];
+        const c = coeffs[1];
+        const b = coeffs[2];
+        const a = coeffs[3];
+        // Normalize
+        const b1 = b.div(a);
+        const c1 = c.div(a);
+        const d1 = d.div(a);
+        // Depressed cubic coefficients
+        const p = c1.minus(b1.pow((0, shortcuts_1.two)()).div((0, shortcuts_1.three)()));
+        const q = d1
+            .minus(b1.times(c1).div((0, shortcuts_1.three)()))
+            .plus((0, shortcuts_1.two)().times(b1.pow((0, shortcuts_1.three)())).div((0, shortcuts_1.twentySeven)()));
+        // Discriminant
+        const discriminant = q.pow((0, shortcuts_1.two)()).div((0, shortcuts_1.four)()).plus(p.pow((0, shortcuts_1.three)()).div((0, shortcuts_1.twentySeven)()));
+        // Shift for converting back from depressed cubic
+        const shift = (0, shortcuts_1.zero)().minus(b1).div((0, shortcuts_1.three)());
+        // General Cardano solution
+        const sqrtDisc = (0, math_1.sqrt)(discriminant);
+        const negQOver2 = (0, shortcuts_1.zero)().minus(q).div((0, shortcuts_1.two)());
+        const u = (0, math_1.cbrt)(negQOver2.plus(sqrtDisc));
+        const v = (0, math_1.cbrt)(negQOver2.minus(sqrtDisc));
+        // First root: t = u + v
+        const t1 = u.plus(v);
+        // Other roots using cube roots of unity
+        const sqrt3 = (0, math_1.sqrt)((0, shortcuts_1.three)());
+        // const half = one.div(two());
+        const negHalf = (0, shortcuts_1.zero)().minus((0, shortcuts_1.half)());
+        const i = (0, math_1.sqrt)((0, shortcuts_1.zero)().minus((0, shortcuts_1.one)()));
+        const uPlusV = u.plus(v);
+        const uMinusV = u.minus(v);
+        const t2 = negHalf.times(uPlusV).plus(sqrt3.div((0, shortcuts_1.two)()).times(uMinusV).times(i));
+        const t3 = negHalf.times(uPlusV).minus(sqrt3.div((0, shortcuts_1.two)()).times(uMinusV).times(i));
+        return [t1.plus(shift), t2.plus(shift), t3.plus(shift)];
+    }
+    /**
+     * Solves `coeffs[2]x^2 + coeffs[1]x + coeffs[0] = 0` symbolically.
+     *
+     * @param coeffs - Three coefficients in ascending-power order.
+     * @returns The two quadratic-formula roots.
+     */
+    static quadratic(coeffs) {
+        const c = coeffs[0];
+        const b = coeffs[1];
+        const a = coeffs[2];
+        // console.log(`${a}, ${b}, ${c}`);
+        const discriminant = b.pow((0, shortcuts_1.two)()).minus((0, shortcuts_1.four)().times(a).times(c));
+        const sqrtDisc = (0, math_1.sqrt)(discriminant);
+        const twoA = (0, shortcuts_1.two)().times(a);
+        const negB = (0, shortcuts_1.zero)().minus(b);
+        const root1 = negB.plus(sqrtDisc).div(twoA);
+        const root2 = negB.minus(sqrtDisc).div(twoA);
+        return [root1, root2];
+    }
+    /**
+     * Solves a quartic from five ascending-power coefficients with Ferrari's method.
+     *
+     * @param coeffs - Coefficients from the constant through fourth-degree term.
+     * @returns Four symbolic root expressions.
+     */
+    static quartic(coeffs) {
+        const e = coeffs[0];
+        const d = coeffs[1];
+        const c = coeffs[2];
+        const b = coeffs[3];
+        const a = coeffs[4];
+        // Normalize: x^4 + A x^3 + B x^2 + C x + D = 0
+        const A = b.div(a);
+        const B = c.div(a);
+        const C = d.div(a);
+        const D = e.div(a);
+        // Depressed quartic: t^4 + p t^2 + q t + r = 0 via x = t - A/4
+        const p = B.minus((0, shortcuts_1.three)().times(A.pow((0, shortcuts_1.two)())).div((0, shortcuts_1.eight)()));
+        const q = C.minus(A.times(B).div((0, shortcuts_1.two)())).plus(A.pow((0, shortcuts_1.three)()).div((0, shortcuts_1.eight)()));
+        const r = D.minus(A.times(C).div((0, shortcuts_1.four)()))
+            .plus(A.pow((0, shortcuts_1.two)()).times(B).div((0, shortcuts_1.sixteen)()))
+            .minus((0, shortcuts_1.three)().times(A.pow((0, shortcuts_1.four)())).div((0, shortcuts_1.twoHundredFiftySix)()));
+        const shift = (0, shortcuts_1.zero)().minus(A).div((0, shortcuts_1.four)());
+        // Special case: biquadratic (q == 0) => solve t^4 + p t^2 + r = 0 as quadratic in z = t^2
+        // This avoids the Ferrari division by s (and in particular avoids 0/0 when q=0 and y=0 is chosen).
+        if (q.isZero()) {
+            // z^2 + p z + r = 0
+            const zRoots = SymbolicSolver.quadratic([r, p, (0, shortcuts_1.one)()]);
+            // Readability + stability for common unit-imaginary cases in biquadratics.
+            // Examples:
+            //   x^4 + 1  => z^2 + 1 = 0 => z = ±i
+            //   x^4 + 16 => z^2 + 16 = 0 => z = ±4i
+            // Using explicit forms avoids ambiguous i^(1/2) formatting and prevents
+            // branch-related simplification from collapsing distinct roots.
+            const I = Expression_1.Expression.Img();
+            const sqrt2 = (0, math_1.sqrt)((0, shortcuts_1.two)());
+            const sqrtSpecial = (z) => {
+                if (z.value !== Expression_1.Expression.imaginary) {
+                    return undefined;
+                }
+                const m = z.getMultiplier();
+                if (m.isOne()) {
+                    return (0, shortcuts_1.one)().plus(I).div(sqrt2);
+                } // sqrt(i)
+                if (m.isMinusOne()) {
+                    return (0, shortcuts_1.one)().minus(I).div(sqrt2);
+                } // sqrt(-i)
+                if (m.eq('4')) {
+                    return sqrt2.times((0, shortcuts_1.one)().plus(I));
+                } // sqrt(4i)
+                if (m.eq('-4')) {
+                    return sqrt2.times((0, shortcuts_1.one)().minus(I));
+                } // sqrt(-4i)
+                return undefined;
+            };
+            const tA = sqrtSpecial(zRoots[0]) ?? (0, math_1.sqrt)(zRoots[0]);
+            const tB = sqrtSpecial(zRoots[1]) ?? (0, math_1.sqrt)(zRoots[1]);
+            return [
+                tA.plus(shift),
+                (0, shortcuts_1.zero)().minus(tA).plus(shift),
+                tB.plus(shift),
+                (0, shortcuts_1.zero)().minus(tB).plus(shift),
+            ];
+        }
+        // Ferrari's method (general case, q != 0)
+        // Resolvent cubic: y^3 + 2 p y^2 + (p^2 - 4 r) y - q^2 = 0
+        const cubicCoeffs = [
+            (0, shortcuts_1.zero)().minus(q.pow((0, shortcuts_1.two)())), // constant: -q^2
+            p.pow((0, shortcuts_1.two)()).minus((0, shortcuts_1.four)().times(r)), // linear: p^2 - 4r
+            (0, shortcuts_1.two)().times(p), // quadratic: 2p
+            (0, shortcuts_1.one)(), // cubic: 1
+        ];
+        const cubicRoots = SymbolicSolver.cubic(cubicCoeffs);
+        // Choose a root y such that s = sqrt(y) is non-zero (required because q != 0).
+        let y = undefined;
+        for (const rt of cubicRoots) {
+            if (!rt.isZero()) {
+                y = rt;
+                break;
+            }
+        }
+        y = y ?? cubicRoots[0];
+        let s = (0, math_1.sqrt)(y);
+        // Last-resort: if s still ends up zero (can happen if cubic returned 0 first and "isZero" didn't catch),
+        // try remaining roots.
+        if (s.isZero()) {
+            for (const rt of cubicRoots) {
+                if (!rt.isZero()) {
+                    const cand = (0, math_1.sqrt)(rt);
+                    if (!cand.isZero()) {
+                        y = rt;
+                        s = cand;
+                        break;
+                    }
+                }
+            }
+        }
+        // u and v derived from:
+        // v - u = q / s, and u + v = p + y
+        const pPlusY = p.plus(y);
+        const u = pPlusY.div((0, shortcuts_1.two)()).minus(q.div((0, shortcuts_1.two)().times(s)));
+        const v = pPlusY.div((0, shortcuts_1.two)()).plus(q.div((0, shortcuts_1.two)().times(s)));
+        // Factor: (t^2 + s t + u)(t^2 - s t + v) = 0
+        const roots1 = SymbolicSolver.quadratic([u, s, (0, shortcuts_1.one)()]);
+        const roots2 = SymbolicSolver.quadratic([v, (0, shortcuts_1.zero)().minus(s), (0, shortcuts_1.one)()]);
+        return [
+            roots1[0].plus(shift),
+            roots1[1].plus(shift),
+            roots2[0].plus(shift),
+            roots2[1].plus(shift),
+        ];
+    }
+    /**
+     * Attempts the supported elementary-function and radical transformations.
+     *
+     * @returns Symbolic solutions, or `undefined` when no supported transformation
+     * closes the equation.
+     */
+    fnSolve() {
+        const input = this.input;
+        const x = this.x;
+        const solveForX = (u, value) => {
+            const vars = u.variables();
+            if (vars.length === 1 && vars[0] === x && u.text() === x && !value.hasVariable(x)) {
+                return [value];
+            }
+            const eq = u.minus(value);
+            const solver = new SymbolicSolver(eq, x);
+            const result = solver.solve();
+            if (!result.unsolved) {
+                return result.solutions;
+            }
+            return (0, solve_1.solve)(eq, x).elements;
+        };
+        const n = Expression_1.Expression.N();
+        const pi = Expression_1.Expression.Pi();
+        const nPi = n.times(pi);
+        const oddPiOver2 = (0, shortcuts_1.two)().times(n).plus((0, shortcuts_1.one)()).times(pi).div((0, shortcuts_1.two)());
+        //  Sum decomposition: f(u) + c = 0
+        if (input.isSum()) {
+            const elements = input.elementsArray();
+            const logTerms = elements.filter(e => e.isFunction(constants_1.LOG) &&
+                e.isLinear() &&
+                e.getMultiplier().isInteger() &&
+                e.getArguments().length > 0);
+            if (logTerms.length === elements.length && logTerms.some(e => e.hasVariable(x))) {
+                let product = (0, shortcuts_1.one)();
+                for (const logTerm of logTerms) {
+                    const exponent = Expression_1.Expression.fromRational(logTerm.getMultiplier());
+                    product = product.times(logTerm.getArguments()[0].pow(exponent));
+                }
+                return (0, solve_1.solve)(product.minus((0, shortcuts_1.one)()), x).elements;
+            }
+            const radicalTerms = elements.filter(e => e.hasVariable(x) && e.getPower().eq((0, shortcuts_1.half)()));
+            if (radicalTerms.length === 1) {
+                const radicalTerm = radicalTerms[0];
+                let remainder = (0, shortcuts_1.zero)();
+                for (const element of elements) {
+                    if (element !== radicalTerm) {
+                        remainder = remainder.plus(element);
+                    }
+                }
+                const base = (0, utils_1.stripPower)(radicalTerm.toUnitMultiplier());
+                const isolated = remainder.neg().div(radicalTerm.getMultiplier());
+                return (0, solve_1.solve)(base.minus(isolated.sq()), x).elements;
+            }
+            const negativeHalf = (0, shortcuts_1.half)().neg();
+            const reciprocalRadicals = [];
+            for (const element of elements) {
+                if (element.hasVariable(x)) {
+                    const factors = element.isProduct() ? element.elementsArray() : [element];
+                    const variableFactors = factors.filter(factor => factor.hasVariable(x));
+                    if (variableFactors.length === 1 &&
+                        variableFactors[0].getPower().eq(negativeHalf)) {
+                        reciprocalRadicals.push({
+                            term: element,
+                            factor: variableFactors[0],
+                        });
+                    }
+                }
+            }
+            if (reciprocalRadicals.length === 1) {
+                const { term: radicalTerm, factor: radicalFactor } = reciprocalRadicals[0];
+                let remainder = (0, shortcuts_1.zero)();
+                for (const element of elements) {
+                    if (element !== radicalTerm) {
+                        remainder = remainder.plus(element);
+                    }
+                }
+                // A reciprocal square root can be nested inside a product. Isolate only
+                // that factor, leaving the established direct-square-root path unchanged.
+                const unitFactor = radicalFactor.toUnitMultiplier();
+                const coefficient = radicalTerm.div(unitFactor);
+                if (!coefficient.hasVariable(x) && !remainder.hasVariable(x)) {
+                    const base = radicalFactor.getBase();
+                    const isolated = remainder.neg().div(coefficient);
+                    return solveForX(base, isolated.pow((0, shortcuts_1.two)().neg()));
+                }
+            }
+            if (elements.length === 2) {
+                let sinArg;
+                let sinCoeff;
+                let cosArg;
+                let cosCoeff;
+                let validTrigCombination = true;
+                for (const element of elements) {
+                    const factors = element.isProduct() ? element.elementsArray() : [element];
+                    const trigFactors = factors.filter(factor => (factor.isFunction(trig_1.SIN) || factor.isFunction(trig_1.COS)) &&
+                        factor.getPower().isOne());
+                    if (trigFactors.length !== 1) {
+                        validTrigCombination = false;
+                        break;
+                    }
+                    const trig = trigFactors[0].toUnitMultiplier();
+                    const coeff = element.div(trig);
+                    if (coeff.hasVariable(x)) {
+                        validTrigCombination = false;
+                        break;
+                    }
+                    if (trigFactors[0].isFunction(trig_1.SIN)) {
+                        sinArg = trig.getArguments()[0];
+                        sinCoeff = coeff;
+                    }
+                    else {
+                        cosArg = trig.getArguments()[0];
+                        cosCoeff = coeff;
+                    }
+                }
+                if (validTrigCombination &&
+                    sinArg &&
+                    sinCoeff &&
+                    cosArg &&
+                    cosCoeff &&
+                    sinArg.eq(cosArg) &&
+                    !sinCoeff.isZero()) {
+                    return solveForX(sinArg, (0, trig_1.atan)(cosCoeff.neg().div(sinCoeff)));
+                }
+            }
+            const fnTerms = elements.filter((e) => e.isFunction() && e.hasVariable(x));
+            if (fnTerms.length === 1) {
+                const fnTerm = fnTerms[0];
+                let remainder = (0, shortcuts_1.zero)();
+                for (const element of elements) {
+                    if (element !== fnTerm) {
+                        remainder = remainder.plus(element);
+                    }
+                }
+                if (!remainder.hasVariable(x) || fnTerm.name === constants_1.ABS) {
+                    const fname = fnTerm.name;
+                    const u = fnTerm.getArguments()[0];
+                    const m = fnTerm.getMultiplier();
+                    const p = fnTerm.getPower();
+                    // f(u) = -remainder / m
+                    let c = remainder.neg().div(m);
+                    // f(u)^n = c => f(u) = c^(1/n)
+                    if (!p.isOne()) {
+                        c = c.pow(p.invert());
+                    }
+                    const values = this.invertFunction(fname, c);
+                    if (values !== undefined) {
+                        const results = [];
+                        for (const v of values) {
+                            results.push(...solveForX(u, v));
+                        }
+                        return results.length > 0 ? results : undefined;
+                    }
+                }
+            }
+            if (elements.length === 2) {
+                const expIdx = elements.findIndex(e => {
+                    let retval = false;
+                    if (e.isEXP()) {
+                        const base = e.getBase();
+                        // Symbolic bases independent of x can use the same formal logarithmic
+                        // inversion. Explicit numeric bases retain the real-log domain restriction.
+                        retval =
+                            e.hasVariable(x) &&
+                                !base.hasVariable(x) &&
+                                (!base.isNUM() || (base.gt((0, shortcuts_1.zero)()) && !base.isOne()));
+                    }
+                    return retval;
+                });
+                if (expIdx !== -1) {
+                    const expTerm = elements[expIdx];
+                    const constTerm = elements[1 - expIdx];
+                    if (!constTerm.hasVariable(x)) {
+                        const base = expTerm.getBase();
+                        const u = expTerm.getPower();
+                        const m = expTerm.getMultiplier();
+                        const c = constTerm.neg().div(m);
+                        return solveForX(u, (0, math_1.log)(c).div((0, math_1.log)(base)));
+                    }
+                }
+            }
+        }
+        //  Direct function: f(u) = 0
+        if (input.isFunction(trig_1.SIN)) {
+            const u = input.getArguments()[0];
+            return solveForX(u, nPi);
+        }
+        if (input.isFunction(trig_1.COS)) {
+            const u = input.getArguments()[0];
+            return solveForX(u, oddPiOver2);
+        }
+        if (input.isFunction(trig_1.TAN)) {
+            const u = input.getArguments()[0];
+            return solveForX(u, nPi);
+        }
+        if (input.isFunction(trig_1.COT)) {
+            const u = input.getArguments()[0];
+            return solveForX(u, oddPiOver2);
+        }
+        if (input.isFunction(constants_1.LOG)) {
+            const u = input.getArguments()[0];
+            return solveForX(u, (0, shortcuts_1.one)());
+        }
+        if (input.isFunction(trig_1.SINH)) {
+            const u = input.getArguments()[0];
+            return solveForX(u, (0, shortcuts_1.zero)());
+        }
+        if (input.isFunction(trig_1.TANH)) {
+            const u = input.getArguments()[0];
+            return solveForX(u, (0, shortcuts_1.zero)());
+        }
+        if (input.isFunction(trig_1.ASIN)) {
+            const u = input.getArguments()[0];
+            return solveForX(u, (0, shortcuts_1.zero)());
+        }
+        if (input.isFunction(trig_1.ACOS)) {
+            const u = input.getArguments()[0];
+            return solveForX(u, (0, shortcuts_1.one)());
+        }
+        if (input.isFunction(trig_1.ATAN)) {
+            const u = input.getArguments()[0];
+            return solveForX(u, (0, shortcuts_1.zero)());
+        }
+        if (input.isFunction(trig_1.ASEC)) {
+            const u = input.getArguments()[0];
+            return solveForX(u, (0, shortcuts_1.one)());
+        }
+        if (input.isFunction(trig_1.ASINH)) {
+            const u = input.getArguments()[0];
+            return solveForX(u, (0, shortcuts_1.zero)());
+        }
+        if (input.isFunction(trig_1.ACOSH)) {
+            const u = input.getArguments()[0];
+            return solveForX(u, (0, shortcuts_1.one)());
+        }
+        if (input.isFunction(trig_1.ATANH)) {
+            const u = input.getArguments()[0];
+            return solveForX(u, (0, shortcuts_1.zero)());
+        }
+        if (input.isFunction(constants_1.ABS)) {
+            const u = input.getArguments()[0];
+            return solveForX(u, (0, shortcuts_1.zero)());
+        }
+        return undefined;
+    }
+    invertFunction(fname, c) {
+        switch (fname) {
+            case trig_1.SIN:
+                return [(0, trig_1.asin)(c)];
+            case trig_1.COS:
+                return [(0, trig_1.acos)(c)];
+            case trig_1.TAN:
+                return [(0, trig_1.atan)(c)];
+            case trig_1.COT:
+                return [(0, trig_1.atan)((0, shortcuts_1.one)().div(c))];
+            case constants_1.LOG:
+                return [(0, math_1.exp)(c)];
+            case trig_1.SINH:
+                return [(0, trig_1.asinh)(c)];
+            case trig_1.COSH:
+                return [(0, trig_1.acosh)(c)];
+            case trig_1.TANH:
+                return [(0, trig_1.atanh)(c)];
+            case trig_1.ASIN:
+                return [(0, trig_1.sin)(c)];
+            case trig_1.ACOS:
+                return [(0, trig_1.cos)(c)];
+            case trig_1.ATAN:
+                return [(0, trig_1.tan)(c)];
+            case trig_1.ASEC:
+                return [(0, shortcuts_1.one)().div((0, trig_1.cos)(c))];
+            case trig_1.ASINH:
+                return [(0, trig_1.sinh)(c)];
+            case trig_1.ACOSH:
+                return [(0, trig_1.cosh)(c)];
+            case trig_1.ATANH:
+                return [(0, trig_1.tanh)(c)];
+            case constants_1.ABS:
+                return [c, (0, shortcuts_1.zero)().minus(c)];
+            default:
+                return undefined;
+        }
+    }
+    /** Returns whether any node in the configured input is a function call. */
+    inputContainsFunction() {
+        let found = false;
+        this.input.forEveryElement(e => {
+            if (e.isFunction()) {
+                found = true;
+            }
+            return e;
+        });
+        return found;
+    }
+    /**
+     * Attempts polynomial formulas and then supported function transformations.
+     *
+     * @returns An object containing `solutions` and, when the strategy cannot
+     * solve the equation, the original `unsolved` expression.
+     */
+    solve() {
+        let solutions;
+        let unsolved;
+        if (this.input.hasVariable(this.x)) {
+            let coeffs;
+            const negativeHalf = (0, shortcuts_1.half)().neg();
+            const containsRadicalTerm = this.input.isSum() &&
+                this.input.elementsArray().some(term => {
+                    let retval = term.hasVariable(this.x) && term.getPower().eq((0, shortcuts_1.half)());
+                    if (!retval && term.isProduct() && term.hasVariable(this.x)) {
+                        const variableFactors = term
+                            .elementsArray()
+                            .filter(factor => factor.hasVariable(this.x));
+                        retval =
+                            variableFactors.length === 1 &&
+                                variableFactors[0].getPower().eq(negativeHalf);
+                    }
+                    return retval;
+                });
+            if (!containsRadicalTerm) {
+                try {
+                    coeffs = this.input.coeffs(this.x).toArray();
+                }
+                catch { }
+            }
+            if (coeffs) {
+                const deg = coeffs.length - 1;
+                let cleanCoeffs = true;
+                for (const c of coeffs) {
+                    if (c.hasVariable(this.x)) {
+                        cleanCoeffs = false;
+                        break;
+                    }
+                }
+                if (cleanCoeffs && deg >= 1 && deg <= 4) {
+                    switch (deg) {
+                        case 1:
+                            solutions = [coeffs[0].neg().div(coeffs[1])];
+                            break;
+                        case 2:
+                            solutions = SymbolicSolver.quadratic(coeffs);
+                            break;
+                        case 3:
+                            solutions = SymbolicSolver.cubic(coeffs);
+                            break;
+                        case 4:
+                            solutions = SymbolicSolver.quartic(coeffs);
+                            break;
+                    }
+                }
+            }
+            if (!solutions) {
+                solutions = this.fnSolve();
+            }
+            if (!solutions) {
+                unsolved = this.input;
+            }
+        }
+        else {
+            unsolved = this.input;
+        }
+        solutions ??= [];
+        return {
+            solutions,
+            unsolved,
+        };
+    }
+}
+exports.SymbolicSolver = SymbolicSolver;

package/output/solve/dispatch.d.ts

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

package/output/solve/dispatch.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadSolveFunctions = loadSolveFunctions;
+const dispatch_1 = require("../core/dispatch");
+const solve_1 = require("./solve");
+const solveSystem_1 = require("./solveSystem");
+function loadSolveFunctions() {
+    Object.assign(dispatch_1.mathFunctionRegistry, {
+        solve: (0, dispatch_1.systemFunction)({ fn: solve_1.solve, minArgs: 2, maxArgs: 2, equationArgs: [0], distElWise: false }),
+        roots: (0, dispatch_1.systemFunction)({ fn: solve_1.roots, minArgs: 1, maxArgs: 2, distElWise: false }),
+        solveeqs: (0, dispatch_1.systemFunction)({ fn: solveSystem_1.solveSystem, minArgs: 1, maxArgs: 1, distElWise: false }),
+    });
+}

package/output/solve/linsolve.d.ts

@@ -0,0 +1,53 @@
+import { Expression } from '../core/classes/expression/Expression';
+import { Vector } from '../core/classes/vector/Vector';
+/**
+ * Discriminated result of exact symbolic linear-system reduction.
+ *
+ * - `type: 'unique'`        — exactly one solution; `solutions` maps each variable to its value.
+ * - `type: 'infinite'`      — infinitely many solutions; `solutions` maps pivot variables to
+ *                              Expressions in terms of free variables; `freeVariables` lists the
+ *                              parameter names.
+ * - `type: 'inconsistent'`  — the system has no solution.
+ */
+export type LinearSystemResult = {
+    type: 'unique';
+    solutions: Record<string, Expression>;
+} | {
+    type: 'infinite';
+    solutions: Record<string, Expression>;
+    freeVariables: string[];
+} | {
+    type: 'inconsistent';
+};
+export declare class NonlinearSystemError extends Error {
+}
+/**
+ * Solves a system of linear equations by symbolic reduced row-echelon form.
+ *
+ * Each element of `equations` is an Expression representing `expr = 0`.
+ * If `variables` is omitted, the union of all variables across equations is used
+ * (sorted alphabetically for deterministic column ordering).
+ *
+ * Input Expressions and strings are interpreted as equal to zero. Coefficients
+ * may be symbolic as long as they do not contain any of the solve variables.
+ * For an underdetermined consistent system, free variables map to their own
+ * Expression and pivot variables are expressed in terms of them.
+ *
+ * @param equations - Vector of Expressions, or an array of Expressions and strings.
+ * @param variables - Optional ordered list of variable names.
+ * @returns A {@link LinearSystemResult} describing a unique, infinite, or
+ * inconsistent system.
+ * @throws {@link Error} If a solve variable occurs nonlinearly or in a
+ * non-polynomial position.
+ *
+ * @example
+ * ```ts
+ * // x + y - 3 = 0,  2x + 3y - 8 = 0
+ * const result = solveLinearSystem(
+ *     [Expression.create('x+y-3'), Expression.create('2*x+3*y-8')]
+ * );
+ * // result.type === 'unique'
+ * // result.solutions === { x: Expression(1), y: Expression(2) }
+ * ```
+ */
+export declare function solveLinearSystem(equations: Vector | Array<Expression | string>, variables?: string[]): LinearSystemResult;