nerdamer 1.1.13 → 2.0.0-rc.1

package/output/calculus/integrate/bySubstitution.js

@@ -0,0 +1,411 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bySubstitution = bySubstitution;
+exports.tryIntegrateBySubstitution = tryIntegrateBySubstitution;
+exports.tryIntegrateByWrappedFactorSubstitution = tryIntegrateByWrappedFactorSubstitution;
+exports.tryIntegrateByLogSubstitution = tryIntegrateByLogSubstitution;
+exports.tryIntegrateByPowerSubstitution = tryIntegrateByPowerSubstitution;
+const factor_1 = require("../../algebra/factor/factor");
+const simplify_1 = require("../../algebra/simplify/simplify");
+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 Pattern_1 = require("../../core/converters/Pattern");
+const subst_1 = require("../../core/functions/subst");
+const diff_1 = require("../derivative/diff");
+const integrationTable_1 = require("./integrationTable");
+const utils_1 = require("./utils");
+const MAX_POWER_SUBSTITUTION_ATTEMPTS = 8;
+/**
+ * Tests whether two expressions match the generalized substitution pattern
+ *
+ *      integrand = c * f(x)^n * f'(x)
+ *
+ * where c is a constant independent of the integration variable
+ * and n is any real number (including n=1 for the basic f·f' case,
+ * n=-1 for the logarithmic case, and fractional powers).
+ *
+ * If the relationship holds, the integral becomes
+ *
+ *      ∫ c f^n f' dx = c * f^(n+1) / (n+1)    (for n ≠ -1)
+ *
+ * The n=-1 case (logarithmic) is handled separately by the log substitution
+ * detector, so this function focuses on n ≠ -1.
+ *
+ * Detection strategy:
+ * 1. Compute f'(x) for the candidate f(x)
+ * 2. Divide `other` by f'(x) to get the residual
+ * 3. If the residual is constant → n=1 (basic f·f' case)
+ * 4. Otherwise, check if the residual is a pure power of f(x):
+ *    residual = c·f(x)^m → n = m+1, constant = c
+ *
+ * @param fx candidate substitution function f(x)
+ * @param other remaining multiplicative factor
+ * @param x integration variable
+ * @returns substitution match information or undefined
+ */
+function testProductSides(fx, other, x) {
+    // Quick structural bail-out: if `other` is purely algebraic (no transcendentals)
+    // but `fx` contains transcendentals, then other cannot be proportional to f'(x)
+    // since differentiating a transcendental always produces transcendentals.
+    if (!(0, utils_1.hasTranscendental)(other, x) && (0, utils_1.hasTranscendental)(fx, x)) {
+        return undefined;
+    }
+    // Compute derivative of the candidate substitution function.
+    const df = (0, diff_1.diff)(fx, x);
+    // Do not divide by zero
+    if (df.isZero()) {
+        return;
+    }
+    // Determine whether the other factor differs from f'(x) only by a constant.
+    // If other = c*f'(x), then the integrand is c*f(x)*f'(x) → power = 1.
+    const residual = (0, simplify_1.simplify)(other.div(df));
+    // Case 1: residual is constant → basic f·f' pattern with power = 1
+    if (!residual.hasVariable(x)) {
+        return { fx, constant: residual, power: (0, shortcuts_1.one)() };
+    }
+    // Skip the expensive repeated-division loop when fx is a plain variable.
+    // If fx = x, the integrand is x·other, and the f^n·f' pattern with fx = x
+    // means other = c·x^m — a pure polynomial, already handled by the table.
+    if (fx.isVAR()) {
+        return undefined;
+    }
+    // Case 2: residual might be c·f(x)^m for some constant c and exponent m.
+    // If so, the integrand = fx · other = f(x) · c·f'(x)·f(x)^m = c·f(x)^(m+1)·f'(x).
+    // The integral is c·f(x)^(m+2)/(m+2).
+    // We return power = m+1 so the caller computes fx^(power+1)/(power+1)·constant.
+    //
+    // Detection: divide residual by fx repeatedly. After k divisions, if the
+    // result is independent of x, then m = k and residual = constant·fx^k.
+    let quotient = residual;
+    let m = 0;
+    for (let attempts = 0; attempts < MAX_POWER_SUBSTITUTION_ATTEMPTS; attempts++) {
+        const next = (0, simplify_1.simplify)(quotient.div(fx));
+        if (!next.hasVariable(x)) {
+            // residual = next·fx^(m+1), integrand = f·(next·fx^(m+1)·f') = next·fx^(m+2)·f'
+            // Return power = m+2 so caller computes fx^(m+3)/(m+3)·next
+            const power = Expression_1.Expression.Number(m + 2);
+            const plusOne = Expression_1.Expression.Number(m + 3);
+            // n+1 must not be zero (would mean n=-1, the logarithmic case)
+            if (plusOne.isZero()) {
+                return undefined;
+            }
+            return { fx, constant: next, power };
+        }
+        quotient = next;
+        m++;
+    }
+    return undefined;
+}
+/**
+ * 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
+ */
+function bySubstitution(factors, x) {
+    const n = factors.length;
+    // Compute the total product once.
+    let total = factors[0];
+    for (let i = 1; i < n; i++) {
+        total = total.times(factors[i]);
+    }
+    // Iterate over contiguous ranges of factors.
+    for (let start = 0; start < n; start++) {
+        const left = factors[start];
+        let right = undefined;
+        for (let i = 0; i < n; i++) {
+            if (i === start) {
+                continue;
+            }
+            right = right ? right.times(factors[i]) : factors[i];
+        }
+        right = right ?? (0, shortcuts_1.one)();
+        const a = testProductSides(left, right, x);
+        if (a) {
+            return a;
+        }
+        const b = testProductSides(right, left, x);
+        if (b) {
+            return b;
+        }
+        // Also try the base of powered factors as candidates.
+        // e.g. for tan(x)^2 · sec(x)^2, try tan(x) vs tan(x)·sec(x)^2
+        // so testProductSides can detect f·f^n·f' patterns.
+        const leftBase = left.getBase();
+        const leftPower = left.getPower();
+        if (!leftPower.isOne() && leftBase.hasVariable(x)) {
+            const adjustedRight = leftBase.pow(leftPower.minus((0, shortcuts_1.one)())).times(right);
+            const c = testProductSides(leftBase, adjustedRight, x);
+            if (c) {
+                return c;
+            }
+        }
+        const rightBase = right.getBase();
+        const rightPower = right.getPower();
+        if (!rightPower.isOne() && rightBase.hasVariable(x)) {
+            const adjustedLeft = rightBase.pow(rightPower.minus((0, shortcuts_1.one)())).times(left);
+            const d = testProductSides(rightBase, adjustedLeft, x);
+            if (d) {
+                return d;
+            }
+        }
+    }
+    return 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
+ */
+function tryIntegrateBySubstitution(fx, x) {
+    // If the expression is not already a product, factor it.
+    if (!fx.isProduct()) {
+        fx = (0, factor_1.factor)(fx);
+    }
+    // If it still is not a product, substitution is impossible.
+    if (!fx.isProduct()) {
+        return undefined;
+    }
+    const factors = fx.elementsArray();
+    // Substitution requires at least two multiplicative components.
+    if (factors.length < 2) {
+        return undefined;
+    }
+    const result = bySubstitution(factors, x);
+    return result;
+}
+/**
+ * Extracts candidate inner functions from a factor for wrapped-factor substitution.
+ *
+ * For function calls like cos(x^2), extracts the argument (x^2).
+ * For exponentials like e^(x^2), extracts the exponent (x^2).
+ * For non-unit powers like (3+2*x^2)^(5/2), extracts the base (3+2*x^2).
+ *
+ * @param factor a multiplicative factor of the integrand
+ * @param x integration variable
+ * @returns list of candidate inner expressions for substitution
+ */
+function getWrappedInnerCandidates(factor, x) {
+    const candidates = [];
+    if (factor.isFunction()) {
+        const args = factor.getArguments();
+        if (args.length === 1 && args[0].hasVariable(x)) {
+            candidates.push(args[0]);
+        }
+    }
+    if (factor.isEXP()) {
+        const base = factor.getBase();
+        const power = factor.getPower();
+        if (base.hasVariable(x) && !base.eq(factor)) {
+            candidates.push(base);
+        }
+        if (base.isE() && power.hasVariable(x) && !power.eq(factor)) {
+            candidates.push(power);
+        }
+    }
+    // Handle (base)^(non-unit power) — e.g. (3+2*x^2)^(5/2)
+    if (!factor.isFunction() && !factor.isEXP()) {
+        const base = factor.getBase();
+        const power = factor.getPower();
+        if (!power.isOne() && base.hasVariable(x) && !base.eq(factor)) {
+            candidates.push(base);
+        }
+    }
+    return candidates;
+}
+/**
+ * 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.
+ */
+function tryIntegrateByWrappedFactorSubstitution(fx, factors, x) {
+    let total = factors[0];
+    for (let i = 1; i < factors.length; i++) {
+        total = total.times(factors[i]);
+    }
+    for (const factor of factors) {
+        const others = (0, simplify_1.simplify)(total.div(factor));
+        for (const inner of getWrappedInnerCandidates(factor, x)) {
+            const df = (0, diff_1.diff)(inner, x);
+            if (df.isZero()) {
+                continue;
+            }
+            const constant = (0, simplify_1.simplify)(others.div(df));
+            if (constant.hasVariable(x)) {
+                continue;
+            }
+            const u = Expression_1.Expression.create((0, subst_1.getU)(fx));
+            const factorInU = (0, simplify_1.simplify)((0, subst_1.subst)(factor, inner, u));
+            if (factorInU.hasVariable(x) || !factorInU.hasVariable(u.text())) {
+                continue;
+            }
+            const outerIntegral = integrationTable_1.tableOfIntegrals.lookup(new Pattern_1.Pattern(factorInU, [u.text()]), 0);
+            if (!outerIntegral || outerIntegral.hasFunction(constants_1.INTEGRATE)) {
+                continue;
+            }
+            return (0, simplify_1.simplify)((0, subst_1.subst)(outerIntegral, u, inner).times(constant));
+        }
+    }
+    return undefined;
+}
+function testQuotientSides(numerator, denominator, x) {
+    // Treat the denominator as the candidate inner function f(x).
+    const df = (0, diff_1.diff)(denominator, x);
+    // If numerator = c*f'(x), then the integrand is c*f'(x)/f(x).
+    const constant = (0, simplify_1.simplify)(numerator.div(df));
+    // The proportionality factor must be independent of x.
+    if (!constant.hasVariable(x)) {
+        return {
+            fx: denominator,
+            constant,
+        };
+    }
+    return 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
+ */
+function tryIntegrateByLogSubstitution(fx, x) {
+    // Extract numerator and denominator directly from the expression.
+    const numerator = (0, simplify_1.simplify)(fx.getNumerator());
+    const denominator = (0, simplify_1.simplify)(fx.getDenominator());
+    // If there is no real denominator, then there is no f'(x)/f(x) structure.
+    if (denominator.isOne()) {
+        return undefined;
+    }
+    return testQuotientSides(numerator, denominator, x);
+}
+/**
+ * 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)
+ */
+function tryIntegrateByPowerSubstitution(fx, x) {
+    const numerator = (0, simplify_1.simplify)(fx.getNumerator());
+    const denominator = (0, simplify_1.simplify)(fx.getDenominator());
+    // Must have a non-trivial denominator containing the variable
+    if (denominator.isOne() || !denominator.hasVariable(x)) {
+        return undefined;
+    }
+    // The denominator may be f(x)^n. Extract the base and power.
+    // getBase() returns the base: for (1-x²)^(1/2), getBase() = 1-x²
+    // getPower() returns the exponent: for (1-x²)^(1/2), getPower() = 1/2
+    const denBase = denominator.getBase();
+    const denPower = denominator.getPower();
+    // If the base doesn't contain the variable, nothing to substitute
+    if (!denBase.hasVariable(x)) {
+        return undefined;
+    }
+    // Compute derivative of the denominator base
+    const df = (0, diff_1.diff)(denBase, x);
+    if (df.isZero()) {
+        return undefined;
+    }
+    // Check if numerator is proportional to f'(x):
+    // If numerator = c·f'(x), then integrand = c·f'(x)/f(x)^n
+    const ratio = (0, simplify_1.simplify)(numerator.div(df));
+    if (!ratio.hasVariable(x)) {
+        const oneMinusN = (0, simplify_1.simplify)((0, shortcuts_1.one)().plus(denPower.times((0, shortcuts_1.minusOne)())));
+        // n=1 is the logarithmic case — skip (handled by log substitution)
+        if (oneMinusN.isZero()) {
+            return undefined;
+        }
+        return {
+            fx: denBase,
+            constant: ratio,
+            power: denPower,
+        };
+    }
+    return undefined;
+}

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

@@ -0,0 +1,38 @@
+import { Expression } from '../../core/classes/expression/Expression';
+import type { ExpressionInput } from '../../core/types';
+/**
+ * Finds a symbolic indefinite integral with respect to a plain variable.
+ *
+ * Constants and linear sums are separated first. The remaining integrand is
+ * tried against the integral table and bounded strategies for radical and
+ * algebraic substitution, quadratic radicals, integration by parts,
+ * derivative-pattern substitution, rational decomposition, and the
+ * Weierstrass tangent half-angle substitution.
+ *
+ * @remarks
+ * This function returns an antiderivative only; it does not append a constant
+ * of integration and it does not accept definite-integration bounds. An
+ * unsupported integral, or a strategy that reaches the recursion guard, is
+ * represented as an unevaluated `integrate(expr, dx)` Expression rather than an
+ * exception.
+ *
+ * Branch-sensitive transformations are limited to patterns recognized by the
+ * implementation. The result should not be read as a global statement about
+ * every real or complex branch outside those supported patterns.
+ *
+ * `depth` is the internal strategy-recursion counter and should normally be
+ * omitted by direct callers.
+ *
+ * @param expr - Integrand to normalize and integrate.
+ * @param dx - Plain integration variable.
+ * @param depth - Internal recursion depth. Defaults to zero.
+ * @returns A symbolic antiderivative without an integration constant, or an
+ * unevaluated `integrate(...)` Expression.
+ * @throws {@link core!UnexpectedInputError} If `dx` is not a plain variable.
+ *
+ * @example
+ * ```ts
+ * integrate('2*x*cos(x^2)', 'x').text();
+ * ```
+ */
+export declare function integrate(expr: ExpressionInput, dx: ExpressionInput, depth?: number): Expression;