nerdamer 1.1.13 → 2.0.0-rc.2

package/output/solve/linsolve.js

@@ -0,0 +1,233 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NonlinearSystemError = void 0;
+exports.solveLinearSystem = solveLinearSystem;
+const collect_1 = require("../core/classes/expression/collect");
+const Expression_1 = require("../core/classes/expression/Expression");
+const shortcuts_1 = require("../core/classes/expression/shortcuts");
+const Matrix_1 = require("../core/classes/matrix/Matrix");
+const Vector_1 = require("../core/classes/vector/Vector");
+const errors_1 = require("../core/errors");
+class NonlinearSystemError extends Error {
+}
+exports.NonlinearSystemError = NonlinearSystemError;
+/**
+ * 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) }
+ * ```
+ */
+function solveLinearSystem(equations, variables) {
+    // Normalize input
+    const exprs = normalizeEquations(equations);
+    if (exprs.length === 0) {
+        return { type: 'unique', solutions: {} };
+    }
+    // Determine variables
+    const vars = variables ?? (0, collect_1.collectVariablesSet)(exprs);
+    if (vars.length === 0) {
+        // No variables — check if all equations are trivially 0
+        for (const expr of exprs) {
+            if (!expr.eq((0, shortcuts_1.zero)())) {
+                return { type: 'inconsistent' };
+            }
+        }
+        return { type: 'unique', solutions: {} };
+    }
+    //  Extract coefficients and build augmented matrix
+    const { coeffMatrix, constants } = extractCoefficients(exprs, vars);
+    // Build augmented matrix [A | -b] where each equation is a_1*x_1 + ... + a_n*x_n + c = 0
+    // so the augmented column is -c
+    const numRows = exprs.length;
+    const numCols = vars.length;
+    const augRows = [];
+    for (let i = 0; i < numRows; i++) {
+        const row = [];
+        for (let j = 0; j < numCols; j++) {
+            row.push(coeffMatrix[i][j]);
+        }
+        // Augmented column: negate the constant
+        row.push((0, shortcuts_1.zero)().minus(constants[i]));
+        augRows.push(row);
+    }
+    const augmented = new Matrix_1.Matrix(...augRows);
+    // RREF
+    const R = augmented.rref();
+    const rRows = R.rows();
+    // const rCols = R.cols(); // = numCols + 1
+    const z = (0, shortcuts_1.zero)();
+    // Identify pivots and check consistency
+    const pivotCol = []; // pivotCol[i] = column of pivot in row i, or -1
+    for (let i = 0; i < rRows; i++) {
+        let found = -1;
+        for (let j = 0; j < numCols; j++) {
+            if (!R.get(i, j).eq(z)) {
+                found = j;
+                break;
+            }
+        }
+        if (found === -1) {
+            // All variable columns are zero — check augmented column
+            const rhs = R.get(i, numCols);
+            if (!rhs.eq(z)) {
+                return { type: 'inconsistent' };
+            }
+            // Otherwise it's a trivial 0 = 0 row
+            pivotCol.push(-1);
+        }
+        else {
+            pivotCol.push(found);
+        }
+    }
+    // Identify pivot vs free variable columns
+    const pivotColSet = new Set();
+    for (const pc of pivotCol) {
+        if (pc !== -1) {
+            pivotColSet.add(pc);
+        }
+    }
+    const freeColIndices = [];
+    for (let j = 0; j < numCols; j++) {
+        if (!pivotColSet.has(j)) {
+            freeColIndices.push(j);
+        }
+    }
+    // Unique solution
+    if (freeColIndices.length === 0) {
+        const solutions = {};
+        for (let i = 0; i < rRows; i++) {
+            const pc = pivotCol[i];
+            if (pc !== -1) {
+                solutions[vars[pc]] = R.get(i, numCols);
+            }
+        }
+        return { type: 'unique', solutions };
+    }
+    // Infinite solutions
+    // Free variables are parameters; pivot variables are expressed in terms of them.
+    const freeVariables = freeColIndices.map(j => vars[j]);
+    const solutions = {};
+    // Free variables map to themselves
+    for (const freeVar of freeVariables) {
+        solutions[freeVar] = Expression_1.Expression.create(freeVar);
+    }
+    // Pivot variables: x_pivot = rhs - sum(coeff * freeVar)
+    for (let i = 0; i < rRows; i++) {
+        const pc = pivotCol[i];
+        if (pc === -1) {
+            continue;
+        }
+        let expr = R.get(i, numCols);
+        for (const fj of freeColIndices) {
+            const coeff = R.get(i, fj);
+            if (!coeff.eq(z)) {
+                // x_pivot = rhs - coeff * freeVar
+                expr = expr.minus(coeff.times(Expression_1.Expression.create(vars[fj])));
+            }
+        }
+        solutions[vars[pc]] = expr;
+    }
+    return { type: 'infinite', solutions, freeVariables };
+}
+// ═══════════════════════════════════════════════════════════════════════════
+// Helpers
+// ═══════════════════════════════════════════════════════════════════════════
+/**
+ * Normalizes input to an array of Expressions.
+ */
+function normalizeEquations(equations) {
+    if (Vector_1.Vector.isVector(equations)) {
+        const result = [];
+        for (let i = 0; i < equations.count(); i++) {
+            result.push(equations.getExpressionAt(i));
+        }
+        return result;
+    }
+    return equations.map(e => (Expression_1.Expression.isExpression(e) ? e : Expression_1.Expression.create(e)));
+}
+/**
+ * Extracts the coefficient matrix and constant vector from linear expressions.
+ *
+ * For each expression, uses `expr.coeffs(...vars)` to get a CoeffObject.
+ * The CoeffObject keys are comma-separated multi-degree tuples like "1,0" for x in [x, y].
+ * The constant term has the all-zeros key (e.g. "0,0").
+ *
+ * Throws if any term has degree > 1 in any variable (nonlinear).
+ */
+function extractCoefficients(exprs, vars) {
+    const n = vars.length;
+    const coeffMatrix = [];
+    const constants = [];
+    for (let i = 0; i < exprs.length; i++) {
+        const expr = exprs[i];
+        const coeffObj = expr.coeffs(...vars);
+        const row = new Array(n).fill(null).map(() => (0, shortcuts_1.zero)());
+        let constant = (0, shortcuts_1.zero)();
+        // CoeffObject stores coefficients in .coeffs keyed by comma-separated degree tuples.
+        // e.g. for vars [x, y]: "1,0" means x^1*y^0 (coefficient of x),
+        // "0,0" is the constant term, "0,1" is coefficient of y, etc.
+        // Use .each() to iterate over all entries.
+        coeffObj.each((coeff, key) => {
+            const degrees = key.split(',').map(Number);
+            // Check total degree
+            const totalDegree = degrees.reduce((sum, d) => sum + d, 0);
+            if (totalDegree === 0) {
+                // Constant term
+                constant = coeff;
+            }
+            else if (totalDegree === 1) {
+                // Linear term — find which variable
+                const varIndex = degrees.findIndex(d => d === 1);
+                if (varIndex !== -1) {
+                    row[varIndex] = coeff;
+                }
+            }
+            else {
+                // Nonlinear term
+                throw new NonlinearSystemError((0, errors_1.message)('solveLinearNonlinearDegree', {
+                    equation: String(i + 1),
+                    degree: String(totalDegree),
+                }));
+            }
+        });
+        // Validate that no coefficient contains solve variables in non-polynomial positions
+        // (e.g. sin(x) would be absorbed as a "constant" but still contains x)
+        const allCoeffs = [...row, constant];
+        for (const c of allCoeffs) {
+            for (const v of vars) {
+                if (c.hasVariable(v)) {
+                    throw new NonlinearSystemError((0, errors_1.message)('solveLinearNonPolynomialVariable', {
+                        equation: String(i + 1),
+                        variable: v,
+                    }));
+                }
+            }
+        }
+        coeffMatrix.push(row);
+        constants.push(constant);
+    }
+    return { coeffMatrix, constants };
+}

