nerdamer 1.1.13 → 2.0.0-rc.1

package/output/calculus/laplace/laplace.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.laplace = laplace;
+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 Pattern_1 = require("../../core/converters/Pattern");
+const laplaceTable_1 = require("./laplaceTable");
+/**
+ * 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();
+ * ```
+ */
+function laplace(expr, t, s) {
+    expr = Expression_1.Expression.create(expr).expand();
+    s = (0, utils_1.assertPlainVariableAndGetString)(Expression_1.Expression.create(s));
+    t = (0, utils_1.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 = laplace(e, t, s);
+            // Any unevaluated laplace(...) means this branch failed
+            if (transform.isFunction(constants_1.LAPLACE)) {
+                retval = undefined;
+                break;
+            }
+            retval = retval.plus(transform);
+        }
+        if (retval) {
+            return retval;
+        }
+    }
+    // Pull out constants from products
+    if (expr.isProduct()) {
+        // let constants: Expression;
+        // let expression: Expression;
+        const { constants, expression } = (0, products_1.constantsFreeProduct)(expr, t);
+        // Only worthwhile if something was actually extracted
+        if (!constants.isOne()) {
+            const transform = laplace(expression, t, s);
+            if (!transform.isFunction(constants_1.LAPLACE)) {
+                return constants.times(transform);
+            }
+        }
+    }
+    // Pattern writes a negative exponential power as a reciprocal, while the transform table
+    // stores exponential factors with their signed rate in the exponent. Apply the frequency
+    // shift directly so the remainder can use the existing table instead of duplicating rules.
+    const factors = expr.isProduct() ? expr.elementsArray() : [expr];
+    for (let i = 0; i < factors.length; i++) {
+        const factor = factors[i];
+        if (!factor.isEXP()) {
+            continue;
+        }
+        const base = factor.getBase();
+        const exponent = factor.getPower();
+        if (base.hasVariable(t) || !exponent.isPolynomialLike()) {
+            continue;
+        }
+        const coefficients = exponent.coeffs(t).toArray();
+        if (coefficients.length !== 2 || !coefficients[0].isZero()) {
+            continue;
+        }
+        const rate = coefficients[1];
+        if (rate.sign() !== -1) {
+            continue;
+        }
+        let remainder = (0, shortcuts_1.one)();
+        for (let j = 0; j < factors.length; j++) {
+            if (j !== i) {
+                remainder = remainder.times(factors[j]);
+            }
+        }
+        const transform = laplace(remainder, t, s);
+        if (!transform.isFunction(constants_1.LAPLACE)) {
+            const baseLog = base.isE() ? (0, shortcuts_1.one)() : Expression_1.Expression.toFunction(constants_1.LOG, [base]);
+            const shiftedVariable = Expression_1.Expression.Variable(s).minus(rate.copy().times(baseLog));
+            return transform.subst(s, shiftedVariable);
+        }
+    }
+    // Base/derived table lookup
+    retval = laplaceTable_1.tableOfTransforms.lookup(new Pattern_1.Pattern(expr, [t]), 0);
+    if (retval) {
+        if (s !== 's') {
+            retval = retval.evaluate({ s });
+        }
+        return retval;
+    }
+    return Expression_1.Expression.toFunction(constants_1.LAPLACE, [expr, t, s]);
+}

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

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

package/output/calculus/laplace/laplaceTable.js

