nerdamer 1.1.13 → 2.0.0-rc.1

package/output/algebra/simplify/invtrigrewrite.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasDerivedInverseTrig = hasDerivedInverseTrig;
+exports.rewriteInverseTrig = rewriteInverseTrig;
+const Expression_1 = require("../../core/classes/expression/Expression");
+const shortcuts_1 = require("../../core/classes/expression/shortcuts");
+const constants_1 = require("../../core/classes/parser/constants");
+/**
+ * Determines whether an expression contains any asec, acsc, or acot functions.
+ */
+function hasDerivedInverseTrig(x) {
+    let found = false;
+    x.forEveryElement(e => {
+        if (e.isFunction(constants_1.ASEC) || e.isFunction(constants_1.ACSC) || e.isFunction(constants_1.ACOT)) {
+            found = true;
+        }
+        return e;
+    });
+    return found;
+}
+/**
+ * Rewrites a single inverse trig element to its primary form.
+ *
+ *   asec(u)^n  →  acos(1/u)^n
+ *   acsc(u)^n  →  asin(1/u)^n
+ *   acot(u)^n  →  atan(1/u)^n
+ *
+ * Multiplier and power are preserved.
+ */
+function rewriteInverseTrigElement(e) {
+    const m = e.getMultiplier();
+    const p = e.getPower();
+    const args = e.getArguments();
+    if (e.isFunction(constants_1.ASEC) && args.length > 0) {
+        const u = args[0];
+        // asec(u) = acos(1/u)
+        const rewritten = Expression_1.Expression.create(`acos(x)`, { x: (0, shortcuts_1.one)().div(u) });
+        return Expression_1.Expression.fromRational(m).times(rewritten.pow(p));
+    }
+    if (e.isFunction(constants_1.ACSC) && args.length > 0) {
+        const u = args[0];
+        // acsc(u) = asin(1/u)
+        const rewritten = Expression_1.Expression.create(`asin(x)`, { x: (0, shortcuts_1.one)().div(u) });
+        return Expression_1.Expression.fromRational(m).times(rewritten.pow(p));
+    }
+    if (e.isFunction(constants_1.ACOT) && args.length > 0) {
+        const u = args[0];
+        // acot(u) = atan(1/u)
+        const rewritten = Expression_1.Expression.create(`atan(x)`, { x: (0, shortcuts_1.one)().div(u) });
+        return Expression_1.Expression.fromRational(m).times(rewritten.pow(p));
+    }
+    return e;
+}
+/**
+ * Recursively rewrites all asec, acsc, acot in an expression tree to acos, asin, atan.
+ * Descends into sums, products, and function arguments.
+ */
+function rewriteInverseTrig(x) {
+    // Direct derived inverse trig function
+    if (x.isFunction(constants_1.ASEC) || x.isFunction(constants_1.ACSC) || x.isFunction(constants_1.ACOT)) {
+        return rewriteInverseTrigElement(x);
+    }
+    // For sums: rewrite each term
+    if (x.isSum()) {
+        const m = x.getMultiplier();
+        const p = x.getPower();
+        let result = (0, shortcuts_1.zero)();
+        for (const term of x.elementsArray()) {
+            result = result.plus(rewriteInverseTrig(term));
+        }
+        if (!p.isOne()) {
+            result = result.pow(p);
+        }
+        if (!m.isOne()) {
+            result = result.times(Expression_1.Expression.fromRational(m));
+        }
+        return result;
+    }
+    // For products: rewrite each factor
+    if (x.isProduct()) {
+        const m = x.getMultiplier();
+        const p = x.getPower();
+        let result = (0, shortcuts_1.one)();
+        for (const element of x.elementsArray()) {
+            result = result.times(rewriteInverseTrig(element));
+        }
+        if (!p.isOne()) {
+            result = result.pow(p);
+        }
+        if (!m.isOne()) {
+            result = result.times(Expression_1.Expression.fromRational(m));
+        }
+        return result;
+    }
+    return x;
+}

package/output/algebra/simplify/ratsimp.d.ts

@@ -0,0 +1,21 @@
+import { Expression } from '../../core/classes/expression/Expression';
+import { toCommonDenominator } from '../../core/functions/rationalNormalization';
+export { toCommonDenominator };
+/**
+ * Simplifies the expression through rationalizing
+ * @param x
+ * @returns
+ */
+export declare function rationalize(x: Expression): Expression;
+/**
+ * Attempts to simplify radicals in the expression. Convert 2/√2 to √2.
+ * @param x
+ * @returns
+ */
+export declare function simplifyRadicals(x: Expression): Expression;
+/**
+ * Eliminates common factors from the numerator and denominators give that they're two polynomials
+ * @param x
+ * @returns
+ */
+export declare function cancelCommonFactors(x: Expression): Expression;

