nerdamer 1.1.13 → 2.0.0-rc.1

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;
+}

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

@@ -0,0 +1,135 @@
+import { Expression } from '../../core/classes/expression/Expression';
+/**
+ * Attempts to detect an f(x)·f'(x) substitution structure from a list of
+ * multiplicative factors.
+ *
+ * The algorithm performs a contiguous range search over the factors.
+ * For each contiguous block it builds a candidate f(x) and compares it
+ * against the remaining factors.
+ *
+ * Example structure detected:
+ *
+ *      (a^x*log(a)*cos(x) - a^x*sin(x)) * a^x*cos(x)
+ *
+ * which matches
+ *
+ *      f(x) = a^x*cos(x)
+ *      f'(x) = a^x*log(a)*cos(x) - a^x*sin(x)
+ *
+ * yielding
+ *
+ *      ∫ f f' dx = f² / 2
+ *
+ * To reduce symbolic overhead:
+ *
+ * - The total product is computed once.
+ * - The left candidate product grows incrementally.
+ * - The complementary product is obtained via division.
+ *
+ * @param factors multiplicative factors of the integrand
+ * @param x integration variable
+ * @returns substitution match or undefined if none found
+ */
+export declare function bySubstitution(factors: Expression[], x: string): {
+    fx: Expression;
+    constant: Expression;
+    power: Expression;
+} | undefined;
+/**
+ * Attempts to integrate an expression using product-style substitution.
+ *
+ * This function prepares the expression for substitution detection
+ * by extracting multiplicative factors and then delegating to
+ * {@link bySubstitution}.
+ *
+ * The method specifically searches for integrands of the form
+ *
+ *      c * f(x) * f'(x)
+ *
+ * which integrate to
+ *
+ *      c * f(x)² / 2
+ *
+ * Factorization is only performed when necessary to avoid the
+ * significant cost of factoring expressions unnecessarily.
+ *
+ * @param fx expression to integrate
+ * @param x integration variable
+ * @returns substitution match information or undefined
+ */
+export declare function tryIntegrateBySubstitution(fx: Expression, x: string): {
+    fx: Expression;
+    constant: Expression;
+    power: Expression;
+} | undefined;
+/**
+ * Attempts substitution when one factor wraps an inner expression and the
+ * remaining factors are proportional to its derivative.
+ *
+ * @param fx - Complete product integrand, used to select a fresh variable.
+ * @param factors - Multiplicative factors to test.
+ * @param x - Integration variable.
+ * @returns The back-substituted antiderivative, or `undefined` when the outer
+ * factor is not covered by the integration table.
+ */
+export declare function tryIntegrateByWrappedFactorSubstitution(fx: Expression, factors: Expression[], x: string): Expression | undefined;
+/**
+ * Attempts to detect a logarithmic substitution structure of the form
+ *
+ *      c * f'(x) / f(x)
+ *
+ * by extracting the numerator and denominator of the expression and
+ * testing whether the numerator is proportional to the derivative of
+ * the denominator.
+ *
+ * This is much cheaper than the contiguous-factor search used for
+ * product-style substitution because the denominator already provides
+ * the natural candidate for f(x).
+ *
+ * Examples:
+ *
+ *      (2*x)/(1+x^2)      -> f(x) = 1+x^2, constant = 1
+ *      cos(x)/sin(x)      -> f(x) = sin(x), constant = 1
+ *      3*cos(x)/sin(x)    -> f(x) = sin(x), constant = 3
+ *
+ * Non-example:
+ *
+ *      f(x)/f'(x)
+ *
+ * That is not the logarithmic rule and should not be handled here.
+ *
+ * @param fx expression to analyze
+ * @param x integration variable
+ * @returns logarithmic substitution match information or undefined
+ */
+export declare function tryIntegrateByLogSubstitution(fx: Expression, x: string): {
+    fx: Expression;
+    constant: Expression;
+} | undefined;
+/**
+ * Attempts to detect a generalized power-quotient substitution structure:
+ *
+ *      integrand = c * f'(x) / f(x)^n
+ *
+ * which integrates to
+ *
+ *      c * f(x)^(1-n) / (1-n)     for n ≠ 1
+ *
+ * The n=1 case is the logarithmic substitution handled by
+ * tryIntegrateByLogSubstitution. This function handles n ≠ 1,
+ * including fractional powers like n=1/2 (square root denominators).
+ *
+ * This catches integrands like:
+ *
+ *      x / sqrt(1-x²)  →  f = 1-x², f' = -2x, n = 1/2
+ *      x / (1+x²)²     →  f = 1+x², f' = 2x, n = 2
+ *
+ * @param fx expression to analyze
+ * @param x integration variable
+ * @returns match with fx (the inner function), constant, and power (the denominator exponent n)
+ */
+export declare function tryIntegrateByPowerSubstitution(fx: Expression, x: string): {
+    fx: Expression;
+    constant: Expression;
+    power: Expression;
+} | undefined;