package/output/solve/solve.d.ts

@@ -0,0 +1,44 @@
+import { Vector } from '../core/classes/vector/Vector';
+import { type FunctionSolverOptions } from './classes/FunctionSolver';
+import { SolutionSet } from './classes/SolutionSet';
+import type { Equation } from '../core/classes/equation/Equation';
+import type { ExpressionInput } from '../core/types';
+/**
+ * Returns polynomial roots as a Vector.
+ *
+ * Unlike solve(), which returns a SolutionSet with solver metadata, this function preserves
+ * the roots API's Vector return type. Numeric constants retain the historical square-root
+ * interpretation. Univariate polynomials delegate to PolynomialSolver and therefore return
+ * numerical roots.
+ */
+export declare function roots(input: ExpressionInput, variable?: ExpressionInput): Vector;
+/**
+ * Solves an equation or finds the zeros of an expression in one variable.
+ *
+ * The solver normalizes the input to `expression = 0`, tries direct symbolic
+ * transformations, factors numerator and denominator, and then applies
+ * symbolic, polynomial-numeric, and limited-range function-numeric strategies to the
+ * factors. Zeros of denominator factors are excluded from the result.
+ *
+ * @remarks
+ * Numerical fallback is heuristic and searches a finite range, so an empty result does
+ * not in general prove that no solution exists. Strategy and input errors are absorbed
+ * by this convenience entry point and produce the solutions collected before
+ * the failure. Decimal input marks returned solutions for decimal formatting.
+ *
+ * The `options` parameter is currently reserved and is not forwarded to the
+ * numerical strategies.
+ *
+ * @param input - Expression or equation to solve.
+ * @param variable - Variable to solve for. When omitted, input preparation
+ * infers it where possible.
+ * @param _options - Reserved numerical-solver options.
+ * @returns A {@link SolutionSet}. The special `all` expression represents an
+ * identity that is true for every value of the variable.
+ *
+ * @example
+ * ```ts
+ * const roots = solve('x^2-1', 'x');
+ * ```
+ */
+export declare function solve(input: ExpressionInput | Equation, variable?: ExpressionInput, _options?: FunctionSolverOptions): SolutionSet;

