nerdamer 1.1.13 → 2.0.0-rc.2

package/output/calculus/derivative/diff.js

@@ -0,0 +1,241 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.diff = diff;
+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 helpers_1 = require("../../core/classes/parser/helpers");
+const errors_1 = require("../../core/errors");
+const math_1 = require("../../math/math");
+/**
+ * Applies the product rule to an expression
+ *
+ * @param expression
+ * @param variable
+ * @returns
+ */
+function productRule(expression, variable) {
+    //grab all the symbols within the CB symbol
+    const elements = expression.elementsArray();
+    let result = (0, shortcuts_1.zero)();
+    //loop over all the symbols
+    for (let i = 0; i < elements.length; i++) {
+        let df = diff(elements[i], variable);
+        for (let j = 0; j < elements.length; j++) {
+            //skip the symbol of which we just pulled the derivative
+            if (i !== j) {
+                //multiply out the remaining symbols
+                df = df.times(elements[j]);
+            }
+        }
+        //add the derivative to the result
+        result = result.plus(df);
+    }
+    return result; //done
+}
+/**
+ * Differentiates an expression symbolically.
+ *
+ * The chain, product, sum, and power rules are applied recursively, together
+ * with the built-in derivative table for recognized functions. An omitted
+ * variable is inferred as the first variable in the expression. Existing
+ * Expression input is reused during normalization.
+ *
+ * @remarks
+ * `n` requests a repeated derivative. A non-integer order, a non-variable
+ * differentiation target, or an unsupported derivative is preserved as an
+ * unevaluated `diff(...)` expression. Constants and expressions independent of
+ * the selected variable differentiate to zero.
+ *
+ * @param x - Expression to differentiate.
+ * @param variable - Variable with respect to which the derivative is taken.
+ * @param n - Positive integer derivative order. Defaults to the first derivative.
+ * @returns The symbolic derivative, or an unevaluated `diff(...)` call when the
+ * requested operation cannot be resolved.
+ * @throws {@link core!UnsupportedOperationError} If `variable` is numeric.
+ *
+ * @example
+ * ```ts
+ * diff('sin(x^2)', 'x').text();
+ * diff('x^4', 'x', 2).text();
+ * ```
+ */
+function diff(x, variable, n) {
+    x = Expression_1.Expression.create(x);
+    const variables = x.variables();
+    // Set the variable if none was provided
+    variable ??= Expression_1.Expression.Variable(variables[0]);
+    variable = Expression_1.Expression.create(variable);
+    const nth = typeof n === 'number' ? Expression_1.Expression.create(n) : n;
+    // If the variable is a number then complain
+    if (variable?.isNUM()) {
+        throw new errors_1.UnsupportedOperationError((0, errors_1.message)('unsupportedOperation'));
+    }
+    let retval;
+    if (x.hasFunction(constants_1.SYMBOLIC_ACCESSOR, true)) {
+        retval = Expression_1.Expression.toFunction(constants_1.DIFF, [x, variable, nth]);
+    }
+    else if (variables.length === 0 || !x.hasVariable(variable.value) || x.isConstant()) {
+        retval = (0, shortcuts_1.zero)();
+    }
+    // If the variable is not of type VAR or nth is not an integer then return it untouched until either or both are resolved
+    else if ((variable && !variable.isVAR()) || (nth && !nth.isInteger())) {
+        retval = Expression_1.Expression.toFunction(constants_1.DIFF, [x, variable, nth]);
+    }
+    else if (x.isEXP()) {
+        // Apply rule a^x*(d/dx x*log(a))
+        const a = (0, math_1.log)(x.getBase());
+        const p = x.getPower();
+        const dx = diff(a.times(p), variable);
+        retval = x.times(dx);
+    }
+    // If the expression doesn't have a variable or if it's a constant then we're done
+    else {
+        // Reduce the nth call of the derivative
+        const n = nth ? Number(nth) - 1 : 0;
+        // Pull the derivate of the outside. At this point we've already performed all the required checks.
+        const m = x.getMultiplier().times(x.getPower());
+        const p = x.getPower().minus('1');
+        const f = Expression_1.Expression.create(x.value);
+        const fp = p.isZero() ? m : f.pow(p).times(m);
+        // Pull the derivative of the inside
+        if (f.isVAR()) {
+            retval = (0, shortcuts_1.one)();
+        }
+        else if (f.isSum()) {
+            let sum = (0, shortcuts_1.zero)();
+            f.elementsArray().forEach(e => {
+                sum = sum.plus(diff(e, variable));
+            });
+            retval = sum;
+        }
+        else if (f.isProduct()) {
+            retval = productRule(f, variable);
+        }
+        else if (f.isFunction()) {
+            const x = f.getArguments()[0];
+            const m = f.getMultiplier();
+            switch (f.name) {
+                case constants_1.LOG:
+                    retval = (0, helpers_1._)(`(${m})/(${x})`);
+                    break;
+                case constants_1.COS:
+                    retval = (0, helpers_1._)(`-sin(${x})`);
+                    break;
+                case constants_1.SIN:
+                    retval = (0, helpers_1._)(`cos(${x})`);
+                    break;
+                case constants_1.TAN:
+                    retval = (0, helpers_1._)(`sec(${x})^2`);
+                    break;
+                case constants_1.SEC:
+                    retval = (0, helpers_1._)(`tan(${x})*sec(${x})`);
+                    break;
+                case constants_1.CSC:
+                    retval = (0, helpers_1._)(`-cot(${x})*csc(${x})`);
+                    break;
+                case constants_1.COT:
+                    retval = (0, helpers_1._)(`-csc(${x})^2`);
+                    break;
+                case constants_1.ACOS:
+                    retval = (0, helpers_1._)(`-1/sqrt(1-(${x})^2)`);
+                    break;
+                case constants_1.ASIN:
+                    retval = (0, helpers_1._)(`1/sqrt(1-(${x})^2)`);
+                    break;
+                case constants_1.ATAN:
+                    retval = (0, helpers_1._)(`1/(1+(${x})^2)`);
+                    break;
+                case constants_1.ASEC:
+                    retval = (0, helpers_1._)(`1/(sqrt(1-1/(${x})^2)*(${x})^2)`);
+                    break;
+                case constants_1.ACSC:
+                    retval = (0, helpers_1._)(`-1/(sqrt(1-1/(${x})^2)*(${x})^2)`);
+                    break;
+                case constants_1.ACOT:
+                    retval = (0, helpers_1._)(`-1/(1+(${x})^2)`);
+                    break;
+                case constants_1.COSH:
+                    retval = (0, helpers_1._)(`sinh(${x})`);
+                    break;
+                case constants_1.SINH:
+                    retval = (0, helpers_1._)(`cosh(${x})`);
+                    break;
+                case constants_1.TANH:
+                    retval = (0, helpers_1._)(`sech(${x})^2`);
+                    break;
+                case constants_1.SECH:
+                    retval = (0, helpers_1._)(`-sech(${x})*tanh(${x})`);
+                    break;
+                case constants_1.CSCH:
+                    retval = (0, helpers_1._)(`-coth(${x})*csch(${x})`);
+                    break;
+                case constants_1.COTH:
+                    retval = (0, helpers_1._)(`-csch(${x})^2`);
+                    break;
+                case constants_1.ASINH:
+                    retval = (0, helpers_1._)(`1/sqrt(1+(${x})^2)`);
+                    break;
+                case constants_1.ACOSH:
+                    retval = (0, helpers_1._)(`1/(sqrt(-1+(${x}))*sqrt(1+(${x})))`);
+                    break;
+                case constants_1.ATANH:
+                    retval = (0, helpers_1._)(`1/(1-(${x})^2)`);
+                    break;
+                case constants_1.ASECH:
+                    retval = (0, helpers_1._)(`-1/(sqrt(-1+1/(${x}))*sqrt(1+1/(${x}))*(${x})^2)`);
+                    break;
+                case constants_1.ACSCH:
+                    retval = (0, helpers_1._)(`-1/(sqrt(1+1/(${x})^2)*(${x})^2)`);
+                    break;
+                case constants_1.ACOTH:
+                    retval = (0, helpers_1._)(`1/(1-(${x})^2)`);
+                    break;
+                case constants_1.ABS:
+                    // d/dx abs(u) = sign(u) * u'
+                    retval = (0, helpers_1._)(`sign(${x})`);
+                    break;
+                case constants_1.CI:
+                    retval = (0, helpers_1._)(`cos(${x})/${x}`);
+                    break;
+                case constants_1.CHI:
+                    retval = (0, helpers_1._)(`cosh(${x})/${x}`);
+                    break;
+                case constants_1.SI:
+                    retval = (0, helpers_1._)(`sin(${x})/${x}`);
+                    break;
+                case constants_1.SHI:
+                    retval = (0, helpers_1._)(`sinh(${x})/${x}`);
+                    break;
+                case constants_1.EI:
+                    retval = (0, helpers_1._)(`e^(${x})/${x}`);
+                    break;
+                case constants_1.LI:
+                    retval = (0, helpers_1._)(`1/${constants_1.LOG}(${x})`);
+                    break;
+                case constants_1.ERF:
+                    retval = (0, helpers_1._)(`(2*e^(-(${x})^2))/sqrt(pi)`);
+                    break;
+                case constants_1.SGN:
+                    retval = (0, shortcuts_1.zero)();
+                    break;
+                // Missing: S, Si, Shi, Ci, Chi, Ei, Li, erf, atan2, sinc, heaviside
+                // case '':
+                //     retval = _(``);
+                //     break;
+            }
+            // Multiply times the derivative of the inside
+            if (retval) {
+                retval = retval.times(diff(x, variable));
+            }
+        }
+        if (retval) {
+            retval = retval.times(fp);
+        }
+        // Pull the nth -1 derivative if that was requested
+        if (n > 0 && retval) {
+            retval = diff(retval, variable, Expression_1.Expression.Number(n));
+        }
+    }
+    return retval || Expression_1.Expression.toFunction(constants_1.DIFF, [x, variable, nth]);
+}