package/output/algebra/simplify/ratsimp.js

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toCommonDenominator = void 0;
+exports.rationalize = rationalize;
+exports.simplifyRadicals = simplifyRadicals;
+exports.cancelCommonFactors = cancelCommonFactors;
+const Expression_1 = require("../../core/classes/expression/Expression");
+const shortcuts_1 = require("../../core/classes/expression/shortcuts");
+const Polynomial_1 = require("../../core/classes/polynomial/Polynomial");
+const utils_1 = require("../../core/classes/polynomial/utils");
+const rationalNormalization_1 = require("../../core/functions/rationalNormalization");
+Object.defineProperty(exports, "toCommonDenominator", { enumerable: true, get: function () { return rationalNormalization_1.toCommonDenominator; } });
+const subst_1 = require("../../core/functions/subst");
+const factor_1 = require("../factor/factor");
+/**
+ * Simplifies the expression through rationalizing
+ * @param x
+ * @returns
+ */
+function rationalize(x) {
+    const num = x.getNumerator();
+    const den = x.getDenominator();
+    // Nothing to do if the denominator is one
+    // Nothing to do if the power in the denominator is 1
+    if (den.isOne() || (!den.isProduct() && den.isLinear())) {
+        return x;
+    }
+    const q = den.getPower();
+    const f = den.toLinearAndUnitMultiplier();
+    const retval = num.div(f.times(den.getMultiplier())).times(f.pow((0, shortcuts_1.one)().minus(q)));
+    return retval;
+}
+/**
+ * Attempts to simplify radicals in the expression. Convert 2/√2 to √2.
+ * @param x
+ * @returns
+ */
+function simplifyRadicals(x) {
+    // This function only works if it's a product
+    if (!x.isProduct()) {
+        return x;
+    }
+    const m = x.getMultiplier();
+    const p = x.getPower();
+    let retval = (0, shortcuts_1.one)();
+    const linearized = x.toLinearAndUnitMultiplier();
+    const linearMultiplier = linearized.getMultiplier();
+    const elements = linearized.elementsArray().map(e => {
+        // Only rationalize if it actually has a radical (fractional power)
+        if (e.hasRadical()) {
+            return rationalize(e);
+        }
+        return e;
+    });
+    // The array of indices that have already been used
+    const seen = [];
+    for (let i = 0; i < elements.length; i++) {
+        // Nothing to do if it's already been multiplied out
+        if (seen.includes(i)) {
+            continue;
+        }
+        let a = elements[i];
+        const p = a.getPower();
+        for (let j = i + 1; j < elements.length; j++) {
+            const b = elements[j];
+            if (p.eq(b.getPower())) {
+                // Powers are stored directly on several expression node types. Extracting
+                // the base through the common Expression API avoids assuming an EXP node
+                // or a function wrapper for symbolic radicals.
+                const u = a.toLinearAndUnitMultiplier();
+                const v = b.toLinearAndUnitMultiplier();
+                // Principal radicals can be combined when both radicands are known nonnegative.
+                // Reciprocals still require a strictly signed base because a zero denominator
+                // cannot be admitted by the sign proof for a negative power.
+                if (!u.isComplex() && !v.isComplex() && u.gte(0) && v.gte(0)) {
+                    const multiplier = a.getMultiplier().times(b.getMultiplier());
+                    if (u.isNUM() && v.isNUM()) {
+                        // Preserve exact numeric reduction when the combined radicand is numeric.
+                        a = u.times(v).pow(p).times(multiplier);
+                    }
+                    else {
+                        // Set the outer power directly so the normal power operation does not
+                        // distribute it back across the known-positive product.
+                        a = Expression_1.Expression.setPower(u.times(v), p).times(multiplier);
+                    }
+                    seen.push(j);
+                }
+            }
+        }
+        retval = retval.times(a);
+    }
+    return retval.pow(p).times(m).times(linearMultiplier);
+}
+/**
+ * Eliminates common factors from the numerator and denominators give that they're two polynomials
+ * @param x
+ * @returns
+ */
+function cancelCommonFactors(x) {
+    if (!x.isProduct() || !x.isLinear()) {
+        return x;
+    }
+    let retval = x;
+    const [radFree, radicalSubs] = (0, subst_1.subRadicals)(x);
+    // Mathematical constants need the same temporary variable treatment as radicals
+    // before entering the exact polynomial layer. Restore both substitution sets below.
+    const [polynomialReady, subs] = (0, subst_1.uSubConstants)(radFree, radicalSubs);
+    let num = polynomialReady.getNumerator();
+    let den = polynomialReady.getDenominator();
+    function reduce(a, b) {
+        const f = new Polynomial_1.Polynomial(a);
+        // Factor both
+        for (const e of (0, factor_1.polyFactorExpressions)(b)) {
+            // Don't risk entering Q by dividing by a constant
+            if (e.isNUM()) {
+                continue;
+            }
+            const g = new Polynomial_1.Polynomial(e);
+            const [q, r] = (0, utils_1.divide)(f, g);
+            if (r.isZero()) {
+                // Update the numerator with the new values
+                a = q;
+                // Update the denominator
+                const [q2, _r2] = (0, utils_1.divide)(b, g);
+                b = q2;
+            }
+        }
+        return [a, b];
+    }
+    if (num.isPolynomialLike() && den.isPolynomialLike()) {
+        // Reduce the numerator by the denominator
+        [num, den] = reduce(num, den);
+        // Reduce the denominator by the numerator
+        [den, num] = reduce(den, num);
+        // Return the quotient
+        retval = num.div(den);
+    }
+    // First try to reduce the denominator
+    return (0, subst_1.uUnSub)(retval, subs);
+}

