nerdamer 1.1.13 → 2.0.0-rc.2

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 dispatch_1 = require("../core/dispatch");
+const constants_1 = require("../core/classes/parser/constants");
+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

@@ -0,0 +1,77 @@
+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';
+/**
+ * Factors polynomial-like numerator and denominator components of an expression.
+ *
+ * @remarks
+ * The implementation converts polynomial structure to the exact integer-coefficient
+ * factorization layer. Irrational constants and function-valued components may be
+ * temporarily represented by substitution variables. If the input cannot be handled
+ * by that finite polynomial path, the function returns an unevaluated symbolic
+ * `factor(input)` expression rather than exposing the internal failure.
+ *
+ * @param x - Expression-compatible value to factor.
+ * @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.
+ *
+ * @param x - Input whose numerator should be factored.
+ * @returns New factor expressions; unsupported input is returned as a one-element array.
+ */
+export declare function polyFactorExpressions(x: ExpressionInput): Expression[];
+/**
+ * Wraps the polynomial factor expressions in an ordered {@link Vector}.
+ *
+ * @param x - Polynomial-like input.
+ * @returns A new Vector containing the factor expressions.
+ */
+export declare function polyFactors(x: ExpressionInput): Vector;
+/**
+ * Factors the polynomialized numerator and denominator separately.
+ *
+ * @param x - Rational expression to polynomialize and factor.
+ * @returns New numerator and denominator factor arrays after reversing temporary substitutions.
+ */
+export declare function factorExpressionParts(x: ExpressionInput): {
+    numerator: Expression[];
+    denominator: Expression[];
+};
+/**
+ * Factors the numerator and denominator separately and returns each factor list as a Vector.
+ *
+ * @param x - Expression-compatible value to factor.
+ * @returns New Vectors for the numerator and denominator factors.
+ */
+export declare function factors(x: ExpressionInput): {
+    numerator: Vector;
+    denominator: Vector;
+};
+/**
+ * Returns prime-power factors for the numeric parts of a numerator and denominator.
+ *
+ * @param x - Numeric or expression-compatible value.
+ * @returns Numerator and denominator Vectors. Non-numeric components are kept as single
+ * factors instead of being recursively factored.
+ */
+export declare function numberFactors(x: ExpressionInput): {
+    numerator: Vector;
+    denominator: Vector;
+};

package/output/algebra/factor/factor.js