package/output/solve/solve.js

@@ -0,0 +1,368 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.roots = roots;
+exports.solve = solve;
+const factor_1 = require("../algebra/factor/factor");
+const factorCommon_1 = require("../algebra/simplify/factorCommon");
+const ratsimp_1 = require("../algebra/simplify/ratsimp");
+const Expression_1 = require("../core/classes/expression/Expression");
+const shortcuts_1 = require("../core/classes/expression/shortcuts");
+const utils_1 = require("../core/classes/expression/utils");
+const constants_1 = require("../core/classes/parser/constants");
+const Vector_1 = require("../core/classes/vector/Vector");
+const trig_1 = require("../math/trig");
+const FunctionSolver_1 = require("./classes/FunctionSolver");
+const PolynomialSolver_1 = require("./classes/PolynomialSolver");
+const SolutionSet_1 = require("./classes/SolutionSet");
+const SymbolicSolver_1 = require("./classes/SymbolicSolver");
+const utils_2 = require("./utils");
+/**
+ * Accumulates roots from distinct exact polynomial factors.
+ *
+ * Each factor result has already enforced uniqueness within that factor. Exact univariate
+ * factorization proves separate factors coprime, so their accepted roots can be copied
+ * without repeating general symbolic equality checks across factors.
+ */
+class FactorRootAccumulator extends SolutionSet_1.SolutionSet {
+    appendFactorSolutions(solutions) {
+        for (const solution of solutions.elements) {
+            this.addKnownUnique(solution);
+        }
+        if (this.solutionsType === undefined) {
+            this.solutionsType = solutions.solutionsType;
+        }
+        else if (solutions.solutionsType !== undefined &&
+            this.solutionsType !== solutions.solutionsType) {
+            this.solutionsType = 'mixed';
+        }
+    }
+}
+function calculateSolutions(factors, variable, disjointPolynomialFactors = false) {
+    const solutionSet = disjointPolynomialFactors
+        ? new FactorRootAccumulator()
+        : new SolutionSet_1.SolutionSet();
+    // We loop through each element (factor) and try to solve it. If we were successful,
+    // then we return 0. If we fail then we return  the value
+    const firstPass = factors
+        .map(fn => {
+        let retval = fn;
+        // The exponential function has no zeros, so an e^u factor contributes no
+        // solutions and must not be sent through the numerical scan over a fixed interval.
+        if (fn.isEXP() && fn.getBase().isE()) {
+            retval = (0, shortcuts_1.zero)();
+        }
+        // Don't even try to solve the function if it does not have x
+        else if (fn.hasVariable(variable)) {
+            // First Symbolically
+            let solutions = new SymbolicSolver_1.SymbolicSolver(fn, variable).solve();
+            if (solutions.unsolved && fn.isPolynomialLike() && fn.getPower().gt(4)) {
+                const linearPoly = fn.toLinearAndUnitMultiplier();
+                // See if you can solve the linear polynomial
+                solutions = new SymbolicSolver_1.SymbolicSolver(linearPoly, variable).solve();
+            }
+            if (!solutions.unsolved) {
+                if (disjointPolynomialFactors) {
+                    const factorSolutions = new SolutionSet_1.SolutionSet();
+                    factorSolutions.addSolutions(solutions.solutions, fn, variable);
+                    if (factorSolutions.count() > 0) {
+                        factorSolutions.solutionsType = 'symbolic';
+                        solutionSet.appendFactorSolutions(factorSolutions);
+                    }
+                }
+                else {
+                    const symbolicSolutions = new SolutionSet_1.SolutionSet(solutions.solutions);
+                    symbolicSolutions.solutionsType = 'symbolic';
+                    solutionSet.addSolutions(symbolicSolutions, fn, variable);
+                }
+                retval = (0, shortcuts_1.zero)();
+            }
+        }
+        return retval;
+    })
+        .filter(fn => !fn.eq((0, shortcuts_1.zero)()));
+    // For the second pass we solve polynomials using polynomials using numerical methods.
+    const secondPass = firstPass
+        .map(fn => {
+        let retval = fn;
+        // Numerical methods are only capable of solving univariate polynomials so
+        // we need to check as not to waste time.
+        const vars = fn.variables();
+        if (vars.length === 1 && vars[0] === variable && fn.isPolynomialLike()) {
+            const solutions = new PolynomialSolver_1.PolynomialSolver(fn, variable).validatedRoots();
+            if (solutions.length > 0) {
+                if (disjointPolynomialFactors) {
+                    const factorSolutions = new SolutionSet_1.SolutionSet();
+                    factorSolutions.addValidatedNumericalSolutions(solutions);
+                    factorSolutions.solutionsType = 'numeric';
+                    solutionSet.appendFactorSolutions(factorSolutions);
+                }
+                else {
+                    solutionSet.addValidatedNumericalSolutions(solutions);
+                    solutionSet.solutionsType =
+                        solutionSet.solutionsType === undefined ||
+                            solutionSet.solutionsType === 'numeric'
+                            ? 'numeric'
+                            : 'mixed';
+                }
+            }
+            retval = (0, shortcuts_1.zero)();
+        }
+        return retval;
+    })
+        .filter(fn => !fn.eq((0, shortcuts_1.zero)()));
+    // We ultimately fall back to numerical methods
+    for (const fn of secondPass) {
+        // Numerical methods are only capable of solving univariate functions so
+        // we need to check as not to waste time.
+        const vars = fn.variables();
+        const options = { method: 'Brent' };
+        if (vars.length === 1 && vars[0] === variable) {
+            const solutions = new FunctionSolver_1.FunctionSolver(fn, variable, options).roots();
+            if (solutions.length > 0) {
+                for (const solution of solutions) {
+                    solutionSet.add(solution);
+                }
+                solutionSet.solutionsType =
+                    solutionSet.solutionsType === undefined ||
+                        solutionSet.solutionsType === 'numeric'
+                        ? 'numeric'
+                        : 'mixed';
+            }
+        }
+    }
+    return solutionSet;
+}
+/**
+ * Returns polynomial roots as a Vector.
+ *
+ * Unlike solve(), which returns a SolutionSet with solver metadata, this function preserves
+ * the roots API's Vector return type. Numeric constants retain the historical square-root
+ * interpretation. Univariate polynomials delegate to PolynomialSolver and therefore return
+ * numerical roots.
+ */
+function roots(input, variable) {
+    const expression = Expression_1.Expression.create(input);
+    const variables = expression.variables();
+    if (variables.length === 0 && expression.isConstant()) {
+        const evaluated = expression.evaluate();
+        if (evaluated.isNUM()) {
+            const magnitude = evaluated.abs();
+            const root = magnitude.pow((0, shortcuts_1.half)());
+            const positive = evaluated.sign() < 0
+                ? root.times(Expression_1.Expression.Img())
+                : root;
+            return new Vector_1.Vector([positive, positive.neg()]);
+        }
+    }
+    const variableName = variable === undefined
+        ? variables[0]
+        : (0, utils_1.assertPlainVariableAndGetString)(Expression_1.Expression.create(variable));
+    if (variableName === undefined) {
+        return new Vector_1.Vector([expression]);
+    }
+    return new Vector_1.Vector(new PolynomialSolver_1.PolynomialSolver(expression, variableName).validatedRoots());
+}
+/**
+ * Solves an equation or finds the zeros of an expression in one variable.
+ *
+ * The solver normalizes the input to `expression = 0`, tries direct symbolic
+ * transformations, factors numerator and denominator, and then applies
+ * symbolic, polynomial-numeric, and limited-range function-numeric strategies to the
+ * factors. Zeros of denominator factors are excluded from the result.
+ *
+ * @remarks
+ * Numerical fallback is heuristic and searches a finite range, so an empty result does
+ * not in general prove that no solution exists. Strategy and input errors are absorbed
+ * by this convenience entry point and produce the solutions collected before
+ * the failure. Decimal input marks returned solutions for decimal formatting.
+ *
+ * The `options` parameter is currently reserved and is not forwarded to the
+ * numerical strategies.
+ *
+ * @param input - Expression or equation to solve.
+ * @param variable - Variable to solve for. When omitted, input preparation
+ * infers it where possible.
+ * @param _options - Reserved numerical-solver options.
+ * @returns A {@link SolutionSet}. The special `all` expression represents an
+ * identity that is true for every value of the variable.
+ *
+ * @example
+ * ```ts
+ * const roots = solve('x^2-1', 'x');
+ * ```
+ */
+function solve(input, variable, _options) {
+    // The solution set that's being returned
+    const solutions = new SolutionSet_1.SolutionSet();
+    let asDecimal = false;
+    // Try to solve the equation.
+    try {
+        // Prepare the inputs
+        const { expression, x } = (0, utils_2.prepareSolverInputs)(input, variable);
+        asDecimal = expression.hasDecimal();
+        // Get the variables
+        const vars = expression.variables();
+        // Handle the zero polynomial. This has as return type the special value all
+        if (expression.isZero()) {
+            solutions.addSolution((0, shortcuts_1.all)(), expression, x);
+            solutions.solutionsType = 'symbolic';
+        }
+        // For monomials a*x^n the value is zero for all values of x
+        else if (expression.isVAR() || (!vars.includes(x) && !expression.isNUM())) {
+            // There's not need to check if the variable matches x as this one done in prepareSolverInputs
+            solutions.addSolution((0, shortcuts_1.zero)(), expression, x);
+            solutions.solutionsType = 'symbolic';
+        }
+        else {
+            // The strategy is a follows:
+            // 1. Try the original expression symbolically before factoring. This avoids expensive
+            //    factorization when the existing symbolic solver can already close the equation.
+            // 2. Factor the expression. Take the divide and conquer approach. Solve the smaller parts. The factors function
+            //	  helps by breaking both the numerator and the denominator into their factors.
+            // 3. We only need to solve the numerator. The denominator only gives us singularities.
+            // 	  We return that as the extraneous roots.
+            // 4. Try to solve symbolically with the symbol solver.
+            // 5. Try to solve polynomials numerically as a fallback.
+            // 6. When all else fails, switch to a numerical solver.
+            const containsRadicalTerm = expression.isSum() &&
+                expression.elementsArray().some(term => {
+                    let retval = term.hasVariable(x) && term.getPower().eq((0, shortcuts_1.half)());
+                    if (!retval && term.isProduct() && term.hasVariable(x)) {
+                        const variableFactors = term
+                            .elementsArray()
+                            .filter(factor => factor.hasVariable(x));
+                        retval =
+                            variableFactors.length === 1 &&
+                                variableFactors[0].getPower().eq((0, shortcuts_1.half)().neg());
+                    }
+                    return retval;
+                });
+            const directCoeffs = expression.isPolynomialLike()
+                ? expression.coeffs(x).toArray()
+                : undefined;
+            const isNumericUnivariatePolynomial = directCoeffs !== undefined &&
+                vars.length === 1 &&
+                vars[0] === x &&
+                directCoeffs.every(coefficient => coefficient.isNUM());
+            let directPowerBinomialSolutions;
+            if (directCoeffs) {
+                const degree = directCoeffs.length - 1;
+                const hasSymbolicCoefficients = directCoeffs.some(coefficient => coefficient.variables().length > 0);
+                const isPowerBinomial = degree > 4 &&
+                    hasSymbolicCoefficients &&
+                    !directCoeffs[0].isZero() &&
+                    directCoeffs.slice(1, degree).every(coefficient => coefficient.isZero());
+                if (isPowerBinomial) {
+                    const degreeExpression = Expression_1.Expression.create(degree);
+                    const rootPower = (0, shortcuts_1.one)().div(degreeExpression);
+                    const radicand = directCoeffs[0].neg().div(directCoeffs[degree]);
+                    const principalRoot = Expression_1.Expression.toEXP(radicand, rootPower);
+                    const fullTurn = (0, shortcuts_1.two)().times(Expression_1.Expression.Variable(constants_1.PI_NAME));
+                    directPowerBinomialSolutions = [];
+                    for (let k = 0; k < degree; k++) {
+                        let rotation = (0, shortcuts_1.one)();
+                        if (k > 0) {
+                            const angle = fullTurn
+                                .copy()
+                                .times(Expression_1.Expression.create(k))
+                                .div(degreeExpression);
+                            rotation = (0, trig_1.cos)(angle).plus((0, trig_1.sin)(angle).times(Expression_1.Expression.Img()));
+                        }
+                        directPowerBinomialSolutions.push(principalRoot.copy().times(rotation));
+                    }
+                }
+            }
+            const commonFactored = directCoeffs?.length === 3 && directCoeffs[0].isZero()
+                ? (0, factorCommon_1.factorCommonPower)(expression)
+                : undefined;
+            const commonFactors = commonFactored?.isProduct()
+                ? commonFactored.elementsArray()
+                : undefined;
+            const direct = containsRadicalTerm
+                ? new SymbolicSolver_1.SymbolicSolver(expression, x).solve()
+                : undefined;
+            let rationalNumerator;
+            let rationalDenominator;
+            if (!expression.isPolynomialLike()) {
+                try {
+                    const rational = (0, ratsimp_1.toCommonDenominator)(expression);
+                    const numerator = rational.getNumerator().expand();
+                    const denominator = rational.getDenominator().expand();
+                    if (!denominator.isOne() &&
+                        numerator.isPolynomialLike() &&
+                        denominator.isPolynomialLike()) {
+                        rationalNumerator = numerator;
+                        rationalDenominator = denominator;
+                    }
+                }
+                catch {
+                    // This is an optimization path. If rational normalization is not supported,
+                    // continue with the existing factorization and numerical strategies below.
+                }
+            }
+            if (directPowerBinomialSolutions) {
+                const symbolicSolutions = new SolutionSet_1.SolutionSet(directPowerBinomialSolutions);
+                symbolicSolutions.solutionsType = 'symbolic';
+                solutions.addSolutions(symbolicSolutions, expression, x);
+            }
+            else if (commonFactors) {
+                solutions.addSolution((0, shortcuts_1.zero)(), expression, x);
+                solutions.solutionsType = 'symbolic';
+                const commonSolutions = calculateSolutions(commonFactors, x);
+                if (isNumericUnivariatePolynomial &&
+                    commonSolutions.solutionsType === 'numeric') {
+                    solutions.appendValidatedNumerical(commonSolutions);
+                }
+                else if (isNumericUnivariatePolynomial) {
+                    solutions.append(commonSolutions);
+                }
+                else {
+                    solutions.addSolutions(commonSolutions, expression, x);
+                }
+            }
+            else if (direct && !direct.unsolved) {
+                const symbolicSolutions = new SolutionSet_1.SolutionSet(direct.solutions);
+                symbolicSolutions.solutionsType = 'symbolic';
+                solutions.addSolutions(symbolicSolutions, expression, x);
+            }
+            else if (rationalNumerator && rationalDenominator) {
+                // A rational expression is zero exactly where its polynomial numerator is zero,
+                // except at denominator singularities. Avoid polynomializing the nested quotient again.
+                const extraneous = calculateSolutions([rationalDenominator], x);
+                solutions.exclude(extraneous);
+                solutions.addSolutions(calculateSolutions([rationalNumerator], x), expression, x);
+            }
+            else {
+                // Get the factors object
+                const factorObj = (0, factor_1.factorExpressionParts)(expression);
+                // Exact univariate factorization returns distinct irreducible factors with
+                // repeated factors represented by powers. Their solution sets can therefore
+                // be combined without proving cross-factor equality again.
+                const disjointPolynomialFactors = isNumericUnivariatePolynomial;
+                // Get the extraneous roots
+                const extraneous = calculateSolutions(factorObj.denominator, x, disjointPolynomialFactors);
+                solutions.exclude(extraneous);
+                // Get the solutions in the numerator
+                const numSolutions = calculateSolutions(factorObj.numerator, x, disjointPolynomialFactors);
+                if (isNumericUnivariatePolynomial &&
+                    numSolutions.solutionsType === 'numeric') {
+                    solutions.appendValidatedNumerical(numSolutions);
+                }
+                else if (isNumericUnivariatePolynomial) {
+                    solutions.append(numSolutions);
+                }
+                else {
+                    solutions.addSolutions(numSolutions, expression, x);
+                }
+            }
+        }
+    }
+    catch (_e) { }
+    if (asDecimal) {
+        solutions.each(solution => {
+            solution.getMultiplier().asDecimal = true;
+            return solution;
+        });
+    }
+    return solutions;
+}

