nerdamer 2.0.0-rc.1 → 2.0.0

package/output/algebra/dispatch.d.ts

@@ -0,0 +1 @@
+export declare function loadAlgebraFunctions(): void;

package/output/algebra/dispatch.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadAlgebraFunctions = loadAlgebraFunctions;
+const constants_1 = require("../core/classes/parser/constants");
+const dispatch_1 = require("../core/dispatch");
+const adapters_1 = require("./adapters");
+const factor_1 = require("./factor/factor");
+const gcd_1 = require("./gcd/gcd");
+const groebner_1 = require("./groebner");
+const partfrac_1 = require("./partfrac");
+const simplify_1 = require("./simplify/simplify");
+function loadAlgebraFunctions() {
+    Object.assign(dispatch_1.mathFunctionRegistry, {
+        polyfactors: (0, dispatch_1.systemFunction)({ fn: factor_1.polyFactors, minArgs: 1, maxArgs: 1, distElWise: false }),
+        factor: (0, dispatch_1.systemFunction)({ fn: factor_1.factor, minArgs: 1, maxArgs: 1, distElWise: true }),
+        [constants_1.PFACTOR]: (0, dispatch_1.systemFunction)({ fn: factor_1.pfactor, minArgs: 1, maxArgs: 1, distElWise: false }),
+        [constants_1.PFACTORD]: (0, dispatch_1.systemFunction)({ fn: factor_1.pfactord, minArgs: 1, maxArgs: 1, distElWise: false }),
+        simplify: (0, dispatch_1.systemFunction)({ fn: simplify_1.simplify, minArgs: 1, maxArgs: 1, distElWise: true }),
+        partfrac: (0, dispatch_1.systemFunction)({ fn: partfrac_1.partfrac, minArgs: 1, maxArgs: 2, distElWise: true }),
+        gcd: (0, dispatch_1.systemFunction)({ fn: gcd_1.gcd, minArgs: 2, maxArgs: 2, distElWise: true }),
+        lcm: (0, dispatch_1.systemFunction)({ fn: gcd_1.lcm, minArgs: 2, maxArgs: 2, distElWise: true }),
+        groebner: (0, dispatch_1.systemFunction)({ fn: groebner_1.groebner, minArgs: 1, maxArgs: 2, distElWise: false }),
+        sqcomp: (0, dispatch_1.systemFunction)({ fn: adapters_1.completeSquare, minArgs: 1, maxArgs: 2, distElWise: true }),
+    });
+}

package/output/algebra/factor/factor.d.ts

@@ -1,3 +1,4 @@
+import { Dictionary } from '../../core/classes/dictionary/Dictionary';
 import { Expression } from '../../core/classes/expression/Expression';
 import { Vector } from '../../core/classes/vector/Vector';
 import type { ExpressionInput } from '../../core/types';
@@ -15,6 +16,20 @@ import type { ExpressionInput } from '../../core/types';
  * @returns A factored expression or an unevaluated symbolic `factor` call.
  */
 export declare function factor(x: ExpressionInput): Expression;