@@ -0,0 +1,245 @@
+"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 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 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.
+ *
+ * @remarks
+ * The implementation converts polynomial structure to the exact integer-coefficient
+ * factorization layer. Irrational constants and function-valued components may be
+ * temporarily represented by substitution variables. If the input cannot be handled
+ * by that finite polynomial path, the function returns an unevaluated symbolic
+ * `factor(input)` expression rather than exposing the internal failure.
+ *
+ * @param x - Expression-compatible value to factor.
+ * @returns A factored expression or an unevaluated symbolic `factor` call.
+ */
+function factor(x) {
+    let retval;
+    try {
+        x = Expression_1.Expression.create(x);
+        if (x.isZero()) {
+            retval = x;
+        }
+        else if (x.isNUM() && x.isInteger()) {
+            let factoredInteger;
+            const factorCounts = (0, primeFactor_1.primeFactorCounts)(x.getMultiplier().numerator);
+            for (const prime in factorCounts) {
+                const primePower = Expression_1.Expression.toEXP(prime, factorCounts[prime]);
+                factoredInteger = factoredInteger
+                    ? (0, multiply_1.merge)(factoredInteger, primePower)
+                    : primePower;
+            }
+            retval = factoredInteger ?? Expression_1.Expression.Number('1');
+            if (x.sign() === -1) {
+                retval = retval.neg();
+            }
+        }
+        // A variable is already fully factored.
+        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());
+        }
+    }
+    catch {
+        retval = Expression_1.Expression.toFunction(constants_1.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.
+ *
+ * @param x - Input whose numerator should be factored.
+ * @returns New factor expressions; unsupported input is returned as a one-element array.
+ */
+function polyFactorExpressions(x) {
+    let retval;
+    try {
+        const expr = (0, analysis_1.normalizeMultiplierDenominators)(Expression_1.Expression.create(x));
+        const num = expr.getNumerator();
+        const den = expr.getDenominator();
+        // Irrational coefficients must first be promoted to variables.
+        const [subbed, map] = (0, subst_1.uSubConstants)(num);
+        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)];
+    }
+    return retval;
+}
+/**
+ * Wraps the polynomial factor expressions in an ordered {@link Vector}.
+ *
+ * @param x - Polynomial-like input.
+ * @returns A new Vector containing the factor expressions.
+ */
+function polyFactors(x) {
+    const retval = new Vector_1.Vector(polyFactorExpressions(x));
+    return retval;
+}
+/**
+ * Factors the polynomialized numerator and denominator separately.
+ *
+ * @param x - Rational expression to polynomialize and factor.
+ * @returns New numerator and denominator factor arrays after reversing temporary substitutions.
+ */
+function factorExpressionParts(x) {
+    const { numerator, denominator, map } = (0, polynomialize_1.polynomialize)(Expression_1.Expression.create(x));
+    return {
+        numerator: polyFactorExpressions(numerator).map(f => (0, subst_1.uUnSub)(f, map)),
+        denominator: polyFactorExpressions(denominator).map(f => (0, subst_1.uUnSub)(f, map)),
+    };
+}
+/**
+ * Factors the numerator and denominator separately and returns each factor list as a Vector.
+ *
+ * @param x - Expression-compatible value to factor.
+ * @returns New Vectors for the numerator and denominator factors.
+ */
+function factors(x) {
+    const { numerator, denominator } = factorExpressionParts(x);
+    return {
+        numerator: new Vector_1.Vector(numerator),
+        denominator: new Vector_1.Vector(denominator),
+    };
+}
+/**
+ * Returns prime-power factors for the numeric parts of a numerator and denominator.
+ *
+ * @param x - Numeric or expression-compatible value.
+ * @returns Numerator and denominator Vectors. Non-numeric components are kept as single
+ * factors instead of being recursively factored.
+ */
+function numberFactors(x) {
+    x = Expression_1.Expression.create(x);
+    const numerator = x.getNumerator();
+    const denominator = x.getDenominator();
+    function factorNumber(num) {
+        if (!num.isNUM()) {
+            return new Vector_1.Vector([num]);
+        }
+        const factors = new Vector_1.Vector();
+        const factorCounts = (0, primeFactor_1.primeFactorCounts)(num.getMultiplier().numerator);
+        for (const prime in factorCounts) {
+            factors.append(Expression_1.Expression.toEXP(prime, factorCounts[prime]));
+        }
+        return factors;
+    }
+    return {
+        numerator: factorNumber(numerator),
+        denominator: factorNumber(denominator),
+    };
+}

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

@@ -0,0 +1,30 @@
+import { Expression } from '../../core/classes/expression/Expression';
+import type { ExpressionInput } from '../../core/types';
+/**
+ * Computes a symbolic greatest common divisor over rational polynomial structure.
+ *
+ * @remarks
+ * 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.
+ * @returns The exact symbolic GCD or an unevaluated `gcd` expression.
+ */
+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 polynomial GCD so shared symbolic factors are retained.
+ *
+ * @param x - First expression-compatible operand.
+ * @param y - Second expression-compatible operand.
+ * @returns Zero when either operand is zero; otherwise a non-negative numeric LCM or
+ * the symbolic product divided by {@link gcd}.
+ */
+export declare function lcm(x: ExpressionInput, y: ExpressionInput): Expression;

