nerdamer 1.1.13 → 2.0.0-rc.1

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

@@ -0,0 +1,28 @@
+import { Expression } from '../../core/classes/expression/Expression';
+import type { ExpressionInput } from '../../core/types';
+/** Description of the substitution `x = t^n` used to clear fractional powers. */
+export interface RadicalSubstitutionResult {
+    /** Integrand after substitution and multiplication by `dx/dt`. */
+    integrand: Expression;
+    /** Fresh variable used in the transformed integrand. */
+    newVariable: string;
+    /** Variable replaced in the original integrand. */
+    originalVariable: string;
+    /** Least common multiple of the fractional-power denominators. */
+    n: number;
+    /** Expression in the original variable used to replace the fresh variable. */
+    backSub: Expression;
+}
+/**
+ * Builds the substitution `x = t^n` needed to eliminate fractional powers.
+ *
+ * @param expr - Integrand to inspect and transform.
+ * @param variable - Variable whose fractional powers should be cleared. The
+ * first expression variable is used when omitted.
+ * @param newVar - Fresh substitution variable. Defaults to `t`.
+ * @returns Substitution metadata, or `null` if the expression is constant or
+ * contains no fractional powers of the selected variable.
+ */
+export declare function radicalSubstitution(expr: ExpressionInput, variable?: string, newVar?: string): RadicalSubstitutionResult | null;
+/** Returns whether `expr` contains a variable-dependent function or exponential. */
+export declare function hasTranscendental(expr: Expression, v: string): boolean;

package/output/calculus/integrate/utils.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.radicalSubstitution = radicalSubstitution;
+exports.hasTranscendental = hasTranscendental;
+const Expression_1 = require("../../core/classes/expression/Expression");
+const bigint_1 = require("../../core/functions/bigint/bigint");
+const subst_1 = require("../../core/functions/subst");
+/**
+ * Collects all fractional power denominators of a given variable in an expression.
+ * Walks into sums, products, and function arguments.
+ */
+function collectPowerDenominators(expr, variable) {
+    const denoms = [];
+    function walk(e) {
+        if (e.isVAR() && e.value === variable) {
+            const p = e.getPower();
+            if (p.isNUM()) {
+                const r = p.getMultiplier();
+                const d = r.denominator < 0n ? -r.denominator : r.denominator;
+                if (d !== 1n) {
+                    denoms.push(d);
+                }
+            }
+            return;
+        }
+        if (e.isSum() || e.isProduct()) {
+            for (const el of e.elementsArray()) {
+                walk(el);
+            }
+            return;
+        }
+        if (e.isFunction()) {
+            for (const arg of e.getArguments()) {
+                walk(arg);
+            }
+        }
+    }
+    walk(expr);
+    return denoms;
+}
+/**
+ * Builds the substitution `x = t^n` needed to eliminate fractional powers.
+ *
+ * @param expr - Integrand to inspect and transform.
+ * @param variable - Variable whose fractional powers should be cleared. The
+ * first expression variable is used when omitted.
+ * @param newVar - Fresh substitution variable. Defaults to `t`.
+ * @returns Substitution metadata, or `null` if the expression is constant or
+ * contains no fractional powers of the selected variable.
+ */
+function radicalSubstitution(expr, variable, newVar = 't') {
+    const e = Expression_1.Expression.create(expr);
+    if (!variable) {
+        const vars = e.variables();
+        if (vars.length === 0) {
+            return null;
+        }
+        variable = vars[0];
+    }
+    const denoms = collectPowerDenominators(e, variable);
+    if (denoms.length === 0) {
+        return null;
+    }
+    const nBig = (0, bigint_1.bigintLCM)(denoms);
+    const n = Number(nBig);
+    const t = Expression_1.Expression.create(newVar);
+    const substituted = (0, subst_1.rewriteRadicals)(e, variable, t, nBig);
+    const dxdt = Expression_1.Expression.create(String(n)).times(t.pow(n - 1));
+    const integrand = substituted.times(dxdt);
+    const backSub = Expression_1.Expression.create(variable).pow(Expression_1.Expression.create(`1/${n}`));
+    return {
+        integrand,
+        newVariable: newVar,
+        originalVariable: variable,
+        n,
+        backSub,
+    };
+}
+/** Returns whether `expr` contains a variable-dependent function or exponential. */
+function hasTranscendental(expr, v) {
+    if (expr.isFunction() && expr.hasVariable(v)) {
+        return true;
+    }
+    if (expr.isEXP() && expr.hasVariable(v)) {
+        return true;
+    }
+    let found = false;
+    if (expr.isProduct() || expr.isSum()) {
+        expr.each((child) => {
+            if (hasTranscendental(child, v)) {
+                found = true;
+            }
+        });
+    }
+    return found;
+}