package/output/algebra/simplify/simplify.d.ts

@@ -0,0 +1,25 @@
+import { Expression } from '../../core/classes/expression/Expression';
+/**
+ * Applies Nerdamer's finite symbolic simplification strategy to an expression.
+ *
+ * @remarks
+ * Simplification first normalizes rational structure, recursively simplifies function
+ * arguments, and then selects targeted transformations for factorial ratios, complex
+ * forms, irrational denominators, sums, or linear products. The final numerator and
+ * denominator are factored. This is a heuristic transformation pipeline rather than a
+ * proof of globally minimal form, and branch-sensitive identities are limited to the
+ * safeguards implemented by the selected rewrite routines.
+ *
+ * Intermediate expressions may be reused while the pipeline runs, but callers should
+ * treat the return value as the simplified result rather than expecting `x` to be updated
+ * in place. Decimal-origin formatting is propagated to the result's outer multiplier.
+ * The `modifiers` object is internal recursion state; its `image` value prevents another
+ * simplification round when the canonical text has stopped changing.
+ *
+ * @param x - Expression or parser text to simplify.
+ * @param modifiers - Internal recursion markers used to detect an unchanged image.
+ * @returns The simplified expression, which may retain forms unsupported by the finite strategy set.
+ */
+export declare function simplify(x: Expression | string, modifiers?: {
+    [name: string]: string;
+}): Expression;

package/output/algebra/simplify/simplify.js

