nerdamer 2.0.0-rc.1 → 2.0.0

package/output/math/trig.js

@@ -402,8 +402,8 @@ function tan(x) {
             retval = Expression_1.Expression.Number(x.getMultiplier().toDecimal().tan());
         }
         else if (Settings_1.Settings.EVALUATE && x.isComplex()) {
-            const dblRe = x.realPart().times(2);
-            const dblIm = x.imagPart().times(2);
+            const dblRe = x.realPart().times((0, shortcuts_1.two)());
+            const dblIm = x.imagPart().times((0, shortcuts_1.two)());
             const d = cos(dblRe).plus(cosh(dblIm));
             retval = sin(dblRe).div(d).plus(sinh(dblIm).div(d).i());
         }
@@ -599,7 +599,7 @@ function acos(x) {
     let retval;
     if (Settings_1.Settings.EVALUATE && x.isNUM()) {
         // Becomes complex between [-1, 1]
-        if (x.lt(-1) || x.gt(1)) {
+        if (x.lt((0, shortcuts_1.minusOne)()) || x.gt((0, shortcuts_1.one)())) {
             const sgn = x.sign();
             const halfPi = Expression_1.Expression.Pi().div((0, shortcuts_1.two)());
             let asinX = asin(x.abs());
@@ -1225,7 +1225,7 @@ function acosh(x) {
         retval = Expression_1.Expression.Pi().div((0, shortcuts_1.two)()).times(Expression_1.Expression.Img());
     }
     else if (Settings_1.Settings.EVALUATE) {
-        if (x.isComplex() || x.lt('1')) {
+        if (x.isComplex() || x.lt((0, shortcuts_1.one)())) {
             const a = (0, math_1.sqrt)(x.plus((0, shortcuts_1.one)()));
             const b = (0, math_1.sqrt)(x.minus((0, shortcuts_1.one)()));
             const c = x.plus(a.times(b));

package/output/math/utils.d.ts

@@ -1,6 +1,12 @@
+import { Collection } from '../core/classes/collection/Collection';
 import { Expression } from '../core/classes/expression/Expression';
 export { product, stripPower, sum } from '../core/classes/expression/utils';
 import type { ExpressionInput, ParserEntity } from '../core/types';
+/**
+ * Returns the continued-fraction decomposition as a Collection containing
+ * sign, whole part, and a Vector of partial quotients.
+ */
+export declare function continuedFraction(x: ExpressionInput, depth?: ExpressionInput): Collection;
 /**
  * Contains useful functions which are not likely to be exported to the user through `build`
  */

package/output/math/utils.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.sum = exports.stripPower = exports.product = void 0;
+exports.continuedFraction = continuedFraction;
 exports.toFactor = toFactor;
 exports.roots = roots;
 exports.getCombinations = getCombinations;
@@ -23,7 +24,45 @@ const Matrix_1 = require("../core/classes/matrix/Matrix");
 const constants_1 = require("../core/classes/parser/constants");
 const ValuesSet_1 = require("../core/classes/valuesSet/ValuesSet");
 const Vector_1 = require("../core/classes/vector/Vector");
+const errors_1 = require("../core/errors");
 const primeFactor_1 = require("../core/functions/bigint/primeFactor");
+/**
+ * Returns the continued-fraction decomposition as a Collection containing
+ * sign, whole part, and a Vector of partial quotients.
+ */
+function continuedFraction(x, depth = 10) {
+    const input = Expression_1.Expression.create(x);
+    const limitExpression = Expression_1.Expression.create(depth);
+    if (!limitExpression.isNUM() ||
+        !limitExpression.isInteger() ||
+        limitExpression.lt((0, shortcuts_1.zero)()) ||
+        limitExpression.getMultiplier().numerator > BigInt(Number.MAX_SAFE_INTEGER)) {
+        throw new errors_1.UnexpectedInputError((0, errors_1.message)('wrongInput', {
+            expected: 'a non-negative integer',
+            received: limitExpression.text(),
+        }));
+    }
+    const limit = Number(limitExpression.getMultiplier().numerator);
+    const evaluated = input.isConstant() ? input.evaluate() : input;
+    if (!evaluated.isNUM()) {
+        return new Collection_1.Collection([(0, shortcuts_1.one)(), input, new Vector_1.Vector()]);
+    }
+    const rational = evaluated.getMultiplier();
+    const sign = Expression_1.Expression.Number(rational.sign());
+    const numerator = rational.numerator < 0n ? -rational.numerator : rational.numerator;
+    let denominator = rational.denominator;
+    const whole = numerator / denominator;
+    let remainder = numerator % denominator;
+    const fractions = [];
+    for (let i = 0; i < limit && remainder !== 0n; i++) {
+        const quotient = denominator / remainder;
+        fractions.push(Expression_1.Expression.Number(quotient));
+        const nextRemainder = denominator % remainder;
+        denominator = remainder;
+        remainder = nextRemainder;
+    }
+    return new Collection_1.Collection([sign, Expression_1.Expression.Number(whole), new Vector_1.Vector(fractions)]);
+}
 /**
  * Contains useful functions which are not likely to be exported to the user through `build`
  */

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

@@ -6,8 +6,8 @@ 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
+ * 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.
  *
@@ -36,37 +36,50 @@ export declare class PolynomialSolver {
     /**
      * Creates a polynomial root solver.
      *
-     * @param input - A polynomial, a polynomial string, or ascending-power
-     * coefficients.
+     * @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 polynomial or string input is multivariate or
-     * uses a variable different from `variable`.
+     * @throws {@link core!UnexpectedInputError} If symbolic input is multivariate, uses a
+     * variable different from `variable`, or has nonnumeric coefficients.
      */
-    constructor(input: Decimal[] | Polynomial | string, variable?: string, precision?: number, epsilon?: Decimal);
+    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;
     /**
-     * Compute Cauchy bound for root magnitudes
+     * Evaluates a polynomial and its derivative together using Horner's method.
      */
-    private cauchyBound;
-    private complexSqrt;
+    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;
-    private solveQuadratic;
     /**
-     * Synthetic division
-     * Returns [P(s), quotient Q] where P(x) = (x-s)*Q(x) + P(s)
+     * 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 syntheticDiv;
+    private rootMagnitudeBound;
+    private solveQuadratic;
     /**
      * Computes the roots of the configured polynomial.
      *
@@ -82,4 +95,10 @@ export declare class PolynomialSolver {
      */
     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[];
 }

package/output/solve/classes/PolynomialSolver.js

@@ -9,6 +9,7 @@ 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 bigint_1 = require("../../core/functions/bigint/bigint");
 const DEFAULT_PRECISION = 50;
 const DEFAULT_EPSILON = 1e-14;
 const ABERTH_MAX_ITERATIONS = 100;
@@ -18,12 +19,13 @@ const ABERTH_ROOT_SPACING_SCALE = 0.01;
 const ABERTH_CONVERGENCE_SCALE = 1e-2;
 const NEWTON_MAX_ITERATIONS = 20;
 const NEWTON_CONVERGENCE_SCALE = 1e-6;
+const NATIVE_EPSILON_SCALE = 16;
 /**
  * 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
+ * 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.
  *
@@ -52,33 +54,73 @@ class PolynomialSolver {
     /**
      * Creates a polynomial root solver.
      *
-     * @param input - A polynomial, a polynomial string, or ascending-power
-     * coefficients.
+     * @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 polynomial or string input is multivariate or
-     * uses a variable different from `variable`.
+     * @throws {@link core!UnexpectedInputError} If symbolic input is multivariate, uses a
+     * variable different from `variable`, or has nonnumeric coefficients.
      */
     constructor(input, variable, precision = DEFAULT_PRECISION, epsilon) {
-        // Allow for input to be a string
-        if (typeof input === 'string') {
-            input = new Polynomial_1.Polynomial(input);
+        let coefficients;
+        if (Array.isArray(input)) {
+            coefficients = input.map(coefficient => new Complex_1.Complex(coefficient, 0));
         }
-        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)) {
+        else {
+            const polynomialInput = Polynomial_1.Polynomial.isPolynomial(input);
+            const expression = polynomialInput
+                ? input.getExpression()
+                : typeof input === 'string'
+                    ? Expression_1.Expression.create(input)
+                    : input;
+            const variables = polynomialInput ? input.variables : expression.variables();
+            if (!expression.isPolynomialLike()) {
+                throw new errors_1.PolynomialError((0, errors_1.message)('notAPolynomial'));
+            }
+            if (variables.length > 1 ||
+                (variables.length === 1 && variable && variables[0] !== variable)) {
                 throw new errors_1.UnexpectedInputError((0, errors_1.message)('tooManyUnknowns'));
             }
+            const coefficientVariable = variable ?? variables[0];
+            const coefficientExpressions = coefficientVariable === undefined
+                ? [expression]
+                : expression.coeffs(coefficientVariable).toArray();
+            const numericComponents = coefficientExpressions.map(coefficient => {
+                const real = coefficient.realPart();
+                const imaginary = coefficient.imagPart();
+                if (!real.isNUM() || !imaginary.isNUM()) {
+                    throw new errors_1.UnexpectedInputError((0, errors_1.message)('wrongInput', {
+                        expected: 'numeric polynomial coefficients',
+                        received: coefficient.text(),
+                    }));
+                }
+                return {
+                    real: real.getMultiplier(),
+                    imaginary: imaginary.getMultiplier(),
+                };
+            });
+            const exactRationals = numericComponents.every(component => !component.real.asDecimal && !component.imaginary.asDecimal);
+            if (exactRationals) {
+                const commonDenominator = (0, bigint_1.LCM)(...numericComponents.flatMap(component => [
+                    component.real.denominator,
+                    component.imaginary.denominator,
+                ]));
+                coefficients = numericComponents.map(component => {
+                    const real = component.real.numerator *
+                        (commonDenominator / component.real.denominator);
+                    const imaginary = component.imaginary.numerator *
+                        (commonDenominator / component.imaginary.denominator);
+                    return new Complex_1.Complex(new decimal_js_1.default(String(real)), new decimal_js_1.default(String(imaginary)));
+                });
+            }
+            else {
+                coefficients = numericComponents.map(component => new Complex_1.Complex(component.real.toDecimal(), component.imaginary.toDecimal()));
+            }
         }
-        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.p = coefficients.slice().reverse();
         this.degree = this.p.length - 1;
         this.eps = epsilon || new decimal_js_1.default(DEFAULT_EPSILON);
         this.precision = precision;
@@ -91,7 +133,7 @@ class PolynomialSolver {
         const n = P.length - 1;
         // Initialize roots on a circle
         const roots = [];
-        const radius = this.cauchyBound(P);
+        const radius = this.rootMagnitudeBound(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
@@ -99,16 +141,18 @@ class PolynomialSolver {
                 .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))));
         }
+        const epsSquared = this.eps.mul(this.eps);
+        const convergenceTolerance = this.eps.mul(ABERTH_CONVERGENCE_SCALE);
+        const convergenceToleranceSquared = convergenceTolerance.mul(convergenceTolerance);
         // Aberth iterations
         for (let iter = 0; iter < ABERTH_MAX_ITERATIONS; iter++) {
-            let maxChange = new decimal_js_1.default(0);
+            let maxChangeSquared = 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)) {
+                // Compute P(z) and P'(z) together.
+                const [pz, dpz] = this.evaluateWithDerivative(P, z);
+                if (dpz.absSquared().lessThan(epsSquared)) {
                     newRoots.push(z);
                     continue;
                 }
@@ -119,28 +163,28 @@ class PolynomialSolver {
                 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));
+                        if (diff.absSquared().greaterThan(epsSquared)) {
+                            sum = sum.add(diff.reciprocal());
                         }
                     }
                 }
                 // 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)
+                const correction = denom.absSquared().lessThan(epsSquared)
                     ? newton
                     : newton.div(denom);
                 const newZ = z.sub(correction);
                 newRoots.push(newZ);
-                const change = correction.abs();
-                if (change.greaterThan(maxChange)) {
-                    maxChange = change;
+                const changeSquared = correction.absSquared();
+                if (changeSquared.greaterThan(maxChangeSquared)) {
+                    maxChangeSquared = changeSquared;
                 }
             }
             for (let i = 0; i < n; i++) {
                 roots[i] = newRoots[i];
             }
             // Check convergence
-            if (maxChange.lessThan(this.eps.mul(ABERTH_CONVERGENCE_SCALE))) {
+            if (maxChangeSquared.lessThan(convergenceToleranceSquared)) {
                 break;
             }
         }
@@ -150,20 +194,6 @@ class PolynomialSolver {
         }
         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()) {
@@ -189,6 +219,20 @@ class PolynomialSolver {
             return new Complex_1.Complex(absY.div(w.mul(2)), imPart);
         }
     }
+    /**
+     * Evaluates a polynomial and its derivative together using Horner's method.
+     */
+    evaluateWithDerivative(P, z) {
+        const n = P.length - 1;
+        let value = P[0];
+        let derivative = P[0];
+        for (let i = 1; i < n; i++) {
+            value = value.mul(z).add(P[i]);
+            derivative = derivative.mul(z).add(value);
+        }
+        value = value.mul(z).add(P[n]);
+        return [value, derivative];
+    }
     finalize(roots, asExpressions, precision, cleanupComponents = true) {
         // Restore the precision
         decimal_js_1.default.set({ precision: precision });
@@ -208,22 +252,154 @@ class PolynomialSolver {
         }
         return roots;
     }
+    isNumericalRoot(root) {
+        let residual = this.p[0];
+        let scale = this.p[0].abs();
+        const magnitude = root.abs();
+        for (let i = 1; i < this.p.length; i++) {
+            residual = residual.mul(root).add(this.p[i]);
+            scale = scale.mul(magnitude).plus(this.p[i].abs());
+        }
+        const tolerance = this.eps.mul(scale.plus(1));
+        return residual.absSquared().lte(tolerance.mul(tolerance));
+    }
+    /**
+     * 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.
+     */
+    nativeAberthSeeds(P) {
+        const n = P.length - 1;
+        const nativeP = [];
+        for (const coefficient of P) {
+            const re = coefficient.re.toNumber();
+            const im = coefficient.im.toNumber();
+            if (!Number.isFinite(re) || !Number.isFinite(im)) {
+                return null;
+            }
+            nativeP.push({ re, im });
+        }
+        const leadMagnitude = Math.hypot(nativeP[0].re, nativeP[0].im);
+        if (!Number.isFinite(leadMagnitude) || leadMagnitude === 0) {
+            return null;
+        }
+        const radius = this.rootMagnitudeBound(P).toNumber();
+        if (!Number.isFinite(radius)) {
+            return null;
+        }
+        const roots = [];
+        for (let k = 0; k < n; k++) {
+            const angle = (2 * Math.PI * k) / n + ABERTH_INITIAL_ANGLE_OFFSET;
+            const r = radius *
+                ABERTH_RADIUS_SCALE *
+                (1 + (k * ABERTH_ROOT_SPACING_SCALE) / n);
+            roots.push({ re: r * Math.cos(angle), im: r * Math.sin(angle) });
+        }
+        const nativeTolerance = Math.max(this.eps.toNumber(), Number.EPSILON * NATIVE_EPSILON_SCALE);
+        const epsSquared = nativeTolerance * nativeTolerance;
+        for (let iter = 0; iter < ABERTH_MAX_ITERATIONS; iter++) {
+            let maxChangeSquared = 0;
+            const newRoots = [];
+            for (let i = 0; i < n; i++) {
+                const z = roots[i];
+                let valueRe = nativeP[0].re;
+                let valueIm = nativeP[0].im;
+                let derivativeRe = nativeP[0].re;
+                let derivativeIm = nativeP[0].im;
+                for (let k = 1; k < n; k++) {
+                    const nextValueRe = valueRe * z.re - valueIm * z.im + nativeP[k].re;
+                    const nextValueIm = valueRe * z.im + valueIm * z.re + nativeP[k].im;
+                    const nextDerivativeRe = derivativeRe * z.re - derivativeIm * z.im + nextValueRe;
+                    const nextDerivativeIm = derivativeRe * z.im + derivativeIm * z.re + nextValueIm;
+                    valueRe = nextValueRe;
+                    valueIm = nextValueIm;
+                    derivativeRe = nextDerivativeRe;
+                    derivativeIm = nextDerivativeIm;
+                }
+                const finalValueRe = valueRe * z.re - valueIm * z.im + nativeP[n].re;
+                const finalValueIm = valueRe * z.im + valueIm * z.re + nativeP[n].im;
+                const derivativeMagnitudeSquared = derivativeRe * derivativeRe + derivativeIm * derivativeIm;
+                if (!Number.isFinite(finalValueRe) ||
+                    !Number.isFinite(finalValueIm) ||
+                    !Number.isFinite(derivativeMagnitudeSquared)) {
+                    return null;
+                }
+                if (derivativeMagnitudeSquared < epsSquared) {
+                    newRoots.push(z);
+                    continue;
+                }
+                const newtonRe = (finalValueRe * derivativeRe + finalValueIm * derivativeIm) /
+                    derivativeMagnitudeSquared;
+                const newtonIm = (finalValueIm * derivativeRe - finalValueRe * derivativeIm) /
+                    derivativeMagnitudeSquared;
+                let sumRe = 0;
+                let sumIm = 0;
+                for (let j = 0; j < n; j++) {
+                    if (i === j) {
+                        continue;
+                    }
+                    const diffRe = z.re - roots[j].re;
+                    const diffIm = z.im - roots[j].im;
+                    const diffMagnitudeSquared = diffRe * diffRe + diffIm * diffIm;
+                    if (diffMagnitudeSquared > epsSquared) {
+                        sumRe += diffRe / diffMagnitudeSquared;
+                        sumIm -= diffIm / diffMagnitudeSquared;
+                    }
+                }
+                const productRe = newtonRe * sumRe - newtonIm * sumIm;
+                const productIm = newtonRe * sumIm + newtonIm * sumRe;
+                const denomRe = 1 - productRe;
+                const denomIm = -productIm;
+                const denomMagnitudeSquared = denomRe * denomRe + denomIm * denomIm;
+                let correctionRe = newtonRe;
+                let correctionIm = newtonIm;
+                if (denomMagnitudeSquared >= epsSquared) {
+                    correctionRe =
+                        (newtonRe * denomRe + newtonIm * denomIm) / denomMagnitudeSquared;
+                    correctionIm =
+                        (newtonIm * denomRe - newtonRe * denomIm) / denomMagnitudeSquared;
+                }
+                const newRoot = {
+                    re: z.re - correctionRe,
+                    im: z.im - correctionIm,
+                };
+                const changeSquared = correctionRe * correctionRe + correctionIm * correctionIm;
+                if (!Number.isFinite(newRoot.re) ||
+                    !Number.isFinite(newRoot.im) ||
+                    !Number.isFinite(changeSquared)) {
+                    return null;
+                }
+                newRoots.push(newRoot);
+                maxChangeSquared = Math.max(maxChangeSquared, changeSquared);
+            }
+            for (let i = 0; i < n; i++) {
+                roots[i] = newRoots[i];
+            }
+            if (maxChangeSquared < epsSquared) {
+                break;
+            }
+        }
+        return roots.map(root => new Complex_1.Complex(new decimal_js_1.default(root.re), new decimal_js_1.default(root.im)));
+    }
     /**
      * Refine a single root using Newton's method
      */
     newtonRefine(P, z) {
+        const epsSquared = this.eps.mul(this.eps);
+        const convergenceTolerance = this.eps.mul(NEWTON_CONVERGENCE_SCALE);
+        const convergenceToleranceSquared = convergenceTolerance.mul(convergenceTolerance);
         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))) {
+            const [pz, dpz] = this.evaluateWithDerivative(P, z);
+            if (pz.absSquared().lessThan(convergenceToleranceSquared)) {
                 break;
             }
-            const [dpz, _] = this.syntheticDiv(P.length - 2, qp, z);
-            if (dpz.abs().lessThan(this.eps)) {
+            if (dpz.absSquared().lessThan(epsSquared)) {
                 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)))) {
+            if (correction.abs().lessThan(convergenceTolerance.mul(newZ.abs().plus(1)))) {
                 z = newZ;
                 break;
             }
@@ -231,6 +407,29 @@ class PolynomialSolver {
         }
         return z;
     }