package/output/calculus/laplace/ilaplace.d.ts

@@ -0,0 +1,31 @@
+import { Expression } from '../../core/classes/expression/Expression';
+import type { ExpressionInput } from '../../core/types';
+/**
+ * Computes a symbolic inverse Laplace transform from a transform variable to a
+ * time variable.
+ *
+ * The strategy applies linearity, extracts constants, consults the inverse
+ * transform table, normalizes supported shifted quadratics and exponential
+ * delays, and finally tries partial-fraction decomposition.
+ *
+ * @remarks
+ * Exponential delay extraction requires a provably positive shift coefficient
+ * according to the expression's current sign information. Unsupported or
+ * ambiguous input is returned as an unevaluated `ilaplace(expr, s, t)`
+ * Expression. The partial-fraction fallback is only attempted when both the
+ * numerator and denominator are in its polynomial domain, and relies on
+ * `partfrac` preserving object identity when it performs no decomposition.
+ *
+ * @param expr - Transform-domain expression.
+ * @param s - Plain transform-domain variable.
+ * @param t - Plain time-domain variable.
+ * @returns The symbolic inverse transform, or an unevaluated `ilaplace(...)`
+ * Expression when no strategy resolves the input.
+ * @throws {@link core!UnexpectedInputError} If `s` or `t` is not a plain variable.
+ *
+ * @example
+ * ```ts
+ * ilaplace('1/(s^2+1)', 's', 't').text();
+ * ```
+ */
+export declare function ilaplace(expr: ExpressionInput, s: ExpressionInput, t: ExpressionInput): Expression;

package/output/calculus/laplace/ilaplace.js