package/output/calculus/dispatch.d.ts

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

package/output/calculus/dispatch.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadCalculusFunctions = loadCalculusFunctions;
+const dispatch_1 = require("../core/dispatch");
+const math_1 = require("../math/math");
+const defint_1 = require("../math/defint/defint");
+const adapters_1 = require("./adapters");
+const fresnel_1 = require("./fresnel");
+const ilaplace_1 = require("./laplace/ilaplace");
+const laplace_1 = require("./laplace/laplace");
+const constants_1 = require("../core/classes/parser/constants");
+function loadCalculusFunctions() {
+    Object.assign(dispatch_1.mathFunctionRegistry, {
+        diff: (0, dispatch_1.systemFunction)({ fn: adapters_1.differentiate, minArgs: 1, maxArgs: 3, equationArgs: [0], distElWise: true }),
+        integrate: (0, dispatch_1.systemFunction)({ fn: adapters_1.integrateEquation, minArgs: 1, maxArgs: 2, equationArgs: [0], distElWise: true }),
+        limit: (0, dispatch_1.systemFunction)({ fn: adapters_1.directionalLimit, minArgs: 3, maxArgs: 4, distElWise: true }),
+        laplace: (0, dispatch_1.systemFunction)({ fn: laplace_1.laplace, minArgs: 3, maxArgs: 3, distElWise: true }),
+        ilaplace: (0, dispatch_1.systemFunction)({ fn: ilaplace_1.ilaplace, minArgs: 3, maxArgs: 3, distElWise: true }),
+        sum: (0, dispatch_1.systemFunction)({ fn: math_1.sum, minArgs: 4, maxArgs: 4, distElWise: true }),
+        product: (0, dispatch_1.systemFunction)({ fn: math_1.product, minArgs: 4, maxArgs: 4, distElWise: true }),
+        defint: (0, dispatch_1.systemFunction)({ fn: defint_1.defint, minArgs: 4, maxArgs: 4, distElWise: true }),
+        [constants_1.FRESNEL_S]: (0, dispatch_1.systemFunction)({ fn: fresnel_1.S, minArgs: 1, maxArgs: 1, distElWise: true }),
+        [constants_1.FRESNEL_C]: (0, dispatch_1.systemFunction)({ fn: fresnel_1.C, minArgs: 1, maxArgs: 1, distElWise: true }),
+    });
+}