+/**
+ * Returns the prime factors of a positive integer in ascending order.
+ *
+ * Repeated factors are retained, so `pfactor(100)` returns `[2, 2, 5, 5]`.
+ * The value 1 has no prime factors and returns an empty Vector.
+ */
+export declare function pfactor(x: ExpressionInput): Vector;
+/**
+ * Returns the prime-factor multiplicities of a positive integer.
+ *
+ * Dictionary keys are prime numbers in ascending order and values are their occurrence
+ * counts. For example, `pfactord(100)` returns `{2 => 2, 5 => 2}`.
+ */
+export declare function pfactord(x: ExpressionInput): Dictionary;
 /**
  * Factors the numerator of polynomial-like input into Expression factors.
  *

package/output/algebra/factor/factor.js

@@ -1,21 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.factor = factor;
+exports.pfactor = pfactor;
+exports.pfactord = pfactord;
 exports.polyFactorExpressions = polyFactorExpressions;
 exports.polyFactors = polyFactors;
 exports.factorExpressionParts = factorExpressionParts;
 exports.factors = factors;
 exports.numberFactors = numberFactors;
+const Dictionary_1 = require("../../core/classes/dictionary/Dictionary");
 const analysis_1 = require("../../core/classes/expression/analysis");
 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 multiply_1 = require("../../core/classes/parser/operations/multiply");
-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 primeFactor_1 = require("../../core/functions/bigint/primeFactor");
 const subst_1 = require("../../core/functions/subst");
-const adapters_1 = require("../adapters");
-const factor_1 = require("../algorithms/factor");
+const SparsePolynomialFactor_1 = require("../polynomial/SparsePolynomialFactor");
+const SparsePolynomialMultivariateFactor_1 = require("../polynomial/SparsePolynomialMultivariateFactor");
 const polynomialize_1 = require("../polynomialize");
 /**
  * Factors polynomial-like numerator and denominator components of an expression.
@@ -55,6 +60,15 @@ function factor(x) {
         else if (x.isVAR()) {
             retval = x;
         }
+        else if (x.isFunction()) {
+            const multiplier = x.getMultiplier();
+            const power = x.getPower();
+            retval = Expression_1.Expression.toFunction(x.name, x.getArguments().map(argument => factor(argument)));
+            retval = retval.pow(power).times(multiplier);
+        }
+        else if (x.isPolynomialLike()) {
+            retval = polyFactors(x).prod();
+        }
         else {
             const factored = factors(x);
             retval = factored.numerator.prod().div(factored.denominator.prod());
@@ -65,6 +79,56 @@ function factor(x) {
     }
     return retval;
 }
+/**
+ * Returns the prime factors of a positive integer in ascending order.
+ *
+ * Repeated factors are retained, so `pfactor(100)` returns `[2, 2, 5, 5]`.
+ * The value 1 has no prime factors and returns an empty Vector.
+ */
+function pfactor(x) {
+    const input = Expression_1.Expression.create(x);
+    if (!input.isNUM() || !input.isInteger() || input.lte((0, shortcuts_1.zero)())) {
+        throw new errors_1.UnexpectedInputError((0, errors_1.message)('wrongInput', {
+            expected: 'a positive integer',
+            received: input.text(),
+        }));
+    }
+    const value = input.getMultiplier().numerator;
+    if (value === 1n) {
+        return new Vector_1.Vector();
+    }
+    const factors = (0, primeFactor_1.primeFactorsBig)(value).factors.map(factor => Expression_1.Expression.Number(factor));
+    return new Vector_1.Vector(factors);
+}
+/**
+ * Returns the prime-factor multiplicities of a positive integer.
+ *
+ * Dictionary keys are prime numbers in ascending order and values are their occurrence
+ * counts. For example, `pfactord(100)` returns `{2 => 2, 5 => 2}`.
+ */
+function pfactord(x) {
+    const input = Expression_1.Expression.create(x);
+    if (!input.isNUM() || !input.isInteger() || input.lte((0, shortcuts_1.zero)())) {
+        throw new errors_1.UnexpectedInputError((0, errors_1.message)('wrongInput', {
+            expected: 'a positive integer',
+            received: input.text(),
+        }));
+    }
+    const value = input.getMultiplier().numerator;
+    if (value === 1n) {
+        return new Dictionary_1.Dictionary();
+    }
+    const counts = (0, primeFactor_1.primeFactorCounts)(value);
+    const retval = new Dictionary_1.Dictionary();
+    for (const prime of Object.keys(counts).sort((a, b) => {
+        const left = BigInt(a);
+        const right = BigInt(b);
+        return left < right ? -1 : left > right ? 1 : 0;
+    })) {
+        retval.set(prime, Expression_1.Expression.Number(counts[prime]));
+    }
+    return retval;
+}
 /**
  * Factors the numerator of polynomial-like input into Expression factors.
  *
@@ -77,16 +141,39 @@ function polyFactorExpressions(x) {
         const expr = (0, analysis_1.normalizeMultiplierDenominators)(Expression_1.Expression.create(x));
         const num = expr.getNumerator();
         const den = expr.getDenominator();
-        // MultiPoly strictly works in Z. Irrational coefficients
-        // must first be promoted to variables.
+        // Irrational coefficients must first be promoted to variables.
         const [subbed, map] = (0, subst_1.uSubConstants)(num);
-        const p = new Polynomial_1.Polynomial(subbed);
-        const variables = p.variables;
-        const { poly } = (0, adapters_1.polynomialToMultiPoly)(p);
-        // Factor it
-        const factors = (0, factor_1.factorPoly)(poly, variables);
-        // Remove the u-substitution
-        retval = (0, adapters_1.factorsToExpressions)(factors, variables).map(f => (0, subst_1.uUnSub)(f, map).div(den));
+        const converted = (0, SparsePolynomialAdapter_1.expressionToSparsePolynomial)(subbed);
+        const variables = converted.variables;
+        const sparse = converted.polynomial;
+        if (variables.length === 0) {
+            retval = [Expression_1.Expression.Number(sparse.constantTerm())];
+        }
+        else {
+            const variableIndices = variables.map((_variable, index) => index);
+            const factorization = variables.length === 1
+                ? (0, SparsePolynomialFactor_1.factorUnivariateInteger)(sparse, 0)
+                : (0, SparsePolynomialMultivariateFactor_1.factorMultivariateInteger)(sparse, variableIndices);
+            retval = [];
+            if (factorization.content !== 1n) {
+                retval.push(Expression_1.Expression.Number(factorization.content));
+            }
+            for (const entry of factorization.factors) {
+                let factor = (0, SparsePolynomialAdapter_1.sparsePolynomialToExpression)(entry.factor, variables);
+                if (entry.multiplicity > 1n) {
+                    factor = factor.pow(Expression_1.Expression.Number(entry.multiplicity));
+                }
+                retval.push(factor);
+            }
+            if (retval.length === 0) {
+                throw new Error((0, errors_1.message)('factorizationNoFactors'));
+            }
+        }
+        // Remove the u-substitution and restore the cleared denominator once.
+        retval = retval.map(factor => (0, subst_1.uUnSub)(factor, map));
+        if (!den.isOne()) {
+            retval[0] = retval[0].div(den);
+        }
     }
     catch {
         retval = [Expression_1.Expression.create(x)];

package/output/algebra/gcd/gcd.d.ts

@@ -4,11 +4,12 @@ import type { ExpressionInput } from '../../core/types';
  * Computes a symbolic greatest common divisor over rational polynomial structure.
  *
  * @remarks
- * Numerators and denominators are polynomialized, function-valued or irrational
- * constants may be temporarily substituted, and the multivariate Zippel GCD is
- * verified by exact polynomial division. Factoring supplies an expensive final
- * fallback. When conversion or the supported polynomial algorithms fail, the
- * result remains symbolic as `gcd(x, y)`.
+ * Numerators and denominators are polynomialized before exact sparse integer GCD
+ * reconstruction. Rational polynomial coefficients are cleared to integers and
+ * their shared clearing denominator is restored afterward. Function-valued,
+ * exponential, and irrational constants use the existing polynomialization
+ * substitutions and are restored after the numerator and denominator GCDs are
+ * combined. Unsupported inputs remain symbolic as `gcd(x, y)`.
  *
  * @param x - First expression-compatible operand.
  * @param y - Second expression-compatible operand.
@@ -18,8 +19,8 @@ export declare function gcd(x: ExpressionInput, y: ExpressionInput): Expression;
 /**
  * Returns the least common multiple of two expressions.
  *
- * Numeric inputs reuse exact `Rational` arithmetic. Polynomial expressions use
- * the existing GCD normalization so shared symbolic factors are retained.
+ * Numeric inputs reuse exact Rational arithmetic. Polynomial expressions use
+ * the polynomial GCD so shared symbolic factors are retained.
  *
  * @param x - First expression-compatible operand.
  * @param y - Second expression-compatible operand.

package/output/algebra/gcd/gcd.js

@@ -6,22 +6,21 @@ 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 Polynomial_1 = require("../../core/classes/polynomial/Polynomial");
-const utils_1 = require("../../core/classes/polynomial/utils");
+const SparsePolynomialAdapter_1 = require("../../core/classes/polynomial/SparsePolynomialAdapter");
+const bigint_1 = require("../../core/functions/bigint/bigint");
 const subst_1 = require("../../core/functions/subst");
-const adapters_1 = require("../adapters");
-const gcd_1 = require("../algorithms/gcd");
-const factor_1 = require("../factor/factor");
+const SparsePolynomialGcd_1 = require("../polynomial/SparsePolynomialGcd");
 const polynomialize_1 = require("../polynomialize");
 /**
  * Computes a symbolic greatest common divisor over rational polynomial structure.
  *
  * @remarks
- * Numerators and denominators are polynomialized, function-valued or irrational
- * constants may be temporarily substituted, and the multivariate Zippel GCD is
- * verified by exact polynomial division. Factoring supplies an expensive final
- * fallback. When conversion or the supported polynomial algorithms fail, the
- * result remains symbolic as `gcd(x, y)`.
+ * Numerators and denominators are polynomialized before exact sparse integer GCD
+ * reconstruction. Rational polynomial coefficients are cleared to integers and
+ * their shared clearing denominator is restored afterward. Function-valued,
+ * exponential, and irrational constants use the existing polynomialization
+ * substitutions and are restored after the numerator and denominator GCDs are
+ * combined. Unsupported inputs remain symbolic as `gcd(x, y)`.
  *
  * @param x - First expression-compatible operand.
  * @param y - Second expression-compatible operand.
@@ -34,10 +33,10 @@ function gcd(x, y) {
         const asDecimal = x.hasDecimal() || y.hasDecimal();
         const { numerator: ax, denominator: bx, map } = (0, polynomialize_1.polynomialize)(x);
         const { numerator: px, denominator: qx, map: finalMap } = (0, polynomialize_1.polynomialize)(y, map);
-        const vars = (0, collect_1.collectVariablesSet)([ax, bx, px, qx]);
-        const g0 = expressionGCD(ax, px, vars);
-        const g1 = expressionGCD(bx, qx, vars);
-        const retval = (0, subst_1.uUnSub)(g0.div(g1), finalMap);
+        const variables = (0, collect_1.collectVariablesSet)([ax, bx, px, qx]);
+        const numeratorGcd = expressionGCD(ax, px, variables);
+        const denominatorGcd = expressionGCD(bx, qx, variables);
+        const retval = (0, subst_1.uUnSub)(numeratorGcd.div(denominatorGcd), finalMap);
         retval.getMultiplier().asDecimal = asDecimal;
         return retval;
     }
@@ -47,8 +46,8 @@ function gcd(x, y) {
 /**
  * Returns the least common multiple of two expressions.
  *
- * Numeric inputs reuse exact `Rational` arithmetic. Polynomial expressions use
- * the existing GCD normalization so shared symbolic factors are retained.
+ * Numeric inputs reuse exact Rational arithmetic. Polynomial expressions use
+ * the polynomial GCD so shared symbolic factors are retained.
  *
  * @param x - First expression-compatible operand.
  * @param y - Second expression-compatible operand.
@@ -71,71 +70,26 @@ function lcm(x, y) {
     return retval;
 }
 function expressionGCD(x, y, variables) {
-    let retval;
     if (x.isNUM() && y.isNUM()) {
-        retval = Expression_1.Expression.create(x.getMultiplier().GCD(y.getMultiplier()));
+        return Expression_1.Expression.create(x.getMultiplier().GCD(y.getMultiplier()));
     }
-    else {
-        const f = new Polynomial_1.Polynomial(x);
-        const g = new Polynomial_1.Polynomial(y);
-        if (f.isZero() && g.isZero()) {
-            return (0, shortcuts_1.zero)();
-        }
-        if (f.isZero()) {
-            return Expression_1.Expression.create(y);
-        }
-        if (g.isZero()) {
-            return Expression_1.Expression.create(x);
-        }
-        const { mGCD, p, q } = f.stripMonomialGCD(g);
-        variables ??= [...new Set(p.variables.concat(q.variables))].sort();
-        const { poly: poly1 } = (0, adapters_1.polynomialToMultiPoly)(p, variables);
-        const { poly: poly2 } = (0, adapters_1.polynomialToMultiPoly)(q, variables);
-        const g0 = (0, gcd_1.zippelGCDMulti)(poly1, poly2, variables);
-        retval = (0, adapters_1.multiPolyToExpression)(g0, variables);
-        // Verify
-        if (!(0, utils_1.divide)(p, retval)[1].isZero()) {
-            retval = (0, shortcuts_1.one)();
-        }
-        // Don't give up just yet. Try by factor
-        if (retval.isOne()) {
-            retval = gcdByCommonFactors(p.getExpression(), q.getExpression());
-        }
-        // Put back the monomial gcd
-        retval = retval.times(mGCD.getExpression());
+    if (x.isZero() && y.isZero()) {
+        return (0, shortcuts_1.zero)();
     }
-    return retval;
-}
-/**
- * Factors both expressions and compares their factors as a last-resort GCD strategy.
- *
- * Factoring is expensive, so this path runs only after exact polynomial reduction fails
- * to find a nontrivial divisor.
- */
-function gcdByCommonFactors(f, g) {
-    let retval = (0, shortcuts_1.one)();
-    if (!f.isProduct()) {
-        f = (0, factor_1.factor)(f);
+    if (x.isZero()) {
+        return Expression_1.Expression.create(y);
     }
-    if (!g.isProduct()) {
-        g = (0, factor_1.factor)(g);
+    if (y.isZero()) {
+        return Expression_1.Expression.create(x);
     }
-    // Only proceed if both are products
-    if (f.isProduct() && g.isProduct()) {
-        const fArray = f.elementsArray();
-        const gArray = g.elementsArray();
-        // Compare them
-        for (const a of fArray) {
-            for (const b of gArray) {
-                // If they're equal then they're a common factor
-                if (a.eq(b)) {
-                    retval = retval.times(a);
-                }
-                else if (a.isProduct() && b.isProduct()) {
-                    return gcd(a, b);
-                }
-            }
-        }
-    }
-    return retval;
+    variables ??= (0, collect_1.collectVariablesSet)([x, y]);
+    const left = (0, SparsePolynomialAdapter_1.expressionToIntegerSparsePolynomial)(x, variables);
+    const right = (0, SparsePolynomialAdapter_1.expressionToIntegerSparsePolynomial)(y, variables);
+    const variableIndices = variables.map((_variable, index) => index);
+    const sparseGcd = (0, SparsePolynomialGcd_1.sparsePolynomialGcd)(left.polynomial, right.polynomial, variableIndices);
+    const clearingDenominator = (0, bigint_1.GCD)(left.denominator, right.denominator);
+    const retval = (0, SparsePolynomialAdapter_1.sparsePolynomialToExpression)(sparseGcd, variables);
+    return clearingDenominator === 1n
+        ? retval
+        : retval.div(Expression_1.Expression.Number(clearingDenominator));
 }

package/output/algebra/groebner.d.ts

@@ -6,8 +6,8 @@ import type { ExpressionInput } from '../core/types';
  * @remarks
  * All generators are converted using one variable order so exponent indices remain
  * consistent. Rational coefficient denominators are cleared per generator before the
- * exact integer-coefficient `MultiPoly` engine runs; multiplying a generator by a
- * nonzero scalar preserves the generated ideal. When `vars` is omitted, variables are
+ * exact integer-coefficient sparse engine runs; multiplying a generator by a nonzero
+ * scalar preserves the generated ideal. When `vars` is omitted, variables are
  * collected across every generator.
  *
  * This convenience wrapper uses lexicographic order and a reduced, deterministically

package/output/algebra/groebner.js

@@ -1,12 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.groebner = groebner;
-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 Polynomial_1 = require("../core/classes/polynomial/Polynomial");
+const SparsePolynomialAdapter_1 = require("../core/classes/polynomial/SparsePolynomialAdapter");
 const Vector_1 = require("../core/classes/vector/Vector");
-const adapters_1 = require("./adapters");
 const groebnerBase_1 = require("./algorithms/groebnerBase");
 /**
  * Computes an expression-facing Groebner basis for polynomial generators.
@@ -14,8 +12,8 @@ const groebnerBase_1 = require("./algorithms/groebnerBase");
  * @remarks
  * All generators are converted using one variable order so exponent indices remain
  * consistent. Rational coefficient denominators are cleared per generator before the
- * exact integer-coefficient `MultiPoly` engine runs; multiplying a generator by a
- * nonzero scalar preserves the generated ideal. When `vars` is omitted, variables are
+ * exact integer-coefficient sparse engine runs; multiplying a generator by a nonzero
+ * scalar preserves the generated ideal. When `vars` is omitted, variables are
  * collected across every generator.
  *
  * This convenience wrapper uses lexicographic order and a reduced, deterministically
@@ -32,11 +30,7 @@ function groebner(expressionArray, vars) {
     // Get the unified variable list across ALL generators
     vars ??= (0, collect_1.collectVariablesSet)(expressions);
     // Convert each polynomial using the unified variable list so indices are consistent.
-    // Since the Groebner core operates on MultiPoly over Z, clear denominators per generator
-    // before converting so rational-coefficient inputs are lifted into equivalent integer ones.
-    const polys = expressions.map(e => {
-        const cleared = (0, analysis_1.normalizeMultiplierDenominators)(e);
-        return (0, adapters_1.polynomialToMultiPoly)(new Polynomial_1.Polynomial(cleared, vars), vars).poly;
-    });
-    return new Vector_1.Vector((0, groebnerBase_1.Groebner)(polys, vars).map(gb => (0, adapters_1.multiPolyToExpression)(gb, vars)));
+    // Rational denominators are cleared exactly while converting into the sparse ring.
+    const polys = expressions.map(e => (0, SparsePolynomialAdapter_1.expressionToIntegerSparsePolynomial)(e, vars).polynomial);
+    return new Vector_1.Vector((0, groebnerBase_1.Groebner)(polys).map(polynomial => (0, SparsePolynomialAdapter_1.sparsePolynomialToExpression)(polynomial, vars)));
 }

package/output/algebra/partfrac.d.ts

@@ -6,9 +6,9 @@ import type { ExpressionInput } from '../core/types';
  * @remarks
  * The routine extracts `P(x)/Q(x)`, performs polynomial long division for an improper
  * fraction, factors `Q` over the supported exact polynomial domain, and solves the
- * undetermined coefficients by exact evaluation and row reduction. Repeated linear
- * factors and irreducible quadratic factors are supported. An irreducible factor of
- * higher degree, a singular coefficient system, a denominator independent of the
+ * undetermined coefficients by exact evaluation and row reduction. Each denominator
+ * factor of degree d receives a numerator polynomial of degree less than d, including
+ * repeated factors. A singular coefficient system, a denominator independent of the
  * selected variable, or a factorization that does not expose a useful decomposition
  * leaves the original expression unchanged.
  *

package/output/algebra/partfrac.js

@@ -13,9 +13,9 @@ const factor_1 = require("./factor/factor");
  * @remarks
  * The routine extracts `P(x)/Q(x)`, performs polynomial long division for an improper
  * fraction, factors `Q` over the supported exact polynomial domain, and solves the
- * undetermined coefficients by exact evaluation and row reduction. Repeated linear
- * factors and irreducible quadratic factors are supported. An irreducible factor of
- * higher degree, a singular coefficient system, a denominator independent of the
+ * undetermined coefficients by exact evaluation and row reduction. Each denominator
+ * factor of degree d receives a numerator polynomial of degree less than d, including
+ * repeated factors. A singular coefficient system, a denominator independent of the
  * selected variable, or a factorization that does not expose a useful decomposition
  * leaves the original expression unchanged.
  *
@@ -161,53 +161,28 @@ function collectFactors(factors, v) {
 /**
  * Decomposes remainder/den into partial fractions given the factored denominator.
  *
- * For each linear factor (ax+b)^k:
- *   A₁/(ax+b) + A₂/(ax+b)² + ... + Aₖ/(ax+b)^k
- *
- * For each irreducible quadratic factor (ax²+bx+c)^k:
- *   (B₁x+C₁)/(ax²+bx+c) + ... + (Bₖx+Cₖ)/(ax²+bx+c)^k
+ * For each factor f(x)^k of degree d, the numerator at every power level is
+ * a polynomial of degree less than d. For example, a cubic factor receives
+ * A*x^2+B*x+C over each repeated power of that factor.
  *
  * Uses evaluation at strategic points to solve for coefficients.
  */
 function decompose(numerator, denominator, factors, v) {
     // Build the list of partial fraction terms and count unknowns.
-    // Each term is: coefficient(s) / factor^power
-    // For linear: 1 unknown per power level
-    // For quadratic: 2 unknowns per power level (Bx + C)
+    // A factor of degree d contributes d numerator coefficients at each power level.
     const terms = [];
     let totalUnknowns = 0;
-    let supported = true;
     for (const f of factors) {
         for (let k = 1; k <= f.power; k++) {
-            if (f.degree === 1) {
-                terms.push({
-                    factor: f.expr,
-                    power: k,
-                    degree: f.degree,
-                    unknownIndex: totalUnknowns,
-                    numUnknowns: 1,
-                });
-                totalUnknowns += 1;
-            }
-            else if (f.degree === 2) {
-                terms.push({
-                    factor: f.expr,
-                    power: k,
-                    degree: f.degree,
-                    unknownIndex: totalUnknowns,
-                    numUnknowns: 2,
-                });
-                totalUnknowns += 2;
-            }
-            else {
-                // Higher-degree irreducible factors — not supported yet
-                supported = false;
-            }
+            terms.push({
+                factor: f.expr,
+                power: k,
+                unknownIndex: totalUnknowns,
+                numUnknowns: f.degree,
+            });
+            totalUnknowns += f.degree;
         }
     }
-    if (!supported) {
-        return undefined;
-    }
     // We need to solve: P(x)/Q(x) = Σ terms
     // Multiply both sides by Q(x):
     // P(x) = Σ (coefficients_i × Q(x) / factor_i^power_i)
@@ -254,15 +229,11 @@ function decompose(numerator, denominator, factors, v) {
         const row = [];
         for (let j = 0; j < terms.length; j++) {
             const term = terms[j];
-            // The basis for this term: Q(x) / factor^power, evaluated at x
+            // The basis for this term: Q(x) / factor^power, evaluated at x.
             const cofactor = evaluateAt(cofactors[j], v, x);
-            if (term.numUnknowns === 1) {
-                row.push(cofactor);
-            }
-            else {
-                // Quadratic: (Bx + C) contributes B*x*cofactor + C*cofactor
-                row.push(x.times(cofactor)); // coefficient of B
-                row.push(cofactor); // coefficient of C
+            for (let degree = term.numUnknowns - 1; degree >= 0; degree--) {
+                const monomial = degree === 0 ? (0, shortcuts_1.one)() : x.pow(Expression_1.Expression.Number(degree));
+                row.push(monomial.times(cofactor));
             }
         }
         rows.push(row);
@@ -274,22 +245,18 @@ function decompose(numerator, denominator, factors, v) {
     }
     // Build the result expression from the solved coefficients
     let result = (0, shortcuts_1.zero)();
+    const variable = Expression_1.Expression.create(v);
     for (const term of terms) {
         const denomPart = term.power === 1 ? term.factor : term.factor.pow(Expression_1.Expression.Number(term.power));
-        if (term.numUnknowns === 1) {
-            const A = solution[term.unknownIndex];
-            if (!A.isZero()) {
-                result = result.plus(A.div(denomPart));
-            }
+        let numPart = (0, shortcuts_1.zero)();
+        for (let i = 0; i < term.numUnknowns; i++) {
+            const coefficient = solution[term.unknownIndex + i];
+            const degree = term.numUnknowns - 1 - i;
+            const monomial = degree === 0 ? (0, shortcuts_1.one)() : variable.pow(Expression_1.Expression.Number(degree));
+            numPart = numPart.plus(coefficient.times(monomial));
         }
-        else {
-            const B = solution[term.unknownIndex];
-            const C = solution[term.unknownIndex + 1];
-            // (Bx + C) / factor^power
-            const numPart = B.times(Expression_1.Expression.create(v)).plus(C);
-            if (!numPart.isZero()) {
-                result = result.plus(numPart.div(denomPart));
-            }
+        if (!numPart.isZero()) {
+            result = result.plus(numPart.div(denomPart));
         }
     }
     return result;
@@ -377,7 +344,7 @@ function solveLinearSystem(A, b) {
         if (pivot === -1) {
             continue;
         }
-        if (!aug.elements[i][pivot].eq('1')) {
+        if (!aug.elements[i][pivot].eq((0, shortcuts_1.one)())) {
             return undefined;
         }
         if (pivotCols.has(pivot)) {