package/output/solve/solveSystem.d.ts

@@ -0,0 +1,31 @@
+import { Vector } from '../core/classes/vector/Vector';
+import type { Equation } from '../core/classes/equation/Equation';
+import type { ExpressionInput } from '../core/types';
+/**
+ * Solves a system of expressions or equations for an ordered set of variables.
+ *
+ * Expressions are interpreted as equal to zero. The solver first tries exact
+ * linear reduction, then a lexicographic Groebner basis with symbolic back
+ * substitution for polynomial systems, and finally multivariate Newton-Raphson
+ * over a fixed search interval. Rational polynomial systems may have denominators
+ * cleared for symbolic work; candidates are checked against the original domain.
+ *
+ * @remarks
+ * The nonlinear numerical fallback is heuristic and does not guarantee all
+ * roots. A returned outer {@link Vector} contains one {@link Dictionary} per
+ * solution. An empty system has one empty solution, while no discovered or
+ * inconsistent solution is represented by an empty Vector.
+ *
+ * Infinite nonlinear solution sets are not represented. Underdetermined
+ * systems that reach numerical fallback are rejected.
+ *
+ * @param equations - Vector or array of equations and zero-valued expressions.
+ * @param variables - Optional variable order. When omitted, variables are
+ * collected from the normalized expressions.
+ * @returns A Vector of solution dictionaries keyed by variable name.
+ * @throws {@link core!UnexpectedInputError} If an input cannot be normalized to an
+ * Expression or Equation.
+ * @throws {@link core!UnsupportedOperationError} If a solution is not isolated or an
+ * underdetermined nonlinear system reaches numerical fallback.
+ */
+export declare function solveSystem(equations: Vector | Array<ExpressionInput | Equation | string>, variables?: string[]): Vector;