package/output/calculus/fresnel.d.ts

@@ -0,0 +1,16 @@
+import { Expression } from '../core/classes/expression/Expression';
+import type { ExpressionInput } from '../core/types';
+/**
+ * Computes the normalized Fresnel sine integral
+ * `S(x) = integral(sin(pi*t^2/2), t, 0, x)`.
+ *
+ * Numeric real arguments are evaluated numerically. Symbolic arguments remain as `S(x)`.
+ */
+export declare function S(x: ExpressionInput): Expression;
+/**
+ * Computes the normalized Fresnel cosine integral
+ * `C(x) = integral(cos(pi*t^2/2), t, 0, x)`.
+ *
+ * Numeric real arguments are evaluated numerically. Symbolic arguments remain as `C(x)`.
+ */
+export declare function C(x: ExpressionInput): Expression;

package/output/calculus/fresnel.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.S = S;
+exports.C = C;
+const Expression_1 = require("../core/classes/expression/Expression");
+const constants_1 = require("../core/classes/parser/constants");
+const fresnelNumeric_1 = require("../core/functions/fresnelNumeric");
+/** Evaluates a Fresnel integral numerically when the argument can be resolved to a real number. */
+function fresnel(x, name) {
+    const argument = Expression_1.Expression.create(x);
+    const evaluated = argument.isNUM() ? argument : argument.evaluate();
+    let retval;
+    if (evaluated.isNUM()) {
+        const value = Number(evaluated.getMultiplier().toDecimal());
+        retval = Expression_1.Expression.create(name === constants_1.FRESNEL_S ? (0, fresnelNumeric_1.fresnelS)(value) : (0, fresnelNumeric_1.fresnelC)(value));
+    }
+    else {
+        retval = Expression_1.Expression.toFunction(name, [argument]);
+    }
+    return retval;
+}
+/**
+ * Computes the normalized Fresnel sine integral
+ * `S(x) = integral(sin(pi*t^2/2), t, 0, x)`.
+ *
+ * Numeric real arguments are evaluated numerically. Symbolic arguments remain as `S(x)`.
+ */
+function S(x) {
+    return fresnel(x, constants_1.FRESNEL_S);
+}
+/**
+ * Computes the normalized Fresnel cosine integral
+ * `C(x) = integral(cos(pi*t^2/2), t, 0, x)`.
+ *
+ * Numeric real arguments are evaluated numerically. Symbolic arguments remain as `C(x)`.
+ */
+function C(x) {
+    return fresnel(x, constants_1.FRESNEL_C);
+}

