nerdamer 1.1.13 → 2.0.0-rc.1

package/output/solve/classes/MultivariateSolver.js

@@ -0,0 +1,240 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MultivariateSolver = void 0;
+const decimal_js_1 = __importDefault(require("decimal.js"));
+const Expression_1 = require("../../core/classes/expression/Expression");
+const DecimalMatrix_1 = require("./DecimalMatrix");
+const DEFAULT_LOWER_BOUND = -10;
+const DEFAULT_UPPER_BOUND = 10;
+const DEFAULT_GRID_POINTS = 5;
+const DEFAULT_MAX_ITERATIONS = 100;
+const DEFAULT_TOLERANCE = 1e-12;
+const DEFAULT_DERIVATIVE_STEP = 1e-8;
+const DEFAULT_DEDUPLICATION_TOLERANCE = 1e-8;
+/**
+ * Searches numerically for isolated real solutions of a multivariate system.
+ *
+ * Each equation is interpreted as `equation = 0`. The solver starts
+ * Newton-Raphson at every point in a Cartesian grid, approximates the Jacobian
+ * with central differences, and merges nearby converged solutions.
+ *
+ * @remarks
+ * This is a finite-range heuristic rather than a completeness proof. The number
+ * of starts is `gridPoints` raised to the number of variables, so cost grows
+ * rapidly with dimension. Singular Jacobians, failed evaluations, and starts
+ * that do not converge are discarded. Calculations use the ambient
+ * `decimal.js` precision, and the supplied equation and variable arrays are
+ * retained by the solver.
+ *
+ * The numerical linear solve requires a square Jacobian in ordinary use; this
+ * class is intended for isolated solutions of systems with as many equations
+ * as variables.
+ */
+class MultivariateSolver {
+    dedupTol;
+    equations;
+    gridPoints;
+    h;
+    lowerBound;
+    maxIterations;
+    tolerance;
+    upperBound;
+    variables;
+    /**
+     * Creates a multi-start solver over the configured limits.
+     *
+     * @param equations - Expressions interpreted as equations equal to zero.
+     * @param variables - Ordered variables corresponding to solution coordinates.
+     * @param options - Grid, iteration, differentiation, and deduplication settings.
+     */
+    constructor(equations, variables, options = {}) {
+        this.equations = equations;
+        this.variables = variables;
+        this.lowerBound = options.lowerBound ?? DEFAULT_LOWER_BOUND;
+        this.upperBound = options.upperBound ?? DEFAULT_UPPER_BOUND;
+        this.gridPoints = options.gridPoints ?? DEFAULT_GRID_POINTS;
+        this.maxIterations = options.maxIterations ?? DEFAULT_MAX_ITERATIONS;
+        this.tolerance = new decimal_js_1.default(options.tolerance ?? DEFAULT_TOLERANCE);
+        this.h = new decimal_js_1.default(options.derivativeStep ?? DEFAULT_DERIVATIVE_STEP);
+        this.dedupTol = new decimal_js_1.default(options.deduplicationTolerance ?? DEFAULT_DEDUPLICATION_TOLERANCE);
+    }
+    /**
+     * Evaluate all equations at a point, returning a vector of Decimal values.
+     */
+    evaluateSystem(point) {
+        const values = {};
+        for (let i = 0; i < this.variables.length; i++) {
+            const value = point[i];
+            // Preserve the parser's existing handling for non-finite values while keeping
+            // ordinary Newton coordinates native.
+            values[this.variables[i]] = value.isFinite() ? Expression_1.Expression.Number(value) : value;
+        }
+        const result = [];
+        for (const eq of this.equations) {
+            try {
+                const evaluated = eq.evaluate(values);
+                if (!Expression_1.Expression.isExpression(evaluated)) {
+                    return null;
+                }
+                result.push(evaluated.getMultiplier().toDecimal());
+            }
+            catch {
+                return null;
+            }
+        }
+        return result;
+    }
+    /**
+     * Generate grid starting points.
+     */
+    generateStartingPoints() {
+        const n = this.variables.length;
+        const points = [];
+        const step = (this.upperBound - this.lowerBound) / (this.gridPoints - 1);
+        // Generate all combinations of grid points
+        const indices = new Array(n).fill(0);
+        while (true) {
+            const point = [];
+            for (let i = 0; i < n; i++) {
+                point.push(new decimal_js_1.default(this.lowerBound + indices[i] * step));
+            }
+            points.push(point);
+            // Increment indices 
+            let carry = true;
+            for (let i = n - 1; i >= 0 && carry; i--) {
+                indices[i]++;
+                if (indices[i] < this.gridPoints) {
+                    carry = false;
+                }
+                else {
+                    indices[i] = 0;
+                }
+            }
+            if (carry) {
+                break;
+            }
+        }
+        return points;
+    }
+    /**
+     * Check if a root is a duplicate of an existing one.
+     */
+    isDuplicate(root, existing) {
+        for (const prev of existing) {
+            let maxDiff = new decimal_js_1.default(0);
+            for (let i = 0; i < root.length; i++) {
+                const diff = root[i].minus(prev[i]).abs();
+                if (diff.greaterThan(maxDiff)) {
+                    maxDiff = diff;
+                }
+            }
+            if (maxDiff.lessThan(this.dedupTol)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Compute the Jacobian matrix numerically using central differences.
+     */
+    jacobian(point) {
+        const n = this.variables.length;
+        const m = this.equations.length;
+        const data = new Array(m).fill(null).map(() => []);
+        const twoH = this.h.times(2);
+        // A forward/backward system evaluation contains every Jacobian row for one
+        // variable. Evaluate once per variable instead of once per equation-variable pair.
+        for (let j = 0; j < n; j++) {
+            const forward = point.map(v => new decimal_js_1.default(v));
+            const backward = point.map(v => new decimal_js_1.default(v));
+            forward[j] = forward[j].plus(this.h);
+            backward[j] = backward[j].minus(this.h);
+            const fPlus = this.evaluateSystem(forward);
+            const fMinus = this.evaluateSystem(backward);
+            if (!fPlus || !fMinus) {
+                return null;
+            }
+            for (let i = 0; i < m; i++) {
+                data[i].push(fPlus[i].minus(fMinus[i]).div(twoH));
+            }
+        }
+        return new DecimalMatrix_1.DecimalMatrix(data);
+    }
+    /**
+     * Run Newton-Raphson from a single starting point.
+     * Returns the converged root or null if it didn't converge.
+     */
+    newtonRaphson(start) {
+        const x = start.map(v => new decimal_js_1.default(v));
+        for (let iter = 0; iter < this.maxIterations; iter++) {
+            const F = this.evaluateSystem(x);
+            if (!F) {
+                return null;
+            }
+            // Check convergence: ||F(x)|| < tolerance
+            let norm = new decimal_js_1.default(0);
+            for (const fi of F) {
+                norm = norm.plus(fi.times(fi));
+            }
+            norm = norm.sqrt();
+            if (norm.lessThan(this.tolerance)) {
+                return x;
+            }
+            const J = this.jacobian(x);
+            if (!J) {
+                return null;
+            }
+            // Solve J * delta = -F
+            const negF = F.map(fi => fi.neg());
+            const delta = DecimalMatrix_1.DecimalMatrix.solve(J, negF);
+            if (!delta) {
+                return null; // Singular Jacobian
+            }
+            // Update: x = x + delta
+            for (let i = 0; i < x.length; i++) {
+                x[i] = x[i].plus(delta[i]);
+            }
+        }
+        // Check if we're close enough after max iterations
+        const F = this.evaluateSystem(x);
+        if (F) {
+            let norm = new decimal_js_1.default(0);
+            for (const fi of F) {
+                norm = norm.plus(fi.times(fi));
+            }
+            if (norm.sqrt().lessThan(this.tolerance)) {
+                return x;
+            }
+        }
+        return null;
+    }
+    /**
+     * Searches for roots from every configured grid point.
+     *
+     * @returns Deduplicated solutions as maps keyed in `variables` order. An empty
+     * array means that no start converged; it does not prove that no root exists.
+     */
+    roots() {
+        const convergedRoots = [];
+        const startingPoints = this.generateStartingPoints();
+        for (const start of startingPoints) {
+            const root = this.newtonRaphson(start);
+            if (root && !this.isDuplicate(root, convergedRoots)) {
+                convergedRoots.push(root);
+            }
+        }
+        // Convert to Maps of Expressions
+        return convergedRoots.map(root => {
+            const solution = new Map();
+            for (let i = 0; i < this.variables.length; i++) {
+                const value = root[i];
+                solution.set(this.variables[i], value.isFinite() ? Expression_1.Expression.Number(value) : Expression_1.Expression.create(value));
+            }
+            return solution;
+        });
+    }
+}
+exports.MultivariateSolver = MultivariateSolver;

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

@@ -0,0 +1,85 @@
+import Decimal from 'decimal.js';
+import { Complex } from '../../core/classes/complex/Complex';
+import { Expression } from '../../core/classes/expression/Expression';
+import { Polynomial } from '../../core/classes/polynomial/Polynomial';
+/**
+ * Finds all complex roots of a univariate polynomial numerically.
+ *
+ * Coefficient arrays use ascending powers: the element at index `k` is the
+ * coefficient of `x^k`. Polynomial and string inputs are converted to that
+ * representation before solving. Linear and quadratic inputs are handled
+ * directly; higher degrees use simultaneous Aberth iteration followed by
+ * Newton refinement.
+ *
+ * @remarks
+ * The solver temporarily changes the global `decimal.js` precision while
+ * {@link roots} runs and restores the previous precision before returning.
+ * The requested precision controls the numerical work, while `epsilon`
+ * controls convergence and cleanup of numerical noise. Roots are returned
+ * once per polynomial degree, so repeated roots can appear as repeated nearby
+ * approximations.
+ *
+ * This class finds numerical roots; it does not certify completeness or exact
+ * multiplicities for ill-conditioned polynomials.
+ *
+ * @example
+ * ```ts
+ * const solver = new PolynomialSolver('x^2+1', 'x');
+ * const roots = solver.roots();
+ * ```
+ */
+export declare class PolynomialSolver {
+    private degree;
+    private eps;
+    private p;
+    private precision;
+    /**
+     * Creates a polynomial root solver.
+     *
+     * @param input - A polynomial, a polynomial string, or ascending-power
+     * coefficients.
+     * @param variable - Variable expected in polynomial or string input. It is used to reject
+     * a conflicting variable or multivariate polynomial.
+     * @param precision - Working `decimal.js` precision used while finding roots.
+     * @param epsilon - Numerical convergence tolerance. Defaults to `1e-14`.
+     * @throws {@link core!UnexpectedInputError} If polynomial or string input is multivariate or
+     * uses a variable different from `variable`.
+     */
+    constructor(input: Decimal[] | Polynomial | string, variable?: string, precision?: number, epsilon?: Decimal);
+    /**
+     * Aberth method: simultaneous approximation of all roots
+     * More stable than deflation for high-degree polynomials
+     */
+    private aberthMethod;
+    /**
+     * Compute Cauchy bound for root magnitudes
+     */
+    private cauchyBound;
+    private complexSqrt;
+    private finalize;
+    /**
+     * Refine a single root using Newton's method
+     */
+    private newtonRefine;
+    private solveQuadratic;
+    /**
+     * Synthetic division
+     * Returns [P(s), quotient Q] where P(x) = (x-s)*Q(x) + P(s)
+     */
+    private syntheticDiv;
+    /**
+     * Computes the roots of the configured polynomial.
+     *
+     * Leading zero coefficients are ignored. A constant or zero coefficient
+     * array produces an empty result. Passing `false` returns the numeric
+     * {@link Complex} values directly; otherwise each root is converted to an
+     * {@link Expression} after restoring the caller's Decimal precision.
+     *
+     * @param asExpressions - Whether to convert roots to symbolic expressions.
+     * Defaults to `true`.
+     * @returns One root value per effective polynomial degree, including repeated
+     * numerical approximations for repeated roots.
+     */
+    roots(asExpressions?: true): Expression[];
+    roots(asExpressions?: false): Complex[];
+}

package/output/solve/classes/PolynomialSolver.js

@@ -0,0 +1,292 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PolynomialSolver = void 0;
+const decimal_js_1 = __importDefault(require("decimal.js"));
+const Complex_1 = require("../../core/classes/complex/Complex");
+const Expression_1 = require("../../core/classes/expression/Expression");
+const Polynomial_1 = require("../../core/classes/polynomial/Polynomial");
+const errors_1 = require("../../core/errors");
+const DEFAULT_PRECISION = 50;
+const DEFAULT_EPSILON = 1e-14;
+const ABERTH_MAX_ITERATIONS = 100;
+const ABERTH_INITIAL_ANGLE_OFFSET = 0.4;
+const ABERTH_RADIUS_SCALE = 0.9;
+const ABERTH_ROOT_SPACING_SCALE = 0.01;
+const ABERTH_CONVERGENCE_SCALE = 1e-2;
+const NEWTON_MAX_ITERATIONS = 20;
+const NEWTON_CONVERGENCE_SCALE = 1e-6;
+/**
+ * Finds all complex roots of a univariate polynomial numerically.
+ *
+ * Coefficient arrays use ascending powers: the element at index `k` is the
+ * coefficient of `x^k`. Polynomial and string inputs are converted to that
+ * representation before solving. Linear and quadratic inputs are handled
+ * directly; higher degrees use simultaneous Aberth iteration followed by
+ * Newton refinement.
+ *
+ * @remarks
+ * The solver temporarily changes the global `decimal.js` precision while
+ * {@link roots} runs and restores the previous precision before returning.
+ * The requested precision controls the numerical work, while `epsilon`
+ * controls convergence and cleanup of numerical noise. Roots are returned
+ * once per polynomial degree, so repeated roots can appear as repeated nearby
+ * approximations.
+ *
+ * This class finds numerical roots; it does not certify completeness or exact
+ * multiplicities for ill-conditioned polynomials.
+ *
+ * @example
+ * ```ts
+ * const solver = new PolynomialSolver('x^2+1', 'x');
+ * const roots = solver.roots();
+ * ```
+ */
+class PolynomialSolver {
+    degree;
+    eps;
+    p;
+    precision;
+    /**
+     * Creates a polynomial root solver.
+     *
+     * @param input - A polynomial, a polynomial string, or ascending-power
+     * coefficients.
+     * @param variable - Variable expected in polynomial or string input. It is used to reject
+     * a conflicting variable or multivariate polynomial.
+     * @param precision - Working `decimal.js` precision used while finding roots.
+     * @param epsilon - Numerical convergence tolerance. Defaults to `1e-14`.
+     * @throws {@link core!UnexpectedInputError} If polynomial or string input is multivariate or
+     * uses a variable different from `variable`.
+     */
+    constructor(input, variable, precision = DEFAULT_PRECISION, epsilon) {
+        // Allow for input to be a string
+        if (typeof input === 'string') {
+            input = new Polynomial_1.Polynomial(input);
+        }
+        if (Polynomial_1.Polynomial.isPolynomial(input)) {
+            const vars = input.variables;
+            // Expect the input to be a univariate polynomial
+            if (vars.length > 1 || (vars.length === 1 && variable && vars[0] !== variable)) {
+                throw new errors_1.UnexpectedInputError((0, errors_1.message)('tooManyUnknowns'));
+            }
+        }
+        const coefficients = Polynomial_1.Polynomial.isPolynomial(input) ? input.toDecimalArray() : input;
+        // Reverse the coefficients so p[0] is the leading coefficient
+        this.p = coefficients
+            .slice()
+            .reverse()
+            .map(c => new Complex_1.Complex(c, 0));
+        this.degree = this.p.length - 1;
+        this.eps = epsilon || new decimal_js_1.default(DEFAULT_EPSILON);
+        this.precision = precision;
+    }
+    /**
+     * Aberth method: simultaneous approximation of all roots
+     * More stable than deflation for high-degree polynomials
+     */
+    aberthMethod(P) {
+        const n = P.length - 1;
+        // Initialize roots on a circle
+        const roots = [];
+        const radius = this.cauchyBound(P);
+        for (let k = 0; k < n; k++) {
+            const angle = new decimal_js_1.default(2).mul(Math.PI).mul(k).div(n).plus(ABERTH_INITIAL_ANGLE_OFFSET);
+            const r = radius
+                .mul(ABERTH_RADIUS_SCALE)
+                .mul(new decimal_js_1.default(1).plus(new decimal_js_1.default(k).mul(ABERTH_ROOT_SPACING_SCALE).div(n)));
+            roots.push(new Complex_1.Complex(r.mul(decimal_js_1.default.cos(angle)), r.mul(decimal_js_1.default.sin(angle))));
+        }
+        // Aberth iterations
+        for (let iter = 0; iter < ABERTH_MAX_ITERATIONS; iter++) {
+            let maxChange = new decimal_js_1.default(0);
+            const newRoots = [];
+            for (let i = 0; i < n; i++) {
+                const z = roots[i];
+                // Compute P(z) and P'(z)
+                const [pz, qp] = this.syntheticDiv(n, P, z);
+                const [dpz, _] = this.syntheticDiv(n - 1, qp, z);
+                if (dpz.abs().lessThan(this.eps)) {
+                    newRoots.push(z);
+                    continue;
+                }
+                // Compute Aberth correction
+                const newton = pz.div(dpz);
+                // Sum of 1/(z_i - z_j) for j != i
+                let sum = new Complex_1.Complex(0, 0);
+                for (let j = 0; j < n; j++) {
+                    if (i !== j) {
+                        const diff = z.sub(roots[j]);
+                        if (diff.abs().greaterThan(this.eps)) {
+                            sum = sum.add(new Complex_1.Complex(1, 0).div(diff));
+                        }
+                    }
+                }
+                // Aberth correction: w = N(z) / (1 - N(z) * sum)
+                const denom = new Complex_1.Complex(1, 0).sub(newton.mul(sum));
+                const correction = denom.abs().lessThan(this.eps)
+                    ? newton
+                    : newton.div(denom);
+                const newZ = z.sub(correction);
+                newRoots.push(newZ);
+                const change = correction.abs();
+                if (change.greaterThan(maxChange)) {
+                    maxChange = change;
+                }
+            }
+            for (let i = 0; i < n; i++) {
+                roots[i] = newRoots[i];
+            }
+            // Check convergence
+            if (maxChange.lessThan(this.eps.mul(ABERTH_CONVERGENCE_SCALE))) {
+                break;
+            }
+        }
+        // Final refinement with Newton's method
+        for (let i = 0; i < n; i++) {
+            roots[i] = this.newtonRefine(P, roots[i]);
+        }
+        return roots;
+    }
+    /**
+     * Compute Cauchy bound for root magnitudes
+     */
+    cauchyBound(P) {
+        const n = P.length - 1;
+        let maxRatio = new decimal_js_1.default(0);
+        for (let i = 1; i <= n; i++) {
+            const ratio = P[i].abs().div(P[0].abs());
+            if (ratio.greaterThan(maxRatio)) {
+                maxRatio = ratio;
+            }
+        }
+        return maxRatio.plus(1);
+    }
+    complexSqrt(z) {
+        const mag = z.abs();
+        if (mag.isZero()) {
+            return new Complex_1.Complex(0, 0);
+        }
+        const x = z.re;
+        const y = z.im;
+        if (y.abs().lessThan(this.eps)) {
+            if (x.greaterThanOrEqualTo(0)) {
+                return new Complex_1.Complex(x.sqrt(), 0);
+            }
+            else {
+                return new Complex_1.Complex(0, x.neg().sqrt());
+            }
+        }
+        const w = mag.plus(x.abs()).div(2).sqrt();
+        if (x.greaterThanOrEqualTo(0)) {
+            return new Complex_1.Complex(w, y.div(w.mul(2)));
+        }
+        else {
+            const absY = y.abs();
+            const imPart = y.greaterThanOrEqualTo(0) ? w : w.neg();
+            return new Complex_1.Complex(absY.div(w.mul(2)), imPart);
+        }
+    }
+    finalize(roots, asExpressions, precision, cleanupComponents = true) {
+        // Restore the precision
+        decimal_js_1.default.set({ precision: precision });
+        if (asExpressions) {
+            return roots.map(root => {
+                let re = root.re;
+                let im = root.im;
+                if (cleanupComponents) {
+                    const magnitude = root.abs();
+                    const componentTolerance = magnitude.mul(this.eps);
+                    re = root.re.abs().lt(componentTolerance) ? new decimal_js_1.default(0) : root.re;
+                    im = root.im.abs().lt(componentTolerance) ? new decimal_js_1.default(0) : root.im;
+                }
+                const retval = Expression_1.Expression.create(re).plus(Expression_1.Expression.Img().times(im));
+                return retval;
+            });
+        }
+        return roots;
+    }
+    /**
+     * Refine a single root using Newton's method
+     */
+    newtonRefine(P, z) {
+        for (let iter = 0; iter < NEWTON_MAX_ITERATIONS; iter++) {
+            const [pz, qp] = this.syntheticDiv(P.length - 1, P, z);
+            if (pz.abs().lessThan(this.eps.mul(NEWTON_CONVERGENCE_SCALE))) {
+                break;
+            }
+            const [dpz, _] = this.syntheticDiv(P.length - 2, qp, z);
+            if (dpz.abs().lessThan(this.eps)) {
+                break;
+            }
+            const correction = pz.div(dpz);
+            const newZ = z.sub(correction);
+            if (correction.abs().lessThan(this.eps.mul(NEWTON_CONVERGENCE_SCALE).mul(newZ.abs().plus(1)))) {
+                z = newZ;
+                break;
+            }
+            z = newZ;
+        }
+        return z;
+    }
+    solveQuadratic(p) {
+        const a = p[0];
+        const b = p[1];
+        const c = p[2];
+        const b2 = b.mul(b);
+        const ac4 = a.mul(c).scale(4);
+        const disc = b2.sub(ac4);
+        const sqrtDisc = this.complexSqrt(disc);
+        const twoA = a.scale(2);
+        const negB = b.neg();
+        return [negB.add(sqrtDisc).div(twoA), negB.sub(sqrtDisc).div(twoA)];
+    }
+    /**
+     * Synthetic division
+     * Returns [P(s), quotient Q] where P(x) = (x-s)*Q(x) + P(s)
+     */
+    syntheticDiv(n, P, s) {
+        const Q = [];
+        let b = P[0];
+        Q[0] = b;
+        for (let i = 1; i <= n; i++) {
+            b = b.mul(s).add(P[i]);
+            if (i < n) {
+                Q[i] = b;
+            }
+        }
+        return [b, Q];
+    }
+    roots(asExpressions = true) {
+        // Store the currently used precision
+        const precision = decimal_js_1.default.precision;
+        // Set the precision to a high number. Default = 50
+        decimal_js_1.default.set({ precision: this.precision });
+        // Remove leading zeros and normalize
+        let poly = [...this.p];
+        let deg = this.degree;
+        while (deg > 0 && poly[0].re.isZero() && poly[0].im.isZero()) {
+            poly.shift();
+            deg--;
+        }
+        if (deg === 0) {
+            return this.finalize([], asExpressions, precision);
+        }
+        const lead = poly[0];
+        poly = poly.map(c => c.div(lead));
+        if (deg === 1) {
+            return this.finalize([poly[1].neg()], asExpressions, precision);
+        }
+        if (deg === 2) {
+            // Quadratic roots are computed analytically, so preserve small components instead of
+            // treating them as iterative noise.
+            return this.finalize(this.solveQuadratic(poly), asExpressions, precision, false);
+        }
+        // For degree >= 3, use Aberth method for better numerical stability
+        const roots = this.aberthMethod(poly);
+        return this.finalize(roots, asExpressions, precision);
+    }
+}
+exports.PolynomialSolver = PolynomialSolver;