@@ -0,0 +1,187 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tableOfTransforms = void 0;
+const LookupTable_1 = require("../../core/classes/lookupTable/LookupTable");
+const diff_1 = require("../derivative/diff");
+const laplaceTable = {
+    // L{a1}
+    a1: (p, _depth) => {
+        return p.fromPattern('a1/s');
+    },
+    // L{a1*t^n1}
+    'a1*x1^n1': p => {
+        const { n1 } = p.references;
+        // Reject Gamma poles: n1 = -1, -2, -3, ...
+        if (n1.isNegative() && n1.plus(1).isInteger()) {
+            return undefined;
+        }
+        return p.fromPattern('a1*gamma(n1+1)/s^(n1+1)');
+    },
+    // L{a1*(a2)^(a3*x1)}
+    'a1*(a2)^(a3*x1^n1)': p => {
+        if (!p.get('n1').isOne()) {
+            return undefined;
+        }
+        // a^(b t) = e^(log(a) b t)
+        return p.fromPattern('a1/(s-log(a2)*a3)');
+    },
+    // L{a1*sin(a2*x1)}
+    'a1*sin(a2*x1^n1)^n2': p => {
+        if (!p.get('n1').isOne() || !p.get('n2').isOne()) {
+            return undefined;
+        }
+        return p.fromPattern('(a1*a2)/(s^2+a2^2)');
+    },
+    // L{a1*cos(a2*x1)}
+    'a1*cos(a2*x1^n1)^n2': p => {
+        if (!p.get('n1').isOne() || !p.get('n2').isOne()) {
+            return undefined;
+        }
+        return p.fromPattern('(a1*s)/(s^2+a2^2)');
+    },
+    'a1*(a2)^(a3*x1^n1)*x1^n2': p => {
+        const { n1, n2 } = p.references;
+        if (!n1.isOne()) {
+            return undefined;
+        }
+        // Reject the pole at Gamma(0), Gamma(-1), ...
+        if (n2.isNegative() && n2.plus(1).isInteger()) {
+            return undefined;
+        }
+        return p.fromPattern('a1*gamma(n2+1)/(s-log(a2)*a3)^(n2+1)');
+    },
+    'a1*x1^n1*sin(a2*x1^n2)^n3': p => {
+        const { _a1, n1, n2, n3, _a2 } = p.references;
+        if (!n2.isOne() || !n3.isOne()) {
+            return undefined;
+        }
+        if (!n1.isInteger() || n1.isNegative()) {
+            return undefined;
+        }
+        const n = Number(n1.getMultiplier().numerator);
+        let result = p.fromPattern('(a1*a2)/(s^2+a2^2)');
+        for (let i = 0; i < n; i++) {
+            result = (0, diff_1.diff)(result, 's').neg();
+        }
+        return result;
+    },
+    'a1*x1^n1*cos(a2*x1^n2)^n3': p => {
+        const { _a1, n1, n2, n3, _a2 } = p.references;
+        if (!n2.isOne() || !n3.isOne()) {
+            return undefined;
+        }
+        if (!n1.isInteger() || n1.isNegative()) {
+            return undefined;
+        }
+        const n = Number(n1.getMultiplier().numerator);
+        let result = p.fromPattern('(a1*s)/(s^2+a2^2)');
+        for (let i = 0; i < n; i++) {
+            result = (0, diff_1.diff)(result, 's').neg();
+        }
+        return result;
+    },
+    'a1*(a2)^(a3*x1^n1)*sin(a4*x1^n2)^n3': p => {
+        const { n1, n2, n3 } = p.references;
+        if (!n1.isOne() || !n2.isOne() || !n3.isOne()) {
+            return undefined;
+        }
+        return p.fromPattern('(a1*a4)/((s-log(a2)*a3)^2+a4^2)');
+    },
+    'a1*(a2)^(a3*x1^n1)*cos(a4*x1^n2)^n3': p => {
+        const { n1, n2, n3 } = p.references;
+        if (!n1.isOne() || !n2.isOne() || !n3.isOne()) {
+            return undefined;
+        }
+        return p.fromPattern('a1*(s-log(a2)*a3)/((s-log(a2)*a3)^2+a4^2)');
+    },
+    'a1*cos(a2*x1^n1)^n2*sin(a3*x1^n3)^n4': p => {
+        const { _a1, a2, a3, n1, n2, n3, n4 } = p.references;
+        if (!n1.isOne() || !n2.isOne() || !n3.isOne() || !n4.isOne()) {
+            return undefined;
+        }
+        if (!a2.eq(a3)) {
+            return undefined;
+        }
+        return p.fromPattern('(a1*a2)/(s^2+4*a2^2)');
+    },
+    'a1*(a2)^(a3*x1^n1)*x1^n2*sin(a4*x1^n3)^n4': p => {
+        const { n1, n2, n3, n4 } = p.references;
+        if (!n1.isOne() || !n2.isOne() || !n3.isOne() || !n4.isOne()) {
+            return undefined;
+        }
+        return p.fromPattern('(2*a1*a4*(s-a3*log(a2)))/((a4^2+(s-a3*log(a2))^2)^2)');
+    },
+    'a1*(a2)^(a3*x1^n1)*x1^n2*cos(a4*x1^n3)^n4': p => {
+        const { n1, n2, n3, n4 } = p.references;
+        if (!n1.isOne() || !n2.isOne() || !n3.isOne() || !n4.isOne()) {
+            return undefined;
+        }
+        return p.fromPattern('(a1*((s-a3*log(a2))^2-a4^2))/((a4^2+(s-a3*log(a2))^2)^2)');
+    },
+    'a1*(a2)^(a3*x1^n1)*(a4*sin(a5*x1^n2)^n3-a6*x1^n4*cos(a7*x1^n5)^n6)^n7': p => {
+        const { n1, n2, n3, n4, n5, n6, n7, a5, a7 } = p.references;
+        if (!n1.isOne() ||
+            !n2.isOne() ||
+            !n3.isOne() ||
+            !n4.isOne() ||
+            !n5.isOne() ||
+            !n6.isOne() ||
+            !n7.isOne()) {
+            return undefined;
+        }
+        if (!a5.eq(a7)) {
+            return undefined;
+        }
+        return p.fromPattern('(a1*(a4*a5^2-a6*((s-a3*log(a2))^2-a5^2)))/(((s-a3*log(a2))^2+a5^2)^2)');
+    },
+    'a1*(a2)^(a3*x1^n1)*(a4*sin(a5*x1^n2)^n3+a6*x1^n4*cos(a7*x1^n5)^n6)^n7': p => {
+        const { n1, n2, n3, n4, n5, n6, n7, a5, a7 } = p.references;
+        if (!n1.isOne() ||
+            !n2.isOne() ||
+            !n3.isOne() ||
+            !n4.isOne() ||
+            !n5.isOne() ||
+            !n6.isOne() ||
+            !n7.isOne()) {
+            return undefined;
+        }
+        if (!a5.eq(a7)) {
+            return undefined;
+        }
+        return p.fromPattern('(a1*(a4*a5^2+a6*((s-a3*log(a2))^2-a5^2)))/(((s-a3*log(a2))^2+a5^2)^2)');
+    },
+    // e^(a t) sinh(b t)
+    'a1*(a2)^(a3*x1^n1)*sinh(a4*x1^n2)^n3': p => {
+        const { n1, n2, n3 } = p.references;
+        if (!n1.isOne() || !n2.isOne() || !n3.isOne()) {
+            return undefined;
+        }
+        return p.fromPattern('(a1*a4)/((s-a3*log(a2))^2-a4^2)');
+    },
+    // e^(a t) cosh(b t)
+    'a1*(a2)^(a3*x1^n1)*cosh(a4*x1^n2)^n3': p => {
+        const { n1, n2, n3 } = p.references;
+        if (!n1.isOne() || !n2.isOne() || !n3.isOne()) {
+            return undefined;
+        }
+        return p.fromPattern('(a1*(s-a3*log(a2)))/((s-a3*log(a2))^2-a4^2)');
+    },
+    // t*e^(a t) sinh(b t)
+    'a1*(a2)^(a3*x1^n1)*x1^n2*sinh(a4*x1^n3)^n4': p => {
+        const { n1, n2, n3, n4 } = p.references;
+        if (!n1.isOne() || !n2.isOne() || !n3.isOne() || !n4.isOne()) {
+            return undefined;
+        }
+        return p.fromPattern('(2*a1*a4*(s-a3*log(a2)))/(((s-a3*log(a2))^2-a4^2)^2)');
+    },
+    // t*e^(a t) cosh(b t)
+    'a1*(a2)^(a3*x1^n1)*x1^n2*cosh(a4*x1^n3)^n4': p => {
+        const { n1, n2, n3, n4 } = p.references;
+        if (!n1.isOne() || !n2.isOne() || !n3.isOne() || !n4.isOne()) {
+            return undefined;
+        }
+        return p.fromPattern('(a1*((s-a3*log(a2))^2+a4^2))/(((s-a3*log(a2))^2-a4^2)^2)');
+    },
+};
+exports.tableOfTransforms = new LookupTable_1.LookupTable();
+exports.tableOfTransforms.addEntries(laplaceTable);

