nerdamer 1.1.13 → 2.0.0-rc.1

package/output/algebra/algorithms/rational.d.ts

@@ -0,0 +1,17 @@
+export type Rat = {
+    n: bigint;
+    d: bigint;
+};
+export declare function ratNorm(r: Rat): Rat;
+export declare function rat(n: bigint, d?: bigint): Rat;
+export declare function ratAdd(a: Rat, b: Rat): Rat;
+export declare function ratSub(a: Rat, b: Rat): Rat;
+export declare function ratMul(a: Rat, b: Rat): Rat;
+export declare function ratDiv(a: Rat, b: Rat): Rat;
+export declare function ratToInt(r: Rat): bigint | null;
+export declare function uniAddRat(a: Rat[], b: Rat[]): Rat[];
+export declare function uniMulRat(a: Rat[], b: Rat[]): Rat[];
+export declare function interpolateUnivariateRat(points: Array<{
+    x: bigint;
+    y: Rat;
+}>): Rat[];

package/output/algebra/algorithms/rational.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ratNorm = ratNorm;
+exports.rat = rat;
+exports.ratAdd = ratAdd;
+exports.ratSub = ratSub;
+exports.ratMul = ratMul;
+exports.ratDiv = ratDiv;
+exports.ratToInt = ratToInt;
+exports.uniAddRat = uniAddRat;
+exports.uniMulRat = uniMulRat;
+exports.interpolateUnivariateRat = interpolateUnivariateRat;
+const arith_1 = require("./arith");
+function ratNorm(r) {
+    if (r.d === 0n) {
+        throw new Error('Rat: division by zero');
+    }
+    if (r.n === 0n) {
+        return { n: 0n, d: 1n };
+    }
+    let n = r.n;
+    let d = r.d;
+    if (d < 0n) {
+        n = -n;
+        d = -d;
+    }
+    const g0 = (0, arith_1.gcd)(n, d);
+    return { n: n / g0, d: d / g0 };
+}
+function rat(n, d = 1n) {
+    return ratNorm({ n, d });
+}
+function ratAdd(a, b) {
+    return ratNorm({ n: a.n * b.d + b.n * a.d, d: a.d * b.d });
+}
+function ratSub(a, b) {
+    return ratNorm({ n: a.n * b.d - b.n * a.d, d: a.d * b.d });
+}
+function ratMul(a, b) {
+    return ratNorm({ n: a.n * b.n, d: a.d * b.d });
+}
+function ratDiv(a, b) {
+    if (b.n === 0n) {
+        throw new Error('Rat: divide by zero');
+    }
+    return ratNorm({ n: a.n * b.d, d: a.d * b.n });
+}
+function ratToInt(r) {
+    return r.d === 1n ? r.n : null;
+}
+function uniAddRat(a, b) {
+    const len = Math.max(a.length, b.length);
+    const out = new Array(len).fill(0).map(() => rat(0n));
+    for (let i = 0; i < len; i++) {
+        out[i] = ratAdd(a[i] ?? rat(0n), b[i] ?? rat(0n));
+    }
+    while (out.length > 1 && out[out.length - 1].n === 0n) {
+        out.pop();
+    }
+    return out;
+}
+function uniMulRat(a, b) {
+    const out = new Array(a.length + b.length - 1).fill(0).map(() => rat(0n));
+    for (let i = 0; i < a.length; i++) {
+        for (let j = 0; j < b.length; j++) {
+            out[i + j] = ratAdd(out[i + j], ratMul(a[i], b[j]));
+        }
+    }
+    while (out.length > 1 && out[out.length - 1].n === 0n) {
+        out.pop();
+    }
+    return out;
+}
+function interpolateUnivariateRat(points) {
+    if (points.length === 0) {
+        return [rat(0n)];
+    }
+    const byX = new Map();
+    for (const p of points) {
+        const prev = byX.get(p.x);
+        if (!prev) {
+            byX.set(p.x, p.y);
+            continue;
+        }
+        if (ratSub(prev, p.y).n !== 0n) {
+            throw new Error('interpolateUnivariateRat: duplicate x with conflicting y');
+        }
+    }
+    const uniq = [...byX.entries()]
+        .map(([x, y]) => ({ x, y }))
+        .sort((a, b) => (a.x < b.x ? -1 : a.x > b.x ? 1 : 0));
+    const n = uniq.length;
+    if (n === 1) {
+        return [uniq[0].y];
+    }
+    let poly = [rat(0n)];
+    for (let i = 0; i < n; i++) {
+        let basis = [rat(1n)];
+        let denom = rat(1n);
+        for (let j = 0; j < n; j++) {
+            if (j === i) {
+                continue;
+            }
+            basis = uniMulRat(basis, [rat(-uniq[j].x), rat(1n)]);
+            denom = ratMul(denom, rat(uniq[i].x - uniq[j].x));
+        }
+        const scale = ratDiv(uniq[i].y, denom);
+        const scaled = basis.map(c => ratMul(c, scale));
+        poly = uniAddRat(poly, scaled);
+    }
+    while (poly.length > 1 && poly[poly.length - 1].n === 0n) {
+        poly.pop();
+    }
+    return poly;
+}

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

@@ -0,0 +1,62 @@
+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;
+/**
+ * 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,158 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.factor = factor;
+exports.polyFactorExpressions = polyFactorExpressions;
+exports.polyFactors = polyFactors;
+exports.factorExpressionParts = factorExpressionParts;
+exports.factors = factors;
+exports.numberFactors = numberFactors;
+const analysis_1 = require("../../core/classes/expression/analysis");
+const Expression_1 = require("../../core/classes/expression/Expression");
+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 Vector_1 = require("../../core/classes/vector/Vector");
+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 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 {
+            const factored = factors(x);
+            retval = factored.numerator.prod().div(factored.denominator.prod());
+        }
+    }
+    catch {
+        retval = Expression_1.Expression.toFunction(constants_1.FACTOR, [x]);
+    }
+    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();
+        // MultiPoly strictly works in Z. 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));
+    }
+    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,29 @@
+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, 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)`.
+ *
+ * @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 existing GCD normalization 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,141 @@
+"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 Polynomial_1 = require("../../core/classes/polynomial/Polynomial");
+const utils_1 = require("../../core/classes/polynomial/utils");
+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 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)`.
+ *
+ * @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 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);
+        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 existing GCD normalization 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) {
+    let retval;
+    if (x.isNUM() && y.isNUM()) {
+        retval = 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());
+    }
+    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 (!g.isProduct()) {
+        g = (0, factor_1.factor)(g);
+    }
+    // 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;
+}

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 `MultiPoly` 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,42 @@
+"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 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.
+ *
+ * @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
+ * 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.
+    // 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)));
+}

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. Repeated linear
+ * factors and irreducible quadratic factors are supported. An irreducible factor of
+ * higher degree, 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;