package/output/calculus/integrate/byParts.d.ts

@@ -0,0 +1,18 @@
+import { Expression } from '../../core/classes/expression/Expression';
+import type { ExpressionInput } from '../../core/types';
+/**
+ * Attempts integration by parts for a product with two variable-dependent factors.
+ *
+ * LIATE priority selects `u`; independent multipliers are preserved separately.
+ * Category-specific progress checks and a dedicated recursion bound reject
+ * cyclic or increasingly complex decompositions.
+ *
+ * @param x - Product integrand.
+ * @param v - Integration variable.
+ * @param integrate - Recursive integration strategy supplied by the caller.
+ * @param depth - Current outer integration depth.
+ * @param ibpDepth - Current integration-by-parts depth.
+ * @returns An antiderivative when the transformation makes progress, otherwise
+ * `undefined` so another strategy can run.
+ */
+export declare function tryIntegrationByParts(x: Expression, v: string, integrate: (f: ExpressionInput, dx: ExpressionInput, depth: number) => Expression, depth?: number, ibpDepth?: number): Expression | undefined;

package/output/calculus/integrate/byParts.js

@@ -0,0 +1,339 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tryIntegrationByParts = tryIntegrationByParts;
+const Expression_1 = require("../../core/classes/expression/Expression");
+const shortcuts_1 = require("../../core/classes/expression/shortcuts");
+const trig_1 = require("../../core/classes/expression/trig");
+const constants_1 = require("../../core/classes/parser/constants");
+const math_1 = require("../../math/math");
+const diff_1 = require("../derivative/diff");
+/**
+ * LIATE priority constants.
+ * Higher number = should be chosen as u.
+ */
+const LIATE = {
+    EXP: 0,
+    TRIG: 1,
+    ALGEBRAIC: 2,
+    INVERSE_TRIG: 3,
+    LOG: 4,
+};
+/**
+ * Maximum number of recursive IBP applications within a single
+ * integration attempt. This is independent of integrate's own
+ * MAX_DEPTH and exists to prevent runaway recursion from
+ * pathological integrands like e^x·tan(x).
+ */
+const MAX_IBP_DEPTH = 4;
+/**
+ * Extracts the maximum power of the integration variable in an expression.
+ * For a product like x^3·sin(x), returns 3. For a sum produced by
+ * linearity (e.g. 2·x·sin(x) + ...), returns the maximum across terms.
+ * Returns 0 if the variable does not appear algebraically (e.g. pure sin(x)).
+ */
+function maxAlgebraicDegree(expr, v) {
+    let retval = undefined;
+    if (expr.isVAR() && expr.hasVariable(v)) {
+        // x^n — getPower() returns the exponent
+        retval = expr.getPower();
+    }
+    else if (expr.isProduct()) {
+        let maxDeg = (0, shortcuts_1.zero)();
+        for (const factor of expr.elementsArray()) {
+            if (factor.isVAR() && factor.hasVariable(v)) {
+                const p = factor.getPower();
+                maxDeg = (0, math_1.max)(maxDeg, p);
+            }
+        }
+        retval = maxDeg;
+    }
+    else if (expr.isSum()) {
+        let maxDeg = (0, shortcuts_1.zero)();
+        expr.each((term) => {
+            maxDeg = (0, math_1.max)(maxDeg, maxAlgebraicDegree(term, v));
+        });
+        retval = maxDeg;
+    }
+    return retval ?? (0, shortcuts_1.zero)();
+}
+/**
+ * Counts the number of function applications (sin, cos, log, etc.)
+ * in an expression. Used as a structural complexity measure for
+ * non-algebraic IBP progress checking.
+ */
+function functionCount(expr) {
+    let count = 0;
+    if (expr.isFunction()) {
+        count = 1;
+    }
+    if (expr.isProduct() || expr.isSum()) {
+        expr.each((child) => {
+            count += functionCount(child);
+        });
+    }
+    return count;
+}
+/**
+ * Determines whether IBP has made progress by producing a simpler
+ * remainder integrand. The definition of "progress" depends on the
+ * LIATE category of u:
+ *
+ * - ALGEBRAIC u (polynomial × trig/exp): progress means the polynomial
+ *   degree in the integration variable strictly decreased. This is the
+ *   fundamental guarantee of IBP for x^n·f(x) — each round reduces
+ *   the degree by 1, terminating after n rounds.
+ *
+ * - LOG or INVERSE_TRIG u: one round of IBP eliminates the
+ *   transcendental factor, replacing it with an algebraic derivative.
+ *   Progress means the new integrand has fewer function nodes than
+ *   the original.
+ *
+ * - Anything else: fallback to a structural comparison — the new
+ *   integrand must have strictly fewer function nodes.
+ *
+ * Returns true if the new integrand represents progress.
+ */
+function isProgress(original, newIntegrand, uCategory, v) {
+    if (uCategory === LIATE.ALGEBRAIC) {
+        // Polynomial degree must strictly decrease
+        const oldDeg = maxAlgebraicDegree(original, v);
+        const newDeg = maxAlgebraicDegree(newIntegrand, v);
+        return newDeg < oldDeg;
+    }
+    if (uCategory === LIATE.LOG || uCategory === LIATE.INVERSE_TRIG) {
+        // Function count must decrease (log/invtrig disappears after differentiation)
+        return functionCount(newIntegrand) < functionCount(original);
+    }
+    // Fallback: structural complexity must decrease
+    return functionCount(newIntegrand) < functionCount(original);
+}
+/**
+ * Classifies an expression by LIATE category.
+ * Returns -1 if unclassifiable.
+ */
+function liatePriority(expr) {
+    // Algebraic: x^n (variable with a power)
+    if (expr.isVAR()) {
+        return LIATE.ALGEBRAIC;
+    }
+    // Exponential: e^(ax) or a^(bx)
+    if (expr.isEXP()) {
+        return LIATE.EXP;
+    }
+    if (expr.isFunction()) {
+        const name = expr.name;
+        // Logarithmic
+        if (name === constants_1.LOG || name === constants_1.LN) {
+            return LIATE.LOG;
+        }
+        // Inverse trig
+        if ((0, trig_1.isInverseTrig)(expr)) {
+            return LIATE.INVERSE_TRIG;
+        }
+        // Trigonometric
+        if ((0, trig_1.isTrig)(expr)) {
+            return LIATE.TRIG;
+        }
+        // Hyperbolic (treat like trig for LIATE purposes)
+        if ((0, trig_1.isHyperbolicTrig)(expr)) {
+            return LIATE.TRIG;
+        }
+    }
+    return -1;
+}
+/**
+ * Detects whether a pair of LIATE categories is known to produce
+ * non-terminating IBP recursion. This goes beyond the simple
+ * same-category check to catch cross-category pathological pairs.
+ *
+ * Known problematic pairs:
+ * - TRIG + TRIG: e.g. sin(x)·cos(x) — cyclic
+ * - EXP + EXP: e.g. e^x·2^x — cyclic
+ * - EXP + TRIG with non-integrable trig: e.g. e^x·tan(x) —
+ *   produces increasingly complex trig powers
+ *
+ * LOG + EXP (e.g. e^x·log(x)) and LOG + TRIG (e.g. sin(x)·log(x))
+ * are NOT blocked here. After one IBP round, the remainder is of the
+ * form f(x)/x which maps to special functions (Ei, Si, Ci) via the
+ * integration table. The isProgress guard prevents spiraling if the
+ * table entry is missing.
+ *
+ * The EXP+TRIG pair is only problematic when the trig function
+ * is not one whose integral stays in the same family (sin/cos).
+ * e^x·sin(x) and e^x·cos(x) are handled by the table, so they
+ * never reach IBP. But e^x·tan(x), e^x·sec(x), etc. spiral.
+ */
+function isCyclicPair(p0, p1, u, dv) {
+    // Same category: trig+trig or exp+exp
+    if (p0 === p1 && (p0 === LIATE.TRIG || p0 === LIATE.EXP)) {
+        return true;
+    }
+    // EXP + TRIG where the trig function is not sin/cos
+    // (sin/cos pairs are handled by the integration table and never reach here,
+    // but tan, sec, csc, cot produce ever-growing powers under IBP)
+    if ((p0 === LIATE.EXP && p1 === LIATE.TRIG) || (p0 === LIATE.TRIG && p1 === LIATE.EXP)) {
+        const trigFactor = p0 === LIATE.TRIG ? u : dv;
+        if (trigFactor.isFunction()) {
+            const name = trigFactor.name;
+            // sin and cos are safe (table handles e^x·sin/cos directly)
+            // Everything else spirals
+            if (name !== constants_1.SIN && name !== constants_1.COS) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+function tryMergeDerivativePair(varFactors, v) {
+    if (varFactors.length < 3) {
+        return undefined;
+    }
+    const dx = Expression_1.Expression.create(v);
+    for (let i = 0; i < varFactors.length; i++) {
+        const candidate = varFactors[i];
+        const dCandidate = (0, diff_1.diff)(candidate, dx);
+        if (dCandidate.isFunction(constants_1.DIFF)) {
+            continue;
+        }
+        for (let j = 0; j < varFactors.length; j++) {
+            if (j === i) {
+                continue;
+            }
+            let rest;
+            for (let k = 0; k < varFactors.length; k++) {
+                if (k === i || k === j) {
+                    continue;
+                }
+                rest = rest ? rest.times(varFactors[k]) : varFactors[k];
+            }
+            if (!rest) {
+                continue;
+            }
+            // Check whether dCandidate is proportional to rest
+            const q = dCandidate.div(rest);
+            if (!q.hasVariable(v)) {
+                return [candidate, varFactors[j]];
+            }
+        }
+    }
+    return undefined;
+}
+/**
+ * Attempts integration by parts for a product with two variable-dependent factors.
+ *
+ * LIATE priority selects `u`; independent multipliers are preserved separately.
+ * Category-specific progress checks and a dedicated recursion bound reject
+ * cyclic or increasingly complex decompositions.
+ *
+ * @param x - Product integrand.
+ * @param v - Integration variable.
+ * @param integrate - Recursive integration strategy supplied by the caller.
+ * @param depth - Current outer integration depth.
+ * @param ibpDepth - Current integration-by-parts depth.
+ * @returns An antiderivative when the transformation makes progress, otherwise
+ * `undefined` so another strategy can run.
+ */
+function tryIntegrationByParts(x, v, integrate, depth = 0, ibpDepth = 0) {
+    if (!x.isProduct()) {
+        return undefined;
+    }
+    // IBP-specific depth guard: prevent runaway recursion independent of
+    // integrate's own MAX_DEPTH. This fires much sooner and avoids the
+    // long delays caused by exhausting the global depth limit.
+    if (ibpDepth >= MAX_IBP_DEPTH) {
+        return undefined;
+    }
+    const factors = x.elementsArray();
+    // Extract the overall multiplier and variable-containing factors
+    const varFactors = [];
+    // IMPORTANT: elementsArray() does not include the product's own multiplier, so pull it from the expression.
+    let coefficient = x.getMultiplier(true);
+    for (let factor of factors) {
+        if (!factor.hasVariable(v)) {
+            // Constant factor: fold it into the coefficient
+            coefficient = coefficient.times(factor);
+        }
+        else {
+            // Variable factor: also peel off its own multiplier so it doesn't get dropped in recursive IBP.
+            // Example: 3*x^2*e^x can appear with the 3 sitting on the product multiplier OR on the factor.
+            const m = factor.getMultiplier(true);
+            if (!m.isOne()) {
+                coefficient = coefficient.times(m);
+                factor = factor.div(m);
+            }
+            varFactors.push(factor);
+        }
+    }
+    if (varFactors.length > 2) {
+        const merged = tryMergeDerivativePair(varFactors, v);
+        if (merged) {
+            varFactors.length = 0;
+            varFactors.push(...merged);
+        }
+    }
+    // IBP needs exactly 2 variable-containing factors
+    if (varFactors.length !== 2) {
+        return undefined;
+    }
+    // Classify and assign u and dv using LIATE priority
+    const p0 = liatePriority(varFactors[0]);
+    const p1 = liatePriority(varFactors[1]);
+    // If either factor is unclassified, bail
+    if (p0 < 0 || p1 < 0) {
+        return undefined;
+    }
+    // Higher priority → u (differentiates to something simpler)
+    let u, dv;
+    if (p0 >= p1) {
+        u = varFactors[0];
+        dv = varFactors[1];
+    }
+    else {
+        u = varFactors[1];
+        dv = varFactors[0];
+    }
+    // Detect cyclic or pathological LIATE pairings that will never converge
+    const uCategory = p0 >= p1 ? p0 : p1;
+    if (isCyclicPair(p0, p1, u, dv)) {
+        return undefined;
+    }
+    // Compute du = d/dx(u)
+    const du = (0, diff_1.diff)(u, Expression_1.Expression.create(v));
+    // If diff returned a symbolic diff(...) expression, it couldn't compute the derivative
+    if (du.isFunction(constants_1.DIFF)) {
+        return undefined;
+    }
+    // Compute v_result = ∫ dv dx
+    const vResult = integrate(dv, v, depth);
+    if (vResult.isFunction(constants_1.INTEGRATE)) {
+        return undefined;
+    } // dv can't be integrated
+    // ∫ u·dv = u·v - ∫ v·du
+    const uv = coefficient.times(u).times(vResult);
+    // Build the new integrand: v·du (with the original coefficient)
+    const newIntegrand = coefficient.times(vResult).times(du);
+    // Progress guard: verify IBP is actually simplifying the integrand.
+    // The definition of "progress" is LIATE-category-aware:
+    // - Algebraic u: polynomial degree must decrease
+    // - Log/InvTrig u: function count must decrease
+    // - Fallback: structural function count must decrease
+    if (!isProgress(x, newIntegrand, uCategory, v)) {
+        return undefined;
+    }
+    // Try to integrate v·du
+    const remainder = integrate(newIntegrand, v, depth);
+    // If the remainder is fully symbolic (nothing was integrated), IBP didn't help
+    // But allow partial results (some terms integrated via linearity)
+    let retval;
+    if (remainder.isFunction(constants_1.INTEGRATE)) {
+        // One more check: try IBP recursively on the remainder
+        const innerResult = tryIntegrationByParts(newIntegrand, v, integrate, depth + 1, ibpDepth + 1);
+        if (innerResult !== undefined) {
+            retval = uv.plus(innerResult.times((0, shortcuts_1.minusOne)()));
+        }
+    }
+    else {
+        retval = uv.plus(remainder.times((0, shortcuts_1.minusOne)()));
+    }
+    return retval;
+}