package/output/algebra/gcd/gcd.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.gcd = gcd;
+exports.lcm = lcm;
+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 SparsePolynomialAdapter_1 = require("../../core/classes/polynomial/SparsePolynomialAdapter");
+const bigint_1 = require("../../core/functions/bigint/bigint");
+const subst_1 = require("../../core/functions/subst");
+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 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.
+ * @returns The exact symbolic GCD or an unevaluated `gcd` expression.
+ */
+function gcd(x, y) {
+    try {
+        x = Expression_1.Expression.create(x);
+        y = Expression_1.Expression.create(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 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;
+    }
+    catch { }
+    return Expression_1.Expression.toFunction(constants_1.GCD, [x, y]);
+}
+/**
+ * Returns the least common multiple of two expressions.
+ *
+ * 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.
+ * @returns Zero when either operand is zero; otherwise a non-negative numeric LCM or
+ * the symbolic product divided by {@link gcd}.
+ */
+function lcm(x, y) {
+    const a = Expression_1.Expression.create(x);
+    const b = Expression_1.Expression.create(y);
+    let retval;
+    if (a.isZero() || b.isZero()) {
+        retval = (0, shortcuts_1.zero)();
+    }
+    else if (a.isNUM() && b.isNUM()) {
+        retval = Expression_1.Expression.fromRational(a.getMultiplier().LCM(b.getMultiplier()).abs());
+    }
+    else {
+        retval = a.times(b).div(gcd(a, b));
+    }
+    return retval;
+}
+function expressionGCD(x, y, variables) {
+    if (x.isNUM() && y.isNUM()) {
+        return Expression_1.Expression.create(x.getMultiplier().GCD(y.getMultiplier()));
+    }
+    if (x.isZero() && y.isZero()) {
+        return (0, shortcuts_1.zero)();
+    }
+    if (x.isZero()) {
+        return Expression_1.Expression.create(y);
+    }
+    if (y.isZero()) {
+        return Expression_1.Expression.create(x);
+    }
+    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

@@ -0,0 +1,21 @@
+import { Vector } from '../core/classes/vector/Vector';
+import type { ExpressionInput } from '../core/types';
+/**
+ * Computes an expression-facing Groebner basis for polynomial generators.
+ *
+ * @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 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
+ * sorted basis. Use the advanced Groebner APIs for another monomial order, resource
+ * budgets, elimination, or ideal membership.
+ *
+ * @param expressionArray - Polynomial-like generators of the ideal.
+ * @param vars - Variable order, from highest to lowest lexicographic priority.
+ * @returns A new vector containing expression representations of the basis.
+ */
+export declare function groebner(expressionArray: ExpressionInput[] | Vector, vars?: string[]): Vector;

package/output/algebra/groebner.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.groebner = groebner;
+const collect_1 = require("../core/classes/expression/collect");
+const Expression_1 = require("../core/classes/expression/Expression");
+const SparsePolynomialAdapter_1 = require("../core/classes/polynomial/SparsePolynomialAdapter");
+const Vector_1 = require("../core/classes/vector/Vector");
+const groebnerBase_1 = require("./algorithms/groebnerBase");
+/**
+ * Computes an expression-facing Groebner basis for polynomial generators.
+ *
+ * @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 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
+ * sorted basis. Use the advanced Groebner APIs for another monomial order, resource
+ * budgets, elimination, or ideal membership.
+ *
+ * @param expressionArray - Polynomial-like generators of the ideal.
+ * @param vars - Variable order, from highest to lowest lexicographic priority.
+ * @returns A new vector containing expression representations of the basis.
+ */
+function groebner(expressionArray, vars) {
+    const inputs = Vector_1.Vector.isVector(expressionArray) ? expressionArray.elements : expressionArray;
+    const expressions = inputs.map(e => Expression_1.Expression.create(e));
+    // 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.
+    // 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

@@ -0,0 +1,19 @@
+import { Expression } from '../core/classes/expression/Expression';
+import type { ExpressionInput } from '../core/types';
+/**
+ * Decomposes a rational expression P(x)/Q(x) into partial fractions.
+ *
+ * @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. 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.
+ *
+ * @param x - Rational expression to decompose.
+ * @param variable - Main variable; defaults to the first variable reported by the expression.
+ * @returns A new decomposition when one is found, otherwise the original parsed expression.
+ */
+export declare function partfrac(x: ExpressionInput, variable?: ExpressionInput): Expression;