+    /**
+     * 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
+     */
+    rootMagnitudeBound(P) {
+        let maxCandidate = new decimal_js_1.default(0);
+        const leadingMagnitude = P[0].abs();
+        for (let i = 1; i < P.length; i++) {
+            const ratio = P[i].abs().div(leadingMagnitude);
+            if (!ratio.isZero()) {
+                const candidate = ratio.pow(new decimal_js_1.default(1).div(i));
+                if (candidate.greaterThan(maxCandidate)) {
+                    maxCandidate = candidate;
+                }
+            }
+        }
+        return maxCandidate.mul(2);
+    }
     solveQuadratic(p) {
         const a = p[0];
         const b = p[1];
@@ -243,22 +442,6 @@ class PolynomialSolver {
         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;
@@ -284,9 +467,26 @@ class PolynomialSolver {
             // treating them as iterative noise.
             return this.finalize(this.solveQuadratic(poly), asExpressions, precision, false);
         }
-        // For degree >= 3, use Aberth method for better numerical stability
+        // Native doubles are sufficient to locate ordinary roots. Refine those seeds with
+        // Decimal arithmetic and accept them only when every root passes the existing residual check.
+        const nativeSeeds = this.nativeAberthSeeds(poly);
+        if (nativeSeeds) {
+            const nativeRoots = nativeSeeds.map(root => this.newtonRefine(poly, root));
+            if (nativeRoots.length === deg &&
+                nativeRoots.every(root => this.isNumericalRoot(root))) {
+                return this.finalize(nativeRoots, asExpressions, precision);
+            }
+        }
+        // Fall back to the Decimal Aberth implementation when native seeding is unavailable
+        // or does not survive Decimal refinement and validation.
         const roots = this.aberthMethod(poly);
         return this.finalize(roots, asExpressions, precision);
     }
+    validatedRoots(asExpressions = true) {
+        const precision = decimal_js_1.default.precision;
+        decimal_js_1.default.set({ precision: this.precision });
+        const roots = this.roots(false).filter(root => this.isNumericalRoot(root));
+        return this.finalize(roots, asExpressions, precision);
+    }
 }
 exports.PolynomialSolver = PolynomialSolver;