@@ -0,0 +1,192 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ilaplace = ilaplace;
+const partfrac_1 = require("../../algebra/partfrac");
+const utils_1 = require("../../algebra/utils");
+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_2 = require("../../core/classes/expression/utils");
+const constants_1 = require("../../core/classes/parser/constants");
+const Pattern_1 = require("../../core/converters/Pattern");
+const ilaplaceTable_1 = require("./ilaplaceTable");
+/**
+ * Computes a symbolic inverse Laplace transform from a transform variable to a
+ * time variable.
+ *
+ * The strategy applies linearity, extracts constants, consults the inverse
+ * transform table, normalizes supported shifted quadratics and exponential
+ * delays, and finally tries partial-fraction decomposition.
+ *
+ * @remarks
+ * Exponential delay extraction requires a provably positive shift coefficient
+ * according to the expression's current sign information. Unsupported or
+ * ambiguous input is returned as an unevaluated `ilaplace(expr, s, t)`
+ * Expression. The partial-fraction fallback is only attempted when both the
+ * numerator and denominator are in its polynomial domain, and relies on
+ * `partfrac` preserving object identity when it performs no decomposition.
+ *
+ * @param expr - Transform-domain expression.
+ * @param s - Plain transform-domain variable.
+ * @param t - Plain time-domain variable.
+ * @returns The symbolic inverse transform, or an unevaluated `ilaplace(...)`
+ * Expression when no strategy resolves the input.
+ * @throws {@link core!UnexpectedInputError} If `s` or `t` is not a plain variable.
+ *
+ * @example
+ * ```ts
+ * ilaplace('1/(s^2+1)', 's', 't').text();
+ * ```
+ */
+function ilaplace(expr, s, t) {
+    expr = Expression_1.Expression.create(expr);
+    s = (0, utils_2.assertPlainVariableAndGetString)(Expression_1.Expression.create(s));
+    t = (0, utils_2.assertPlainVariableAndGetString)(Expression_1.Expression.create(t));
+    let retval;
+    // Linearity over sums
+    if (expr.isSum() && expr.isLinear()) {
+        const elements = expr.elementsArray();
+        retval = (0, shortcuts_1.zero)();
+        for (const e of elements) {
+            const transform = ilaplace(e, s, t);
+            // Any unevaluated ilaplace(.) means this branch failed
+            if (transform.isFunction(constants_1.ILAPLACE)) {
+                retval = undefined;
+                break;
+            }
+            retval = retval.plus(transform);
+        }
+        if (retval) {
+            return retval;
+        }
+    }
+    // Pull out a numeric multiplier stored directly on a non-product node.
+    const multiplier = Expression_1.Expression.fromRational(expr.getMultiplier());
+    if (!multiplier.isOne()) {
+        const transform = ilaplace(expr.toUnitMultiplier(), s, t);
+        if (!transform.isFunction(constants_1.ILAPLACE)) {
+            return multiplier.times(transform);
+        }
+    }
+    // Pull out constants from products
+    if (expr.isProduct()) {
+        const { constants, expression } = (0, products_1.constantsFreeProduct)(expr, s);
+        if (!constants.isOne()) {
+            const transform = ilaplace(expression, s, t);
+            if (!transform.isFunction(constants_1.ILAPLACE)) {
+                return constants.times(transform);
+            }
+        }
+    }
+    // Base/derived table lookup
+    retval = ilaplaceTable_1.tableOfInverseTransforms.lookup(new Pattern_1.Pattern(expr, [s]), 0);
+    if (retval) {
+        if (t !== 't') {
+            retval = retval.evaluate({ t });
+        }
+        return retval;
+    }
+    // Normalize an affine numerator over an expanded quadratic to the shifted
+    // forms already covered by the inverse-transform table.
+    {
+        const num = expr.getNumerator();
+        const den = expr.getDenominator();
+        if (den.isPolynomialLike() && num.isPolynomialLike()) {
+            const denCoeffs = den.coeffs(s);
+            const numCoeffs = num.coeffs(s);
+            if (denCoeffs.max() === 2 && numCoeffs.max() <= 1) {
+                const { h, expression: completed } = (0, utils_1.sqcomp)(den, s);
+                const hasShiftedSquare = den.isSum() &&
+                    den
+                        .elementsArray()
+                        .some(term => term.getPower().eq(2) && term.getBase().isSum());
+                if (!h.isZero() && !hasShiftedSquare) {
+                    const constant = numCoeffs.hasPower(0) ? numCoeffs.getPower(0) : (0, shortcuts_1.zero)();
+                    const linear = numCoeffs.hasPower(1) ? numCoeffs.getPower(1) : (0, shortcuts_1.zero)();
+                    const shifted = Expression_1.Expression.create(s).plus(h);
+                    const remainder = constant.minus(linear.times(h));
+                    const alignedTransform = linear.isZero()
+                        ? (0, shortcuts_1.zero)()
+                        : ilaplace(shifted.div(completed), s, t);
+                    const remainderTransform = remainder.isZero()
+                        ? (0, shortcuts_1.zero)()
+                        : ilaplace(completed.invert(), s, t);
+                    if (!alignedTransform.isFunction(constants_1.ILAPLACE) &&
+                        !remainderTransform.isFunction(constants_1.ILAPLACE)) {
+                        return linear
+                            .times(alignedTransform)
+                            .plus(remainder.times(remainderTransform));
+                    }
+                }
+            }
+        }
+    }
+    // Exponential shift: L^-1{e^(-a*s) * F(s)} = heaviside(t-a) * f(t-a)
+    // When e^(-a*s) appears, it lands in the denominator as e^(a*s) with a > 0.
+    {
+        const num = expr.getNumerator();
+        const den = expr.getDenominator();
+        const shift = extractExpShift(den, s);
+        if (shift) {
+            // Rebuild the expression without the exponential factor
+            const stripped = num.div(shift.remainder);
+            const transform = ilaplace(stripped, s, t);
+            if (!transform.isFunction(constants_1.ILAPLACE)) {
+                const a = shift.coefficient;
+                const tShifted = Expression_1.Expression.create(t).minus(a);
+                const shifted = transform.subst(t, tShifted);
+                return Expression_1.Expression.toFunction(constants_1.HEAVISIDE, [tShifted]).times(shifted);
+            }
+        }
+    }
+    // Partial fractions are only defined here for polynomial numerators and denominators.
+    // partfrac constructs Polynomial objects once the denominator depends on the selected
+    // variable, so guard its domain rather than leaking a PolynomialError for unsupported input.
+    const num = expr.getNumerator();
+    const den = expr.getDenominator();
+    if (num.isPolynomialLike() && den.isPolynomialLike()) {
+        // IMPORTANT: partfrac returns the same reference (===) when no decomposition
+        // occurs. This identity check avoids infinite recursion. If partfrac is ever
+        // changed to return a copy on no-op, this will silently cause wasted recursion
+        // (or worse). Keep this method in sync with partfrac.
+        const decomposed = (0, partfrac_1.partfrac)(expr, s);
+        if (decomposed !== expr) {
+            const transform = ilaplace(decomposed, s, t);
+            if (!transform.isFunction(constants_1.ILAPLACE)) {
+                return transform;
+            }
+        }
+    }
+    return Expression_1.Expression.toFunction(constants_1.ILAPLACE, [expr, s, t]);
+}
+/**
+ * Scans a denominator expression for an exponential factor e^(a*s) where a > 0.
+ * This corresponds to e^(-a*s) in the original expression (negative absorbed into denominator).
+ *
+ * @returns The positive shift coefficient and the denominator with the exponential stripped,
+ *          or undefined if no such factor is found.
+ */
+function extractExpShift(den, s) {
+    const elements = den.isProduct() ? den.elementsArray() : [den];
+    for (const el of elements) {
+        if (!el.isEXP()) {
+            continue;
+        }
+        const exponent = el.getPower();
+        if (!exponent.hasVariable(s)) {
+            continue;
+        }
+        // Check that the exponent is linear in s: exponent = a * s (no constant term, no higher powers)
+        const { constants: coefficient, expression: variable } = (0, products_1.constantsFreeProduct)(exponent, s);
+        if (!variable.eq(s)) {
+            continue;
+        }
+        if (coefficient.sign() <= 0) {
+            continue;
+        }
+        // Strip this factor from the denominator
+        const remainder = den.div(el);
+        return { coefficient, remainder };
+    }
+    return undefined;
+}

