nerdamer 1.1.13 → 2.0.0-rc.1

package/output/calculus/integrate/integrate.js

@@ -0,0 +1,652 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.integrate = integrate;
+const partfrac_1 = require("../../algebra/partfrac");
+const simplify_1 = require("../../algebra/simplify/simplify");
+const trigrewrite_1 = require("../../algebra/simplify/trigrewrite");
+const Expression_1 = require("../../core/classes/expression/Expression");
+const products_1 = require("../../core/classes/expression/products");
+const shortcuts_1 = require("../../core/classes/expression/shortcuts");
+const utils_1 = require("../../core/classes/expression/utils");
+const constants_1 = require("../../core/classes/parser/constants");
+const Polynomial_1 = require("../../core/classes/polynomial/Polynomial");
+const utils_2 = require("../../core/classes/polynomial/utils");
+const Pattern_1 = require("../../core/converters/Pattern");
+const subst_1 = require("../../core/functions/subst");
+const math_1 = require("../../math/math");
+const trig_1 = require("../../math/trig");
+const byParts_1 = require("./byParts");
+const bySubstitution_1 = require("./bySubstitution");
+const integrationTable_1 = require("./integrationTable");
+const utils_3 = require("./utils");
+const MAX_DEPTH = 10;
+/**
+ * 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();
+ * ```
+ */
+function integrate(expr, dx, depth = 0) {
+    expr = Expression_1.Expression.create(expr);
+    dx = (0, utils_1.assertPlainVariableAndGetString)(Expression_1.Expression.create(dx));
+    const fn = Expression_1.Expression.create(expr);
+    let retval;
+    if (depth++ > MAX_DEPTH) {
+        retval = Expression_1.Expression.toFunction(constants_1.INTEGRATE, [fn, dx]);
+    }
+    else {
+        let constants;
+        ({ constants, expression: expr } = (0, products_1.constantsFreeProduct)(expr, dx));
+        if (!expr.hasVariable(dx)) {
+            retval = expr.times(dx);
+        }
+        else if (expr.isSum() && expr.isLinear()) {
+            let sum = (0, shortcuts_1.zero)();
+            expr.each((e) => {
+                sum = sum.plus(integrate(e, dx, depth));
+            });
+            retval = sum;
+        }
+        else {
+            retval = integrationTable_1.tableOfIntegrals.lookup(new Pattern_1.Pattern(expr, [dx]), depth);
+        }
+        if (!retval) {
+            retval = tryIntegrateLogPower(expr, dx, depth);
+        }
+        if (!retval) {
+            retval = tryIntegrateByRadicalSubstitutionFastPath(expr, dx, depth);
+        }
+        if (!retval) {
+            retval = tryIntegrateSqrtQuadratic(expr, dx);
+        }
+        if (!retval && expr.isProduct()) {
+            const wrapped = (0, bySubstitution_1.tryIntegrateByWrappedFactorSubstitution)(expr, expr.elementsArray(), dx);
+            if (wrapped) {
+                retval = wrapped;
+            }
+        }
+        if (!retval && expr.isProduct()) {
+            // If any factor of the product is a sum, expand and retry.
+            // This distributes e.g. x*sec(u)^2*(1+tan(u)^2) into
+            // x*sec(u)^2 + x*sec(u)^2*tan(u)^2, enabling linearity.
+            let hasSumFactor = false;
+            for (const factor of expr.elementsArray()) {
+                if (factor.isSum() && (0, utils_3.hasTranscendental)(factor, dx)) {
+                    hasSumFactor = true;
+                    break;
+                }
+            }
+            if (hasSumFactor) {
+                const expanded = expr.expand();
+                if (expanded.isSum() && expanded.isLinear()) {
+                    let expandedResult = (0, shortcuts_1.zero)();
+                    let allResolved = true;
+                    expanded.each((term) => {
+                        const termResult = integrate(term, dx, depth);
+                        if (termResult.isFunction(constants_1.INTEGRATE)) {
+                            allResolved = false;
+                        }
+                        expandedResult = expandedResult.plus(termResult);
+                    });
+                    if (allResolved) {
+                        retval = expandedResult;
+                    }
+                }
+            }
+        }
+        if (!retval) {
+            const result = (0, byParts_1.tryIntegrationByParts)(expr, dx, integrate, depth);
+            if (result) {
+                retval = result;
+            }
+        }
+        if (!retval) {
+            const logResult = (0, bySubstitution_1.tryIntegrateByLogSubstitution)(expr, dx);
+            if (logResult) {
+                retval = (0, math_1.log)(logResult.fx).times(logResult.constant);
+            }
+        }
+        if (!retval) {
+            const subsResult = (0, bySubstitution_1.tryIntegrateBySubstitution)(expr, dx);
+            if (subsResult) {
+                const n = subsResult.power;
+                const nPlusOne = n.plus((0, shortcuts_1.one)());
+                retval = subsResult.fx.pow(nPlusOne).div(nPlusOne).times(subsResult.constant);
+            }
+        }
+        if (!retval) {
+            retval = tryIntegratePolynomial(expr, dx);
+        }
+        if (!retval) {
+            retval = tryIntegratePowerQuotient(expr, dx, depth);
+        }
+        if (!retval) {
+            retval = tryIntegrateRational(expr, dx, depth);
+        }
+        if (!retval) {
+            retval = tryIntegrateByWeierstrass(expr, dx, depth);
+        }
+        if (retval) {
+            retval = retval.times(constants);
+        }
+    }
+    return retval ?? Expression_1.Expression.toFunction(constants_1.INTEGRATE, [fn, dx]);
+}
+function tryIntegratePolynomial(expr, dx) {
+    if (!expr.isPolynomialLike() || (0, utils_3.hasTranscendental)(expr, dx)) {
+        return undefined;
+    }
+    let polynomial;
+    try {
+        polynomial = new Polynomial_1.Polynomial(expr, [dx]);
+    }
+    catch {
+        return undefined;
+    }
+    const coeffs = polynomial.toArray(false, dx);
+    const x = Expression_1.Expression.create(dx);
+    let retval = (0, shortcuts_1.zero)();
+    for (let i = 0; i < coeffs.length; i++) {
+        const coeff = coeffs[i] ?? (0, shortcuts_1.zero)();
+        if (!coeff.isZero()) {
+            const power = i + 1;
+            retval = retval.plus(coeff.times(x.pow(power)).div(power));
+        }
+    }
+    return retval;
+}
+function tryIntegrateLogPower(expr, dx, depth) {
+    if (!expr.isFunction(constants_1.LOG)) {
+        return undefined;
+    }
+    const power = expr.getPower();
+    if (!power.isInteger() || !power.gt((0, shortcuts_1.one)())) {
+        return undefined;
+    }
+    const args = expr.getArguments();
+    if (args.length !== 1) {
+        return undefined;
+    }
+    let argumentPolynomial;
+    try {
+        argumentPolynomial = new Polynomial_1.Polynomial(args[0], [dx]);
+    }
+    catch {
+        return undefined;
+    }
+    if (argumentPolynomial.deg() !== 1) {
+        return undefined;
+    }
+    const coeffs = argumentPolynomial.toArray(false, dx);
+    const linearCoefficient = coeffs[1] ?? (0, shortcuts_1.zero)();
+    if (linearCoefficient.isZero()) {
+        return undefined;
+    }
+    const lowerPower = expr.getBase().pow(power.minus((0, shortcuts_1.one)()));
+    const lowerIntegral = integrate(lowerPower, dx, depth);
+    if (lowerIntegral.isFunction(constants_1.INTEGRATE)) {
+        return undefined;
+    }
+    const leadingTerm = args[0].div(linearCoefficient).times(expr);
+    return leadingTerm.minus(power.times(lowerIntegral));
+}
+function isRationalFunctionInVariable(expr, variable) {
+    try {
+        new Polynomial_1.Polynomial(expr.getNumerator(), [variable]);
+        new Polynomial_1.Polynomial(expr.getDenominator(), [variable]);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function tryIntegrateByRadicalSubstitutionFastPath(expr, dx, depth) {
+    const newVariable = (0, subst_1.getU)(expr);
+    const sub = (0, utils_3.radicalSubstitution)(expr, dx, newVariable);
+    if (!sub) {
+        return undefined;
+    }
+    const transformed = (0, simplify_1.simplify)(sub.integrand);
+    if (!isRationalFunctionInVariable(transformed, sub.newVariable)) {
+        return undefined;
+    }
+    const inner = tryIntegrateRational(transformed, sub.newVariable, depth);
+    if (!inner || inner.isFunction(constants_1.INTEGRATE)) {
+        return undefined;
+    }
+    return (0, simplify_1.simplify)((0, subst_1.subst)(inner, Expression_1.Expression.create(sub.newVariable), sub.backSub));
+}
+function tryIntegrateSqrtQuadratic(expr, dx) {
+    const power = expr.getPower();
+    if (!power.eq((0, shortcuts_1.half)())) {
+        return undefined;
+    }
+    const base = expr.getBase();
+    if ((0, utils_3.hasTranscendental)(base, dx)) {
+        return undefined;
+    }
+    let p;
+    try {
+        p = new Polynomial_1.Polynomial(base, [dx]);
+    }
+    catch {
+        return undefined;
+    }
+    if (p.deg() !== 2) {
+        return undefined;
+    }
+    const coeffs = p.toArray(false, dx);
+    const c = coeffs[0] ?? (0, shortcuts_1.zero)();
+    const b = coeffs[1] ?? (0, shortcuts_1.zero)();
+    const a = coeffs[2] ?? (0, shortcuts_1.zero)();
+    if (a.isZero()) {
+        return undefined;
+    }
+    const x = Expression_1.Expression.create(dx);
+    const u = x.plus(b.div((0, shortcuts_1.two)().times(a)));
+    const k = c.minus(b.pow((0, shortcuts_1.two)()).div((0, shortcuts_1.four)().times(a)));
+    const sqrtQ = expr;
+    const leadingTerm = (0, shortcuts_1.half)().times(u).times(sqrtQ);
+    if (k.isZero()) {
+        return undefined;
+    }
+    if (a.gt((0, shortcuts_1.zero)())) {
+        const sqrtA = a.pow((0, shortcuts_1.half)());
+        if (k.gt((0, shortcuts_1.zero)())) {
+            const sqrtK = k.pow((0, shortcuts_1.half)());
+            const arg = sqrtA.times(u).div(sqrtK);
+            return leadingTerm.plus(k.div((0, shortcuts_1.two)().times(sqrtA)).times(Expression_1.Expression.toFunction(constants_1.ASINH, [arg])));
+        }
+        if (k.lt((0, shortcuts_1.zero)())) {
+            const arg = sqrtA.times(u).plus(sqrtQ);
+            return leadingTerm.plus(k.div((0, shortcuts_1.two)().times(sqrtA)).times((0, math_1.log)(arg)));
+        }
+        return undefined;
+    }
+    if (a.lt((0, shortcuts_1.zero)()) && k.gt((0, shortcuts_1.zero)())) {
+        const sqrtNegA = a.times('-1').pow((0, shortcuts_1.half)());
+        const sqrtK = k.pow((0, shortcuts_1.half)());
+        const arg = sqrtNegA.times(u).div(sqrtK);
+        return leadingTerm.plus(k.div((0, shortcuts_1.two)().times(sqrtNegA)).times(Expression_1.Expression.toFunction(constants_1.ASIN, [arg])));
+    }
+    return undefined;
+}
+function tryIntegrateRational(expr, dx, depth) {
+    const num = expr.getNumerator();
+    const den = expr.getDenominator();
+    if (den.isOne() || !den.hasVariable(dx)) {
+        return undefined;
+    }
+    if ((0, utils_3.hasTranscendental)(num, dx) || (0, utils_3.hasTranscendental)(den, dx)) {
+        return undefined;
+    }
+    let pNum;
+    let pDen;
+    try {
+        pNum = new Polynomial_1.Polynomial(num, [dx]);
+        pDen = new Polynomial_1.Polynomial(den, [dx]);
+    }
+    catch {
+        return undefined;
+    }
+    const degNum = pNum.deg();
+    const degDen = pDen.deg();
+    if (degDen < 2) {
+        return undefined;
+    }
+    let result = (0, shortcuts_1.zero)();
+    let remainder = num;
+    if (degNum >= degDen) {
+        try {
+            const [quotient, rem] = (0, utils_2.divide)(num, den, undefined, [dx]);
+            const polyIntegral = integrate(quotient, dx, depth);
+            if (polyIntegral.isFunction(constants_1.INTEGRATE)) {
+                return undefined;
+            }
+            result = result.plus(polyIntegral);
+            remainder = rem;
+        }
+        catch {
+            return undefined;
+        }
+        if (Expression_1.Expression.create(remainder).isZero()) {
+            return result;
+        }
+    }
+    const properFraction = Expression_1.Expression.create(remainder).div(den);
+    if (degNum >= degDen) {
+        const directIntegral = integrate(properFraction, dx, depth);
+        if (!directIntegral.isFunction(constants_1.INTEGRATE)) {
+            result = result.plus(directIntegral);
+            return result;
+        }
+    }
+    const quadraticIntegral = tryIntegrateLinearOverQuadratic(properFraction, dx);
+    if (quadraticIntegral) {
+        return result.plus(quadraticIntegral);
+    }
+    let decomposed;
+    try {
+        decomposed = (0, partfrac_1.partfrac)(properFraction, dx);
+    }
+    catch {
+        return undefined;
+    }
+    if (decomposed.text() === properFraction.text()) {
+        return undefined;
+    }
+    const decomposedIntegral = integrate(decomposed, dx, depth);
+    if (decomposedIntegral.isFunction(constants_1.INTEGRATE)) {
+        return undefined;
+    }
+    return result.plus(decomposedIntegral);
+}
+function tryIntegrateLinearOverQuadratic(expr, dx) {
+    const num = expr.getNumerator();
+    const den = expr.getDenominator();
+    if (den.isOne() || !den.hasVariable(dx)) {
+        return undefined;
+    }
+    if ((0, utils_3.hasTranscendental)(num, dx) || (0, utils_3.hasTranscendental)(den, dx)) {
+        return undefined;
+    }
+    let nCoeffs;
+    let dCoeffs;
+    try {
+        const nc = num.coeffs(dx);
+        const dc = den.coeffs(dx);
+        if (dc.max() !== 2 || nc.max() > 1) {
+            return undefined;
+        }
+        nCoeffs = nc.toArray();
+        dCoeffs = dc.toArray();
+    }
+    catch {
+        return undefined;
+    }
+    const a = dCoeffs[2] ?? (0, shortcuts_1.zero)();
+    const b = dCoeffs[1] ?? (0, shortcuts_1.zero)();
+    const c = dCoeffs[0] ?? (0, shortcuts_1.zero)();
+    const m = nCoeffs[1] ?? (0, shortcuts_1.zero)();
+    const n = nCoeffs[0] ?? (0, shortcuts_1.zero)();
+    if (a.isZero()) {
+        return undefined;
+    }
+    const x = Expression_1.Expression.create(dx);
+    const A = m.div((0, shortcuts_1.two)().times(a));
+    const B = n.minus(A.times(b));
+    let result = (0, shortcuts_1.zero)();
+    if (!A.isZero()) {
+        result = result.plus(A.times((0, math_1.log)(den)));
+    }
+    if (B.isZero()) {
+        return result;
+    }
+    const twoAxPlusB = (0, shortcuts_1.two)().times(a).times(x).plus(b);
+    const delta = (0, shortcuts_1.four)().times(a).times(c).minus(b.pow('2'));
+    let reciprocalIntegral;
+    if (delta.isZero()) {
+        reciprocalIntegral = (0, shortcuts_1.two)().times('-1').div(twoAxPlusB);
+    }
+    else if (delta.gt((0, shortcuts_1.zero)())) {
+        const sqrtDelta = delta.pow((0, shortcuts_1.half)());
+        const arg = twoAxPlusB.div(sqrtDelta);
+        reciprocalIntegral = (0, shortcuts_1.two)()
+            .div(sqrtDelta)
+            .times(Expression_1.Expression.toFunction(constants_1.ATAN, [arg]));
+    }
+    else if (delta.lt((0, shortcuts_1.zero)())) {
+        const sqrtNegDelta = delta.times('-1').pow((0, shortcuts_1.half)());
+        const ratio = twoAxPlusB.minus(sqrtNegDelta).div(twoAxPlusB.plus(sqrtNegDelta));
+        reciprocalIntegral = (0, math_1.log)(ratio).div(sqrtNegDelta);
+    }
+    else {
+        return undefined;
+    }
+    return result.plus(B.times(reciprocalIntegral));
+}
+function tryIntegratePowerQuotient(expr, dx, depth) {
+    const powResult = (0, bySubstitution_1.tryIntegrateByPowerSubstitution)(expr, dx);
+    if (powResult) {
+        const n = powResult.power;
+        const oneMinusN = (0, shortcuts_1.one)().plus(n.times((0, shortcuts_1.minusOne)()));
+        return powResult.fx.pow(oneMinusN).div(oneMinusN).times(powResult.constant);
+    }
+    const num = expr.getNumerator();
+    const den = expr.getDenominator();
+    if (den.isOne() || !den.hasVariable(dx)) {
+        return undefined;
+    }
+    const denBase = den.getBase();
+    const denPower = den.getPower();
+    if (denPower.isOne()) {
+        return undefined;
+    }
+    if ((0, utils_3.hasTranscendental)(num, dx) || (0, utils_3.hasTranscendental)(denBase, dx)) {
+        return undefined;
+    }
+    let pNum;
+    try {
+        pNum = new Polynomial_1.Polynomial(num, [dx]);
+        new Polynomial_1.Polynomial(denBase, [dx]);
+    }
+    catch {
+        return undefined;
+    }
+    if (pNum.deg() < 1) {
+        return undefined;
+    }
+    let quotient;
+    let remainder;
+    try {
+        [quotient, remainder] = (0, utils_2.divide)(num, denBase, undefined, [dx]);
+    }
+    catch {
+        return undefined;
+    }
+    if (Expression_1.Expression.create(quotient).isZero()) {
+        return undefined;
+    }
+    const term1 = Expression_1.Expression.create(quotient).times(denBase.pow((0, shortcuts_1.one)().plus(denPower.times((0, shortcuts_1.minusOne)()))));
+    const term2Num = Expression_1.Expression.create(remainder);
+    const term2 = term2Num.isZero() ? (0, shortcuts_1.zero)() : term2Num.div(den);
+    const integral1 = integrate(term1, dx, depth);
+    if (integral1.isFunction(constants_1.INTEGRATE)) {
+        return undefined;
+    }
+    let result = integral1;
+    if (!term2Num.isZero()) {
+        const integral2 = integrate(term2, dx, depth);
+        if (integral2.isFunction(constants_1.INTEGRATE)) {
+            return undefined;
+        }
+        result = result.plus(integral2);
+    }
+    return result;
+}
+// ============================================================================
+// Weierstrass substitution (tangent half-angle substitution)
+//
+// For integrands that are rational functions of sin(x) and cos(x),
+// the substitution t = tan(x/2) converts to a rational function of t:
+//
+//   sin(x) = 2t/(1+t²)
+//   cos(x) = (1-t²)/(1+t²)
+//   dx     = 2/(1+t²) dt
+//
+// The resulting rational function can be integrated via partial fractions.
+//
+// More generally, for trig functions with argument (a*x+b):
+//   t = tan((a*x+b)/2)
+//   sin(a*x+b) = 2t/(1+t²)
+//   cos(a*x+b) = (1-t²)/(1+t²)
+//   dx = 2/(a*(1+t²)) dt
+// ============================================================================
+/**
+ * Determines whether an expression is a rational function of sin and cos
+ * with a common linear argument in the integration variable.
+ *
+ * Returns the common trig argument if so, or undefined if not.
+ *
+ * The expression must have all occurrences of the integration variable
+ * wrapped inside sin(x) or cos(x) calls (after rewriting tan/sec/csc/cot),
+ * and all such calls must share the same argument. Reuse trig rewrite from simplify.
+ */
+function getTrigArgIfRationalInTrig(expr, dx) {
+    let commonArg;
+    let valid = true;
+    function walk(e) {
+        if (!valid) {
+            return;
+        }
+        if (e.isFunction(constants_1.SIN) || e.isFunction(constants_1.COS)) {
+            const args = e.getArguments();
+            if (args.length === 1 && args[0].hasVariable(dx)) {
+                if (commonArg === undefined) {
+                    commonArg = args[0];
+                }
+                else if (!commonArg.eq(args[0])) {
+                    valid = false;
+                }
+            }
+            // Don't descend into the trig argument — it's been accounted for
+            return;
+        }
+        // If we encounter a bare variable outside of sin/cos, this is not
+        // purely rational in trig
+        if (e.isVAR() && e.hasVariable(dx)) {
+            valid = false;
+            return;
+        }
+        // Descend into sums, products
+        if (e.isSum() || e.isProduct()) {
+            for (const child of e.elementsArray()) {
+                walk(child);
+            }
+            // Also check the power. It should not contain the variable
+            const p = e.getPower();
+            if (p.hasVariable(dx)) {
+                valid = false;
+            }
+            return;
+        }
+        // For any other function containing the variable (e.g. log, exp),
+        // this is not rational in trig
+        if (e.isFunction() && e.hasVariable(dx)) {
+            valid = false;
+            return;
+        }
+        if (e.isEXP() && e.hasVariable(dx)) {
+            valid = false;
+            return;
+        }
+    }
+    walk(expr);
+    if (valid && commonArg !== undefined) {
+        return commonArg;
+    }
+    return undefined;
+}
+/**
+ * Extracts the linear coefficient from a trig argument of the form a*x+b.
+ * Returns the coefficient `a` such that d/dx[a*x+b] = a.
+ * Returns undefined if the argument is not linear in dx.
+ */
+function getLinearCoefficient(arg, dx) {
+    try {
+        const p = new Polynomial_1.Polynomial(arg, [dx]);
+        if (p.deg() !== 1) {
+            return undefined;
+        }
+        const coeffs = p.toArray(false, dx);
+        return coeffs[1] ?? undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Attempts to integrate a rational function of trig via Weierstrass substitution.
+ *
+ * The substitution t = tan(arg/2) transforms the integrand into a rational
+ * function of t, which can then be integrated using the existing rational
+ * function machinery (partial fractions, etc.).
+ */
+function tryIntegrateByWeierstrass(expr, dx, depth) {
+    // Step 1: Rewrite tan/sec/csc/cot to sin/cos
+    let working = expr;
+    if ((0, trigrewrite_1.hasDerivedTrig)(working)) {
+        working = (0, trigrewrite_1.rewrite)(working);
+    }
+    // Step 2: Check if the result is rational in sin/cos with a common argument
+    const trigArg = getTrigArgIfRationalInTrig(working, dx);
+    if (!trigArg) {
+        return undefined;
+    }
+    // Step 3: Extract the linear coefficient of the argument
+    const a = getLinearCoefficient(trigArg, dx);
+    if (!a) {
+        return undefined;
+    }
+    // Step 4: Pick a fresh variable for the substitution
+    const tName = (0, subst_1.getU)(expr);
+    const t = Expression_1.Expression.create(tName);
+    const tSq = t.pow((0, shortcuts_1.two)());
+    const onePlusTSq = (0, shortcuts_1.one)().plus(tSq);
+    // Step 5: Perform the substitution
+    //   sin(x) → 2t/(1+t²)
+    //   cos(x) → (1-t²)/(1+t²)
+    const sinReplacement = (0, shortcuts_1.two)().times(t).div(onePlusTSq);
+    const cosReplacement = (0, shortcuts_1.one)().minus(tSq).div(onePlusTSq);
+    let substituted = (0, subst_1.subst)(working, (0, trig_1.sin)(trigArg), sinReplacement);
+    substituted = (0, subst_1.subst)(substituted, (0, trig_1.cos)(trigArg), cosReplacement);
+    // Multiply by the Jacobian: dx = 2/(a*(1+t²)) dt
+    const jacobian = (0, shortcuts_1.two)().div(a.times(onePlusTSq));
+    substituted = substituted.times(jacobian);
+    // Step 6: Simplify — should collapse to a rational function of t
+    substituted = (0, simplify_1.simplify)(substituted);
+    // Verify it's actually rational in t (no leftover trig or transcendentals)
+    if (substituted.hasVariable(dx)) {
+        return undefined;
+    }
+    if (!isRationalFunctionInVariable(substituted, tName)) {
+        return undefined;
+    }
+    // Step 7: Integrate the rational function
+    const rational = integrate(substituted, tName, depth);
+    if (rational.isFunction(constants_1.INTEGRATE)) {
+        return undefined;
+    }
+    // Step 8: Back-substitute t → tan(arg/2)
+    const backSub = (0, trig_1.tan)(trigArg.div((0, shortcuts_1.two)()));
+    return (0, simplify_1.simplify)((0, subst_1.subst)(rational, t, backSub));
+}

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

@@ -0,0 +1,2 @@
+import { LookupTable } from '../../core/classes/lookupTable/LookupTable';
+export declare const tableOfIntegrals: LookupTable;