@@ -0,0 +1,228 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.simplify = simplify;
+const Expression_1 = require("../../core/classes/expression/Expression");
+const shortcuts_1 = require("../../core/classes/expression/shortcuts");
+const utils_1 = require("../../math/utils");
+const factor_1 = require("../factor/factor");
+const complexsimp_1 = require("./complexsimp");
+const factorCommon_1 = require("./factorCommon");
+const funcsimp_1 = require("./funcsimp");
+const invtrigrewrite_1 = require("./invtrigrewrite");
+const ratsimp_1 = require("./ratsimp");
+const trigrewrite_1 = require("./trigrewrite");
+const trigsimp_1 = require("./trigsimp");
+const utils_2 = require("./utils");
+/**
+ * Applies Nerdamer's finite symbolic simplification strategy to an expression.
+ *
+ * @remarks
+ * Simplification first normalizes rational structure, recursively simplifies function
+ * arguments, and then selects targeted transformations for factorial ratios, complex
+ * forms, irrational denominators, sums, or linear products. The final numerator and
+ * denominator are factored. This is a heuristic transformation pipeline rather than a
+ * proof of globally minimal form, and branch-sensitive identities are limited to the
+ * safeguards implemented by the selected rewrite routines.
+ *
+ * Intermediate expressions may be reused while the pipeline runs, but callers should
+ * treat the return value as the simplified result rather than expecting `x` to be updated
+ * in place. Decimal-origin formatting is propagated to the result's outer multiplier.
+ * The `modifiers` object is internal recursion state; its `image` value prevents another
+ * simplification round when the canonical text has stopped changing.
+ *
+ * @param x - Expression or parser text to simplify.
+ * @param modifiers - Internal recursion markers used to detect an unchanged image.
+ * @returns The simplified expression, which may retain forms unsupported by the finite strategy set.
+ */
+function simplify(x, modifiers = {}) {
+    if (typeof x === 'string') {
+        x = Expression_1.Expression.create(x);
+    }
+    const asDecimal = x.hasDecimal();
+    if ((0, invtrigrewrite_1.hasDerivedInverseTrig)(x)) {
+        x = (0, invtrigrewrite_1.rewriteInverseTrig)(x);
+    }
+    x = (0, ratsimp_1.toCommonDenominator)(x);
+    x = x.getNumerator().expand().div(x.getDenominator().expand());
+    // No changes from last round — nothing left to do
+    let retval = x;
+    const unchanged = modifiers.image === x.text();
+    if (!unchanged) {
+        retval = simplifyArguments(retval);
+        // Early factorial simplification for bare factorial ratios
+        if (retval.isProduct() && (0, utils_2.hasFactorialRatio)(retval)) {
+            retval = (0, funcsimp_1.simplifyFactorials)(retval);
+        }
+        // Only enter the main simplification if factorials didn't fully resolve,
+        // or the expression wasn't a factorial ratio to begin with
+        if ((0, utils_2.hasFactorialRatio)(retval) || !x.isProduct() || !(0, utils_2.hasFactorialRatio)(x)) {
+            if (x.isComplex()) {
+                retval = (0, complexsimp_1.complexSimplify)(retval);
+            }
+            else if ((0, utils_2.hasIrrationalDenominator)(retval)) {
+                retval = (0, ratsimp_1.rationalize)(retval);
+            }
+            else if (retval.isSum()) {
+                retval = (0, trigrewrite_1.tryRewriteTrig)(retval);
+                retval = (0, trigsimp_1.simplifyTrigSum)(retval);
+                retval = (0, factorCommon_1.factorCommonPower)(retval);
+                retval = (0, funcsimp_1.simplifyLogs)(retval);
+            }
+            else if (retval.isProduct() && retval.isLinear()) {
+                retval = (0, funcsimp_1.simplifyFactorials)(retval);
+                retval = (0, ratsimp_1.simplifyRadicals)(retval);
+                retval = cancelNestedFactors(retval);
+                retval = (0, ratsimp_1.cancelCommonFactors)(retval);
+                retval = (0, trigrewrite_1.tryRewriteTrig)(retval);
+            }
+        }
+    }
+    retval = factorResult(retval);
+    if (asDecimal) {
+        retval.getMultiplier().asDecimal = true;
+    }
+    return retval;
+}
+function simplifyArguments(x) {
+    let retval = undefined;
+    const m = x.getMultiplier();
+    const p = x.getPower();
+    if (x.isFunction()) {
+        retval = Expression_1.Expression.toFunction(x.name, x.getArguments().map(e => simplify(e)));
+    }
+    else if (x.isProduct()) {
+        retval = (0, shortcuts_1.one)();
+        for (const element of x.elementsArray()) {
+            const simplified = simplifyArguments(element);
+            retval = retval.times(simplified);
+        }
+    }
+    else if (x.isSum()) {
+        retval = (0, shortcuts_1.zero)();
+        for (const element of x.elementsArray()) {
+            retval = retval.plus(simplifyArguments(element));
+        }
+    }
+    if (retval) {
+        retval = retval.pow(p).times(m);
+    }
+    else {
+        retval = x;
+    }
+    return retval;
+}
+/** Shared exit: factor numerator and denominator, or return as-is for pure numbers. */
+function factorResult(x) {
+    if (x.isNUM()) {
+        return x;
+    }
+    const num = (0, utils_1.product)(...(0, factor_1.polyFactorExpressions)(x.getNumerator()));
+    const den = (0, utils_1.product)(...(0, factor_1.polyFactorExpressions)(x.getDenominator()));
+    return num.div(den);
+}
+/**
+ * Cancels common factors between top-level elements and elements nested inside
+ * inverted products. Handles cases like fact(n) * (fact(n)*(1+n))^-1 → (1+n)^-1
+ * where the denominator is a product raised to -1 and contains a factor that
+ * matches a numerator element.
+ */
+function cancelNestedFactors(x) {
+    if (!x.isProduct()) {
+        return x;
+    }
+    const numFactors = [];
+    const denCompounds = [];
+    const otherDen = [];
+    let idx = 0;
+    for (const element of x.elementsArray()) {
+        const p = element.getPower();
+        if (p.sign() === -1 && p.isMinusOne?.()) {
+            // This is something^-1. Check if the base is a product.
+            const base = element.invert();
+            if (base.isProduct()) {
+                denCompounds.push({ base, index: idx });
+            }
+            else {
+                otherDen.push(element);
+            }
+        }
+        else if (p.sign() === 1) {
+            numFactors.push(element);
+        }
+        else {
+            otherDen.push(element);
+        }
+        idx++;
+    }
+    // Nothing to do if there are no compound denominators
+    if (denCompounds.length === 0 || numFactors.length === 0) {
+        return x;
+    }
+    let changed = false;
+    const usedNum = new Set();
+    for (const compound of denCompounds) {
+        const denElements = compound.base.elementsArray();
+        const denMultiplier = compound.base.getMultiplier();
+        const survivingDen = [];
+        let compoundChanged = false;
+        for (const de of denElements) {
+            let cancelled = false;
+            for (let i = 0; i < numFactors.length; i++) {
+                if (usedNum.has(i)) {
+                    continue;
+                }
+                // Compare ignoring multipliers
+                const numUnit = numFactors[i].toUnitMultiplier();
+                const denUnit = de.toUnitMultiplier();
+                if (numUnit.eq(denUnit)) {
+                    // Cancel, keeping ratio of multipliers
+                    const mRatio = numFactors[i].getMultiplier().div(de.getMultiplier());
+                    if (!mRatio.isOne()) {
+                        // Replace the numerator factor with the multiplier ratio
+                        numFactors[i] = Expression_1.Expression.fromRational(mRatio);
+                    }
+                    else {
+                        usedNum.add(i);
+                    }
+                    cancelled = true;
+                    compoundChanged = true;
+                    changed = true;
+                    break;
+                }
+            }
+            if (!cancelled) {
+                survivingDen.push(de);
+            }
+        }
+        if (compoundChanged) {
+            // Rebuild the denominator from surviving elements
+            if (survivingDen.length === 0) {
+                // Entire denominator cancelled — just the multiplier remains
+                otherDen.push(Expression_1.Expression.fromRational(denMultiplier).invert());
+            }
+            else {
+                let newDen = Expression_1.Expression.fromRational(denMultiplier);
+                for (const s of survivingDen) {
+                    newDen = newDen.times(s);
+                }
+                otherDen.push(newDen.invert());
+            }
+        }
+        else {
+            otherDen.push(compound.base.invert());
+        }
+    }
+    if (!changed) {
+        return x;
+    }
+    let result = Expression_1.Expression.fromRational(x.getMultiplier());
+    for (let i = 0; i < numFactors.length; i++) {
+        if (!usedNum.has(i)) {
+            result = result.times(numFactors[i]);
+        }
+    }
+    for (const d of otherDen) {
+        result = result.times(d);
+    }
+    return result;
+}

