nerdamer 2.0.0-rc.1 → 2.0.0

package/output/solve/classes/SolutionSet.d.ts

@@ -1,6 +1,7 @@
 import { Expression } from '../../core/classes/expression/Expression';
 import { SOLUTIONS_SET } from '../../core/classes/parser/constants';
 import { ValuesSet } from '../../core/classes/valuesSet/ValuesSet';
+import type { ParserValuesObject } from '../../core/classes/parser/types';
 import type { ParserEntity } from '../../core/types';
 import type { Root } from './FunctionSolver';
 /** Describes whether accepted solutions were produced by numerical strategies, symbolic strategies, or both. */
@@ -91,6 +92,14 @@ export declare class SolutionSet extends ValuesSet {
      * use {@link append} when the complete solver result should be merged without revalidation.
      */
     addSolutions(arr: Expression[] | SolutionSet, forFunction: Expression, variable: string): this;
+    /**
+     * Adds a batch of numerical solutions that has already been validated against its source
+     * polynomial. Incoming values are deduplicated by their exact numeric components before
+     * storage so a numerical root batch does not require pairwise symbolic equality checks.
+     *
+     * @internal
+     */
+    addValidatedNumericalSolutions(values: Iterable<Expression>): SolutionSet;
     /**
      * Appends another solution result while preserving set and solver metadata.
      *
@@ -103,6 +112,16 @@ export declare class SolutionSet extends ValuesSet {
      * current data model can represent only one such expression.
      */
     append(s: SolutionSet): SolutionSet;
+    /**
+     * Appends numerical solutions that were already validated by a numerical solver.
+     *
+     * This follows the same metadata and exclusion handling as {@link append}, but avoids
+     * repeating symbolic membership checks for a batch that has already been numerically
+     * validated and deduplicated.
+     *
+     * @internal
+     */
+    appendValidatedNumerical(s: SolutionSet): SolutionSet;
     /** Returns an independent Expression copy at the requested insertion-order index. */
     at(i: number): Expression | undefined;
     /**
@@ -122,7 +141,7 @@ export declare class SolutionSet extends ValuesSet {
     each(callback: (e: ParserEntity, i?: string | number, j?: string | number) => ParserEntity | void): this;
     /** Returns deep-copied accepted solution descriptors in deterministic insertion order. */
     get elements(): Expression[];
-    evaluate(): SolutionSet;
+    evaluate(values?: ParserValuesObject): SolutionSet;
     /**
      * Adds exclusions and removes any matching values that were already accepted.
      */

package/output/solve/classes/SolutionSet.js

@@ -83,8 +83,9 @@ class SolutionSet extends ValuesSet_1.ValuesSet {
             // Preserve parameterized candidates that cannot yet be verified, but
             // require every closed residual, including complex values, to be zero.
             if ((isClosed && evaluated.isNearlyZero()) || !isClosed) {
+                const excluded = this.excluded.has(solution);
                 this.add(solution);
-                retval = this.has(solution);
+                retval = !excluded;
             }
         }
         catch (e) {
@@ -106,7 +107,11 @@ class SolutionSet extends ValuesSet_1.ValuesSet {
         if (this.excluded.has(value)) {
             const index = indices[0];
             if (index < 0 || index >= this.count()) {
-                throw new RangeError(`Index ${index} out of bounds for ${this.dataType} of length ${this.count()}`);
+                throw new RangeError((0, errors_1.message)('indexOutOfBounds', {
+                    index: String(index),
+                    type: String(this.dataType),
+                    length: String(this.count()),
+                }));
             }
             const current = this.at(index);
             if (current) {
@@ -201,6 +206,48 @@ class SolutionSet extends ValuesSet_1.ValuesSet {
         }
         return this;
     }
+    /**
+     * Adds a batch of numerical solutions that has already been validated against its source
+     * polynomial. Incoming values are deduplicated by their exact numeric components before
+     * storage so a numerical root batch does not require pairwise symbolic equality checks.
+     *
+     * @internal
+     */
+    addValidatedNumericalSolutions(values) {
+        const candidates = [...values];
+        const existing = this.elements;
+        const keys = new Set();
+        for (const value of candidates) {
+            if (!Expression_1.Expression.isExpression(value)) {
+                const entity = value;
+                throw new errors_1.UnexpectedDataType((0, errors_1.message)('expressionExpected', { type: entity.dataType }));
+            }
+            const real = value.isComplex() ? value.realPart() : value;
+            const imaginary = value.isComplex() ? value.imagPart() : Expression_1.Expression.Number(0);
+            if (!real.isNUM() || !imaginary.isNUM()) {
+                throw new errors_1.UnexpectedDataType((0, errors_1.message)('expressionExpected', { type: value.dataType }));
+            }
+            const realMultiplier = real.getMultiplier();
+            const imaginaryMultiplier = imaginary.getMultiplier();
+            const key = `${realMultiplier.numerator}/${realMultiplier.denominator}|` +
+                `${imaginaryMultiplier.numerator}/${imaginaryMultiplier.denominator}`;
+            if (keys.has(key) || this.excluded.has(value)) {
+                continue;
+            }
+            let present = false;
+            for (const stored of existing) {
+                if (stored.eq(value) && value.eq(stored)) {
+                    present = true;
+                    break;
+                }
+            }
+            if (!present) {
+                this.addKnownUnique(value);
+                keys.add(key);
+            }
+        }
+        return this;
+    }
     /**
      * Appends another solution result while preserving set and solver metadata.
      *
@@ -213,8 +260,38 @@ class SolutionSet extends ValuesSet_1.ValuesSet {
      * current data model can represent only one such expression.
      */
     append(s) {
+        const transferUnique = this.count() === 0 && this.excluded.count() === 0;
+        this.exclude(s.getExcluded());
+        if (transferUnique) {
+            for (const solution of s.elements) {
+                this.addKnownUnique(solution);
+            }
+        }
+        else {
+            this.addMany(s.elements);
+        }
+        for (const root of s.getRawRoots()) {
+            this.addRawRoot(root);
+        }
+        this.partial = this.partial || s.partial;
+        this.mergeSolutionsType(s.solutionsType);
+        if (!this.unsolved && s.unsolved) {
+            this.unsolved = s.unsolved.copy();
+        }
+        return this;
+    }
+    /**
+     * Appends numerical solutions that were already validated by a numerical solver.
+     *
+     * This follows the same metadata and exclusion handling as {@link append}, but avoids
+     * repeating symbolic membership checks for a batch that has already been numerically
+     * validated and deduplicated.
+     *
+     * @internal
+     */
+    appendValidatedNumerical(s) {
         this.exclude(s.getExcluded());
-        this.addMany(s.elements);
+        this.addValidatedNumericalSolutions(s.elements);
         for (const root of s.getRawRoots()) {
             this.addRawRoot(root);
         }
@@ -276,8 +353,8 @@ class SolutionSet extends ValuesSet_1.ValuesSet {
     get elements() {
         return super.elements;
     }
-    evaluate() {
-        return this.copy().each(e => e.evaluate());
+    evaluate(values) {
+        return this.copy().each(e => e.evaluate(values));
     }
     /**
      * Adds exclusions and removes any matching values that were already accepted.

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

@@ -19,6 +19,8 @@ export type LinearSystemResult = {
 } | {
     type: 'inconsistent';
 };
+export declare class NonlinearSystemError extends Error {
+}
 /**
  * Solves a system of linear equations by symbolic reduced row-echelon form.
  *

package/output/solve/linsolve.js

@@ -1,11 +1,16 @@
 "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.
  *
@@ -202,8 +207,10 @@ function extractCoefficients(exprs, vars) {
             }
             else {
                 // Nonlinear term
-                throw new Error(`Nonlinear term detected in equation ${i + 1}: degree ${totalDegree} term found. ` +
-                    `solveLinearSystem only handles linear systems.`);
+                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
@@ -212,9 +219,10 @@ function extractCoefficients(exprs, vars) {
         for (const c of allCoeffs) {
             for (const v of vars) {
                 if (c.hasVariable(v)) {
-                    throw new Error(`Nonlinear term detected in equation ${i + 1}: ` +
-                        `variable "${v}" appears in a non-polynomial position. ` +
-                        `solveLinearSystem only handles linear systems.`);
+                    throw new NonlinearSystemError((0, errors_1.message)('solveLinearNonPolynomialVariable', {
+                        equation: String(i + 1),
+                        variable: v,
+                    }));
                 }
             }
         }

package/output/solve/solve.d.ts

@@ -1,7 +1,17 @@
+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.
  *

package/output/solve/solve.js

@@ -1,21 +1,46 @@
 "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 Polynomial_1 = require("../core/classes/polynomial/Polynomial");
+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_1 = require("./utils");
-function calculateSolutions(factors, variable) {
-    const solutionSet = new SolutionSet_1.SolutionSet();
+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
@@ -30,15 +55,25 @@ function calculateSolutions(factors, variable) {
         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)) {
+            if (solutions.unsolved && fn.isPolynomialLike() && fn.getPower().gt((0, shortcuts_1.four)())) {
                 const linearPoly = fn.toLinearAndUnitMultiplier();
                 // See if you can solve the linear polynomial
                 solutions = new SymbolicSolver_1.SymbolicSolver(linearPoly, variable).solve();
             }
             if (!solutions.unsolved) {
-                const symbolicSolutions = new SolutionSet_1.SolutionSet(solutions.solutions);
-                symbolicSolutions.solutionsType = 'symbolic';
-                solutionSet.addSolutions(symbolicSolutions, fn, variable);
+                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)();
             }
         }
@@ -53,11 +88,22 @@ function calculateSolutions(factors, variable) {
         // 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(new Polynomial_1.Polynomial(fn), variable).roots();
+            const solutions = new PolynomialSolver_1.PolynomialSolver(fn, variable).validatedRoots();
             if (solutions.length > 0) {
-                const numericSolutions = new SolutionSet_1.SolutionSet(solutions.map(solution => solution.evaluate()));
-                numericSolutions.solutionsType = 'numeric';
-                solutionSet.append(numericSolutions);
+                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)();
         }
@@ -73,14 +119,49 @@ function calculateSolutions(factors, variable) {
         if (vars.length === 1 && vars[0] === variable) {
             const solutions = new FunctionSolver_1.FunctionSolver(fn, variable, options).roots();
             if (solutions.length > 0) {
-                const numericSolutions = new SolutionSet_1.SolutionSet(solutions);
-                numericSolutions.solutionsType = 'numeric';
-                solutionSet.append(numericSolutions);
+                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.
  *
@@ -117,7 +198,7 @@ function solve(input, variable, _options) {
     // Try to solve the equation.
     try {
         // Prepare the inputs
-        const { expression, x } = (0, utils_1.prepareSolverInputs)(input, variable);
+        const { expression, x } = (0, utils_2.prepareSolverInputs)(input, variable);
         asDecimal = expression.hasDecimal();
         // Get the variables
         const vars = expression.variables();
@@ -159,6 +240,10 @@ function solve(input, variable, _options) {
             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;
@@ -223,7 +308,17 @@ function solve(input, variable, _options) {
             else if (commonFactors) {
                 solutions.addSolution((0, shortcuts_1.zero)(), expression, x);
                 solutions.solutionsType = 'symbolic';
-                solutions.addSolutions(calculateSolutions(commonFactors, x), expression, x);
+                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);
@@ -240,12 +335,25 @@ function solve(input, variable, _options) {
             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);
+                const extraneous = calculateSolutions(factorObj.denominator, x, disjointPolynomialFactors);
                 solutions.exclude(extraneous);
                 // Get the solutions in the numerator
-                const numSolutions = calculateSolutions(factorObj.numerator, x);
-                solutions.addSolutions(numSolutions, expression, x);
+                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);
+                }
             }
         }
     }

package/output/solve/solveSystem.d.ts

@@ -1,5 +1,5 @@
-import { Equation } from '../core/classes/equation/Equation';
 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.

package/output/solve/solveSystem.js

@@ -1,48 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.solveSystem = solveSystem;
-const adapters_1 = require("../algebra/adapters");
 const groebnerBase_1 = require("../algebra/algorithms/groebnerBase");
 const ratsimp_1 = require("../algebra/simplify/ratsimp");
 const Dictionary_1 = require("../core/classes/dictionary/Dictionary");
-const Equation_1 = require("../core/classes/equation/Equation");
-const analysis_1 = require("../core/classes/expression/analysis");
 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 constants_1 = require("../core/classes/parser/constants");
-const Parser_1 = require("../core/classes/parser/Parser");
-const Polynomial_1 = require("../core/classes/polynomial/Polynomial");
+const SparsePolynomialAdapter_1 = require("../core/classes/polynomial/SparsePolynomialAdapter");
 const Vector_1 = require("../core/classes/vector/Vector");
 const errors_1 = require("../core/errors");
 const MultivariateSolver_1 = require("./classes/MultivariateSolver");
 const linsolve_1 = require("./linsolve");
 const solve_1 = require("./solve");
-function toExpression(input) {
-    if (Equation_1.Equation.isEquation(input)) {
-        return input.toLHS().LHS;
-    }
-    if (Expression_1.Expression.isExpression(input)) {
-        return input;
-    }
-    const parsed = Parser_1.Parser.parse(String(input));
-    if (Equation_1.Equation.isEquation(parsed)) {
-        return parsed.toLHS().LHS;
-    }
-    if (Expression_1.Expression.isExpression(parsed)) {
-        return parsed;
-    }
-    throw new errors_1.UnexpectedInputError((0, errors_1.message)('expressionExpected', { type: constants_1.dataTypes[parsed.dataType] }));
-}
+const utils_1 = require("./utils");
 function normalizeEquations(equations) {
     if (Vector_1.Vector.isVector(equations)) {
         const result = [];
         for (let i = 0; i < equations.count(); i++) {
-            result.push(toExpression(equations.__get__([i])));
+            result.push((0, utils_1.normalizeSolverExpression)(equations.__get__([i])));
         }
         return result;
     }
-    return equations.map(eq => toExpression(eq));
+    return equations.map(eq => (0, utils_1.normalizeSolverExpression)(eq));
 }
 function symbolicBackSubstitution(basisExprs, vars) {
     let partials = [
@@ -248,7 +227,7 @@ function solveSystem(equations, variables) {
         }
     }
     catch (error) {
-        if (!(error instanceof Error) || !error.message.includes('Nonlinear term detected')) {
+        if (!(error instanceof linsolve_1.NonlinearSystemError)) {
             throw error;
         }
     }
@@ -256,15 +235,12 @@ function solveSystem(equations, variables) {
     const allPolynomial = symbolicExpressions.every(e => e.isPolynomialLike());
     if (allPolynomial) {
         try {
-            const polys = symbolicExpressions.map(expression => {
-                const cleared = (0, analysis_1.normalizeMultiplierDenominators)(expression);
-                return (0, adapters_1.polynomialToMultiPoly)(new Polynomial_1.Polynomial(cleared, vars), vars).poly;
-            });
-            const basis = (0, groebnerBase_1.Groebner)(polys, vars, 'LEX', true);
+            const polys = symbolicExpressions.map(expression => (0, SparsePolynomialAdapter_1.expressionToIntegerSparsePolynomial)(expression, vars).polynomial);
+            const basis = (0, groebnerBase_1.Groebner)(polys, 'LEX', true);
             if (basis.length === 1 && basis[0].isConstant() && basis[0].constantTerm() !== 0n) {
                 return new Vector_1.Vector([]);
             }
-            const basisExprs = basis.map(p => (0, adapters_1.multiPolyToExpression)(p, vars));
+            const basisExprs = basis.map(p => (0, SparsePolynomialAdapter_1.sparsePolynomialToExpression)(p, vars));
             let solutions = symbolicBackSubstitution(basisExprs, vars);
             if (hasRationalRewrite) {
                 solutions = solutions.filter(solution => isSystemSolution(expressions, domainRestrictions, solution));

package/output/solve/utils.d.ts

@@ -1,9 +1,10 @@
 import { Equation } from '../core/classes/equation/Equation';
 import { Expression } from '../core/classes/expression/Expression';
-import type { ExpressionInput } from '../core/types';
+import type { ExpressionInput, NerdamerInput } from '../core/types';
 export interface SolverInputs {
     x: string;
     expression: Expression;
 }
+export declare function normalizeSolverExpression(input: NerdamerInput): Expression;
 export declare function extractVariable(variable: ExpressionInput): string;
 export declare function prepareSolverInputs(input: ExpressionInput | Equation | string, variable?: ExpressionInput): SolverInputs;

package/output/solve/utils.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeSolverExpression = normalizeSolverExpression;
 exports.extractVariable = extractVariable;
 exports.prepareSolverInputs = prepareSolverInputs;
 const Equation_1 = require("../core/classes/equation/Equation");
@@ -7,6 +8,22 @@ const Expression_1 = require("../core/classes/expression/Expression");
 const constants_1 = require("../core/classes/parser/constants");
 const Parser_1 = require("../core/classes/parser/Parser");
 const errors_1 = require("../core/errors");
+function normalizeSolverExpression(input) {
+    if (Equation_1.Equation.isEquation(input)) {
+        return input.toLHS().LHS;
+    }
+    if (Expression_1.Expression.isExpression(input)) {
+        return input;
+    }
+    const parsed = Parser_1.Parser.parse(String(input));
+    if (Equation_1.Equation.isEquation(parsed)) {
+        return parsed.toLHS().LHS;
+    }
+    if (Expression_1.Expression.isExpression(parsed)) {
+        return parsed;
+    }
+    throw new errors_1.UnexpectedInputError((0, errors_1.message)('expressionExpected', { type: constants_1.dataTypes[parsed.dataType] }));
+}
 function extractVariable(variable) {
     variable = Expression_1.Expression.create(variable);
     if (!variable.isPlainVariable()) {
@@ -15,28 +32,7 @@ function extractVariable(variable) {
     return variable.value;
 }
 function prepareSolverInputs(input, variable) {
-    let expression;
-    if (Equation_1.Equation.isEquation(input)) {
-        expression = input.toLHS().LHS;
-    }
-    else if (!Expression_1.Expression.isExpression(input)) {
-        // Cast them all to string
-        const parsed = Parser_1.Parser.parse(String(input));
-        // Was it an equation string?
-        if (Equation_1.Equation.isEquation(parsed)) {
-            expression = parsed.toLHS().LHS;
-        }
-        else if (!Expression_1.Expression.isExpression(parsed)) {
-            // Complain for any other types
-            throw new errors_1.UnexpectedInputError((0, errors_1.message)('expressionExpected', { type: constants_1.dataTypes[parsed.dataType] }));
-        }
-        else {
-            expression = parsed;
-        }
-    }
-    else {
-        expression = input;
-    }
+    const expression = normalizeSolverExpression(input);
     const vars = expression.variables();
     let x;
     // Get the variable to solve for

package/output/utils/array.d.ts

@@ -38,5 +38,5 @@ export declare function intersection<T>(arr1: T[], arr2: T[]): T[];
  * @param compareFn
  * @returns
  */
-export declare function syncSort<T>(arr1: T[], arr2: T[], compareFn: (a: T, b: T) => number): T[][];
+export declare function syncSort<T, U>(arr1: T[], arr2: U[], compareFn: (a: T, b: T) => number): [T[], U[]];
 export declare function allEqual<T>(arr: T[]): boolean;