package/output/calculus/limit/limit.d.ts

@@ -0,0 +1,35 @@
+import { Expression } from '../../core/classes/expression/Expression';
+import type { ExpressionInput } from '../../core/types';
+/** Direction from which the independent variable approaches a finite point. */
+export type LimitDir = 'both' | 'left' | 'right';
+/**
+ * Computes a symbolic finite or infinite limit.
+ *
+ * The implementation combines direct substitution, side-aware pole analysis,
+ * simplification, bounded L'Hopital recursion, indeterminate-form rewrites,
+ * composition rules, dominant-growth analysis at infinity, and a table of
+ * known limits.
+ *
+ * @remarks
+ * `'left'` and `'right'` request one-sided limits; `'both'` is the default
+ * two-sided direction. Direction is significant for poles and piecewise
+ * functions such as `sign`. When the available strategies cannot establish a
+ * result, the function returns an unevaluated `limit(expr, x, val, dir)`
+ * Expression. That form can therefore mean unsupported, undefined, or
+ * non-existent; it is not a proof that a limit exists.
+ *
+ * The implementation primarily reasons about real signs and real growth.
+ * Oscillatory and branch-sensitive complex cases are intentionally left
+ * symbolic unless a specific rule resolves them. Decimal input is preserved in
+ * the formatting of a resolved result.
+ *
+ * `depth` is an internal recursion counter and should normally be omitted.
+ *
+ * @param expr - Expression whose limit is sought.
+ * @param x - Independent variable.
+ * @param val - Finite value or positive/negative infinity to approach.
+ * @param dir - Two-sided, left-sided, or right-sided approach.
+ * @param depth - Internal recursion depth. Defaults to zero.
+ * @returns The resolved limit or an unevaluated `limit(...)` Expression.
+ */
+export declare function limit(expr: ExpressionInput, x: ExpressionInput, val: ExpressionInput, dir?: LimitDir, depth?: number): Expression;