nerdamer 1.1.13 → 2.0.0-rc.2

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,104 @@
+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`. Expression, Polynomial, and string inputs are converted directly
+ * to numerical complex coefficients 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 expression, Polynomial, polynomial string, or ascending-power
+     * Decimal 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 symbolic input is multivariate, uses a
+     * variable different from `variable`, or has nonnumeric coefficients.
+     */
+    constructor(input: Decimal[] | Polynomial | Expression | string, variable?: string, precision?: number, epsilon?: Decimal);
+    /**
+     * Aberth method: simultaneous approximation of all roots
+     * More stable than deflation for high-degree polynomials
+     */
+    private aberthMethod;
+    private complexSqrt;
+    /**
+     * Evaluates a polynomial and its derivative together using Horner's method.
+     */
+    private evaluateWithDerivative;
+    private finalize;
+    private isNumericalRoot;
+    /**
+     * Uses native double-precision arithmetic to locate starting points for Decimal refinement.
+     *
+     * Returning `null` leaves the existing Decimal Aberth implementation responsible for the
+     * complete solve.
+     */
+    private nativeAberthSeeds;
+    /**
+     * Refine a single root using Newton's method
+     */
+    private newtonRefine;
+    /**
+     * Computes a Lagrange-Fujiwara upper bound for root magnitudes.
+     *
+     * For a polynomial with leading coefficient a_n, every root lies within
+     * 2 * max(|a_(n-i) / a_n|^(1/i)). This is substantially tighter than the
+     * simple Cauchy bound for polynomials with large middle coefficients.
+     *
+     * @see https://doi.org/10.1016/S0377-0427(03)00381-9
+     */
+    private rootMagnitudeBound;
+    private solveQuadratic;
+    /**
+     * 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[];
+    /**
+     * Computes roots numerically, rejects candidates with an excessive polynomial residual,
+     * and converts accepted values only after numerical validation is complete.
+     */
+    validatedRoots(asExpressions?: true): Expression[];
+    validatedRoots(asExpressions?: false): Complex[];
+}