package/output/calculus/laplace/ilaplaceTable.d.ts

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

package/output/calculus/laplace/ilaplaceTable.js

@@ -0,0 +1,200 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tableOfInverseTransforms = void 0;
+const LookupTable_1 = require("../../core/classes/lookupTable/LookupTable");
+const Pattern_1 = require("../../core/converters/Pattern");
+const ilaplaceTable = {
+    // L^-1{a1/s^n1} = a1*t^(n1-1)/gamma(n1)
+    'a1/x1^n1': p => {
+        const { n1 } = p.references;
+        if (n1.isZero()) {
+            return undefined;
+        }
+        if (n1.isNegative()) {
+            return undefined;
+        }
+        return p.fromPattern('(a1*t^(n1-1))/gamma(n1)');
+    },
+    // Linear pole family:
+    // L^-1{ a1 / (a2*s + a3)^n2 } =
+    // a1 * t^(n2-1) * e^((-a3/a2)*t) / (a2^n2 * gamma(n2))
+    //
+    // Quadratic unshifted sine family:
+    // L^-1{ a1 / (a2*s^2 + a3) } =
+    // (a1/(a2^(1/2)*a3^(1/2))) * sin((a3^(1/2)*t)/(a2^(1/2)))
+    'a1/((a2*x1^n1+a3)^n2)': p => {
+        const { n1, n2 } = p.references;
+        if (n1.isOne()) {
+            return p.fromPattern('(a1*t^(n2-1)*e^((-a3/a2)*t))/(a2^n2*gamma(n2))');
+        }
+        if (n1.eq(2) && n2.isOne()) {
+            return p.fromPattern('(a1*sin((a3^(1/2)*t)/(a2^(1/2))))/(a2^(1/2)*a3^(1/2))');
+        }
+        if (n1.eq(2) && n2.eq(2)) {
+            return p
+                .fromPattern('(a1*sin((a3^(1/2)*t)/(a2^(1/2))))/(2*a2^(1/2)*a3^(3/2))')
+                .minus(p.fromPattern('(a1*t*cos((a3^(1/2)*t)/(a2^(1/2))))/(2*a2*a3)'));
+        }
+    },
+    // Cosine family:
+    // L^-1{ a1*s / (a2*s^2 + a3) } =
+    // (a1/a2) * cos((a3^(1/2)*t)/(a2^(1/2)))
+    //
+    // t*sin family:
+    // L^-1{ a1*s / (a2*s^2 + a3)^2 } =
+    // (a1*t*sin((a3^(1/2)*t)/(a2^(1/2)))) / (2*a2^(3/2)*a3^(1/2))
+    '(a1*x1^n1)/((a2*x1^n2+a3)^n3)': p => {
+        const { n1, n2, n3 } = p.references;
+        if (!n2.eq(2)) {
+            return undefined;
+        }
+        if (n1.isOne()) {
+            if (n3.isOne()) {
+                return p.fromPattern('(a1*cos((a3^(1/2)*t)/(a2^(1/2))))/a2');
+            }
+            if (n3.eq(2)) {
+                return p.fromPattern('(a1*t*sin((a3^(1/2)*t)/(a2^(1/2))))/(2*a2^(3/2)*a3^(1/2))');
+            }
+        }
+        if (n1.eq(2) && n3.eq(2)) {
+            return p
+                .fromPattern('(a1*sin((a3^(1/2)*t)/(a2^(1/2))))/(2*a2^(1/2)*a3^(1/2))')
+                .plus(p.fromPattern('(a1*t*cos((a3^(1/2)*t)/(a2^(1/2))))/(2*a2)'));
+        }
+    },
+    // Shifted sine family:
+    // L^-1{ a1 / (a2*(a3*s + a4)^2 + a5) } =
+    // a1*e^((-a4/a3)*t)*sin((a5^(1/2)*t)/(a2^(1/2)*a3)) / (a2^(1/2)*a3*a5^(1/2))
+    // 1 / (((s-b)^2 + c^2)^n) and 1 / (((s-b)^2 - c^2)^n)
+    'a1/((a2*(a3*x1^n1+a4)^n2+a5)^n3)': p => {
+        const { n1, n2, n3, a5 } = p.references;
+        if (!n1.isOne() || !n2.eq(2)) {
+            return undefined;
+        }
+        // Hyperbolic branch: a5 < 0
+        if (a5.sign() < 0) {
+            if (n3.isOne()) {
+                return p.fromPattern('(a1*e^((-a4/a3)*t)*sinh((((-a5)^(1/2))*t)/(a2^(1/2)*a3)))/(a2^(1/2)*a3*((-a5)^(1/2)))');
+            }
+            if (n3.eq(2)) {
+                return p.fromPattern('(a1*e^((-a4/a3)*t)*((((-a5)^(1/2))*t*cosh((((-a5)^(1/2))*t)/(a2^(1/2)*a3)))/(a2^(1/2)*a3)-sinh((((-a5)^(1/2))*t)/(a2^(1/2)*a3))))/(2*a2^(1/2)*a3*((-a5)^(3/2)))');
+            }
+            return undefined;
+        }
+        // Trig branch: a5 > 0
+        if (n3.isOne()) {
+            return p.fromPattern('(a1*e^((-a4/a3)*t)*sin((a5^(1/2)*t)/(a2^(1/2)*a3)))/(a2^(1/2)*a3*a5^(1/2))');
+        }
+        if (n3.eq(2)) {
+            return p.fromPattern('(a1*e^((-a4/a3)*t)*(sin((a5^(1/2)*t)/(a2^(1/2)*a3))-(a5^(1/2)*t*cos((a5^(1/2)*t)/(a2^(1/2)*a3)))/(a2^(1/2)*a3)))/(2*a2^(1/2)*a3*a5^(3/2))');
+        }
+        return undefined;
+    },
+    // Shifted cosine family:
+    // L^-1{ a1*(a3*s+a4) / (a2*(a3*s+a4)^2 + a5) } =
+    // a1*e^((-a4/a3)*t)*cos((a5^(1/2)*t)/(a2^(1/2)*a3)) / (a2*a3)
+    // (s-b) / (((s-b)^2 + c^2)^n) and (s-b) / (((s-b)^2 - c^2)^n)
+    // (c*(s-a)) / ((b*(d*(s-a))^2 + e)^n)
+    // (c*(s-a)) / ((b*(d*(s-a))^2 + e)^n)
+    '(a1*((a6*x1^n4+a7)^n5))/((a2*(a3*x1^n1+a4)^n2+a5)^n3)': p => {
+        const { n1, n2, n3, n4, n5, a3, a4, a5, a6, a7 } = p.references;
+        if (!n1.isOne() || !n2.eq(2) || !n4.isOne() || !n5.isOne()) {
+            return undefined;
+        }
+        // numerator affine term must be a scalar multiple of denominator affine term
+        if (!a7.times(a3).eq(a4.times(a6))) {
+            return undefined;
+        }
+        // Hyperbolic branch
+        if (a5.sign() < 0) {
+            if (n3.isOne()) {
+                return p.fromPattern('(a1*a6*e^((-a4/a3)*t)*cosh((((-a5)^(1/2))*t)/(a2^(1/2)*a3)))/(a2*a3^2)');
+            }
+            if (n3.eq(2)) {
+                return p.fromPattern('(a1*a6*t*e^((-a4/a3)*t)*sinh((((-a5)^(1/2))*t)/(a2^(1/2)*a3)))/(2*a2^(3/2)*a3^3*((-a5)^(1/2)))');
+            }
+            return undefined;
+        }
+        // Trigonometric branch
+        if (n3.isOne()) {
+            return p.fromPattern('(a1*a6*e^((-a4/a3)*t)*cos((a5^(1/2)*t)/(a2^(1/2)*a3)))/(a2*a3^2)');
+        }
+        if (n3.eq(2)) {
+            return p.fromPattern('(a1*a6*t*e^((-a4/a3)*t)*sin((a5^(1/2)*t)/(a2^(1/2)*a3)))/(2*a2^(3/2)*a3^3*a5^(1/2))');
+        }
+        return undefined;
+    },
+    // ((c*(s-a))^2) / ((b*(d*(s-a))^2 + e)^2)
+    '(a1*(a6*x1^n4+a7)^n5)/((a2*(a3*x1^n1+a4)^n2+a5)^n3)': p => {
+        const { n1, n2, n3, n4, n5, a3, a4, a5, a6, a7 } = p.references;
+        if (!n1.isOne() || !n2.eq(2) || !n3.eq(2) || !n4.isOne() || !n5.eq(2)) {
+            return undefined;
+        }
+        // numerator affine term must be a scalar multiple of denominator affine term
+        if (!a7.times(a3).eq(a4.times(a6))) {
+            return undefined;
+        }
+        // Hyperbolic branch
+        if (a5.sign() < 0) {
+            return p.fromPattern('(a1*a6^2*e^((-a4/a3)*t)*(sinh((((-a5)^(1/2))*t)/(a2^(1/2)*a3))+(((-a5)^(1/2))*t*cosh((((-a5)^(1/2))*t)/(a2^(1/2)*a3)))/(a2^(1/2)*a3)))/(2*a2^(3/2)*a3^3*((-a5)^(1/2)))');
+        }
+        // Trigonometric branch
+        return p.fromPattern('(a1*a6^2*e^((-a4/a3)*t)*(sin((a5^(1/2)*t)/(a2^(1/2)*a3))+(a5^(1/2)*t*cos((a5^(1/2)*t)/(a2^(1/2)*a3)))/(a2^(1/2)*a3)))/(2*a2^(3/2)*a3^3*a5^(1/2))');
+    },
+    // a / ((s-b)^2 - c^2)
+    'a1/(a2*(a3*x1^n1+a4)^n2-a5)': p => {
+        const { n1, n2 } = p.references;
+        if (!n1.isOne() || !n2.eq(2)) {
+            return undefined;
+        }
+        return p.fromPattern('(a1*e^((-a4/a3)*t)*sinh((a5^(1/2)*t)/(a2^(1/2)*a3)))/(a2^(1/2)*a3*a5^(1/2))');
+    },
+    // (s-b) / ((s-b)^2 - c^2)
+    '(a1*(a6*x1^n3+a7)^n4)/(a2*(a3*x1^n1+a4)^n2-a5)': p => {
+        const { n1, n2, n3, n4 } = p.references;
+        if (!n1.isOne() || !n2.eq(2) || !n3.isOne() || !n4.isOne()) {
+            return undefined;
+        }
+        return p.fromPattern('(a1*e^((-a4/a3)*t)*cosh((a5^(1/2)*t)/(a2^(1/2)*a3)))/(a2*a3^2)');
+    },
+    // a / (((s-b)^2 - c^2)^2)
+    'a1/((a2*(a3*x1^n1+a4)^n2-a5)^n3)': p => {
+        const { n1, n2, n3 } = p.references;
+        if (!n1.isOne() || !n2.eq(2) || !n3.eq(2)) {
+            return undefined;
+        }
+        return p.fromPattern('(a1*e^((-a4/a3)*t)*(a5^(1/2)*t*cosh((a5^(1/2)*t)/(a2^(1/2)*a3))-a2^(1/2)*a3*sinh((a5^(1/2)*t)/(a2^(1/2)*a3))))/(2*a2*a3^2*a5^(3/2))');
+    },
+    // (s-b) / (((s-b)^2 - c^2)^2)
+    '(a1*(a6*x1^n3+a7)^n4)/((a2*(a3*x1^n1+a4)^n2-a5)^n5)': p => {
+        const { n1, n2, n3, n4, n5 } = p.references;
+        if (!n1.isOne() || !n2.eq(2) || !n3.isOne() || !n4.isOne() || !n5.eq(2)) {
+            return undefined;
+        }
+        return p.fromPattern('(a1*t*e^((-a4/a3)*t)*sinh((a5^(1/2)*t)/(a2^(1/2)*a3)))/(2*a2^(1/2)*a3*a5^(1/2))');
+    },
+    // (A*(B*(s-a)^2+C)) / ((D*(s-a)^2+E)^2)
+    '(a1*((a2*(a3*x1^n1+a4)^n2+a5)^n3))/((a6*(a7*x1^n4+a8)^n5+a9)^n6)': p => {
+        const { n1, n2, n3, n4, n5, n6, _a2, a3, a4, _a6, a7, a8, _a9 } = p.references;
+        if (!n1.isOne() || !n2.eq(2) || !n3.isOne() || !n4.isOne() || !n5.eq(2) || !n6.eq(2)) {
+            return undefined;
+        }
+        if (!a3.eq(a7) || !a4.eq(a8)) {
+            return undefined;
+        }
+        const v = p.get('x1').text();
+        const expr1 = p.fromPattern('1/(a6*(a7*x1^n4+a8)^n5+a9)');
+        const expr2 = p.fromPattern('1/((a6*(a7*x1^n4+a8)^n5+a9)^2)');
+        const T1 = exports.tableOfInverseTransforms.lookup(new Pattern_1.Pattern(expr1, [v]), 0);
+        const T2 = exports.tableOfInverseTransforms.lookup(new Pattern_1.Pattern(expr2, [v]), 0);
+        if (!T1 || !T2) {
+            return undefined;
+        }
+        return p
+            .fromPattern('(a1*a2)/a6')
+            .times(T1)
+            .plus(p.fromPattern('a1*(a5-(a2*a9)/a6)').times(T2));
+    },
+};
+exports.tableOfInverseTransforms = new LookupTable_1.LookupTable();
+exports.tableOfInverseTransforms.addEntries(ilaplaceTable);

package/output/calculus/laplace/laplace.d.ts

@@ -0,0 +1,22 @@
+import { Expression } from '../../core/classes/expression/Expression';
+import type { ExpressionInput } from '../../core/types';
+/**
+ * Computes a symbolic Laplace transform from a time variable to a transform variable.
+ *
+ * The expression is expanded, linear sums are transformed term by term,
+ * constants independent of the time variable are extracted, and the remaining
+ * expression is matched against the transform table.
+ *
+ * @param expr - Time-domain expression.
+ * @param t - Plain time-domain variable.
+ * @param s - Plain transform-domain variable.
+ * @returns The symbolic transform, or an unevaluated `laplace(expr, t, s)`
+ * Expression when no table rule resolves the input.
+ * @throws {@link core!UnexpectedInputError} If `t` or `s` is not a plain variable.
+ *
+ * @example
+ * ```ts
+ * laplace('sin(t)', 't', 's').text();
+ * ```
+ */
+export declare function laplace(expr: ExpressionInput, t: ExpressionInput, s: ExpressionInput): Expression;