package/output/algebra/simplify/trigreduce.d.ts

@@ -0,0 +1,38 @@
+import { Expression } from '../../core/classes/expression/Expression';
+/**
+ * Applies power reduction to a single trig function with an integer power ≥ 2.
+ *
+ *   sin(u)^(2k) → expanded using repeated application of half-angle
+ *   cos(u)^(2k) → expanded using repeated application of half-angle
+ *   sin(u)^(2k+1) → sin(u) · [sin(u)^(2k) reduced]
+ *   cos(u)^(2k+1) → cos(u) · [cos(u)^(2k) reduced]
+ *
+ * Only applies when the power is an integer ≥ 2 (or ≤ -2).
+ * Fractional powers like sin(x)^(1/2) are left unchanged.
+ */
+export declare function reduceTrigPower(e: Expression): Expression;
+/**
+ * Applies power reduction to all trig powers in an expression.
+ * Descends into sums and products.
+ */
+export declare function trigReduce(x: Expression): Expression;
+/**
+ * Expands all double-angle trig functions in an expression.
+ */
+export declare function expandDoubleAngle(x: Expression): Expression;
+/**
+ * Converts a product of two trig functions to a sum using product-to-sum identities.
+ *
+ * sin(a)·cos(b) → (1/2)[sin(a+b) + sin(a-b)]
+ * cos(a)·cos(b) → (1/2)[cos(a-b) + cos(a+b)]
+ * sin(a)·sin(b) → (1/2)[cos(a-b) - cos(a+b)]
+ */
+export declare function productToSum(x: Expression): Expression;
+/**
+ * Converts sin(u)·cos(u) products into double-angle form.
+ *
+ *   k·sin(u)·cos(u) → (k/2)·sin(2u)
+ *
+ * This is the reverse of expandDoubleAngle for sin.
+ */
+export declare function convertToDoubleAngle(x: Expression): Expression;