nerdamer 1.1.13 → 2.0.0-rc.1

package/output/algebra/simplify/trigreduce.js

@@ -0,0 +1,424 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reduceTrigPower = reduceTrigPower;
+exports.trigReduce = trigReduce;
+exports.expandDoubleAngle = expandDoubleAngle;
+exports.productToSum = productToSum;
+exports.convertToDoubleAngle = convertToDoubleAngle;
+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 trig_1 = require("../../math/trig");
+// ============================================================================
+// POWER REDUCTION (trigreduce)
+//
+// Reduces powers of trig functions using double-angle identities:
+//   sin²(u) → (1 - cos(2u)) / 2
+//   cos²(u) → (1 + cos(2u)) / 2
+//   sin²(u)·cos²(u) → (1 - cos(4u)) / 8   (via sin(2u)²/4)
+//
+// Higher powers are handled recursively:
+//   sin³(u) → sin(u)·sin²(u) → sin(u)·(1 - cos(2u))/2
+//   sin⁴(u) → (sin²(u))² → ((1 - cos(2u))/2)² → (3 - 4cos(2u) + cos(4u))/8
+// ============================================================================
+/**
+ * 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.
+ */
+function reduceTrigPower(e) {
+    if (!e.isFunction(constants_1.SIN) && !e.isFunction(constants_1.COS)) {
+        return e;
+    }
+    const p = e.getPower();
+    const m = e.getMultiplier();
+    const args = e.getArguments();
+    if (args.length === 0) {
+        return e;
+    }
+    const u = args[0];
+    const isSin = e.isFunction(constants_1.SIN);
+    // Only reduce integer powers with |n| >= 2.
+    // The power is an Expression. Check that it's a pure integer by inspecting
+    // its Rational multiplier: it must be an integer (denominator === 1n)
+    // and the power itself must be a NUM type (no symbolic component).
+    if (!p.isNUM()) {
+        return e;
+    }
+    const pRat = p.getMultiplier(); // Rational
+    if (pRat.denominator !== 1n && pRat.denominator !== -1n) {
+        // Fractional power — not an integer, leave unchanged
+        return e;
+    }
+    const nBig = pRat.numerator / (pRat.denominator < 0n ? -pRat.denominator : pRat.denominator);
+    const nAbs = nBig < 0n ? -nBig : nBig;
+    if (nAbs < 2n) {
+        return e;
+    }
+    // For negative powers, reduce the positive power and invert
+    if (nBig < 0n) {
+        const positive = reduceTrigPower(isSin
+            ? (0, trig_1.sin)(u).pow(Expression_1.Expression.Number(nAbs))
+            : (0, trig_1.cos)(u).pow(Expression_1.Expression.Number(nAbs)));
+        return Expression_1.Expression.fromRational(m).times(positive.invert());
+    }
+    const n = Number(nAbs);
+    let result;
+    if (n === 2) {
+        // sin²(u) = (1 - cos(2u)) / 2
+        // cos²(u) = (1 + cos(2u)) / 2
+        const twoU = u.times((0, shortcuts_1.two)());
+        if (isSin) {
+            result = (0, shortcuts_1.one)().minus((0, trig_1.cos)(twoU)).div((0, shortcuts_1.two)());
+        }
+        else {
+            result = (0, shortcuts_1.one)().plus((0, trig_1.cos)(twoU)).div((0, shortcuts_1.two)());
+        }
+    }
+    else if (n % 2 === 0) {
+        // Even power: sin^(2k)(u) = (sin²(u))^k, then reduce sin²
+        const halfPower = n / 2;
+        const squared = reduceTrigPower(isSin ? (0, trig_1.sin)(u).pow((0, shortcuts_1.two)()) : (0, trig_1.cos)(u).pow((0, shortcuts_1.two)()));
+        result = squared.pow(Expression_1.Expression.create(`${halfPower}`));
+    }
+    else {
+        // Odd power: sin^(2k+1)(u) = sin(u) · sin^(2k)(u)
+        const evenPart = reduceTrigPower(isSin
+            ? (0, trig_1.sin)(u).pow(Expression_1.Expression.create(`${n - 1}`))
+            : (0, trig_1.cos)(u).pow(Expression_1.Expression.create(`${n - 1}`)));
+        result = (isSin ? (0, trig_1.sin)(u) : (0, trig_1.cos)(u)).times(evenPart);
+    }
+    if (!m.isOne()) {
+        result = result.times(Expression_1.Expression.fromRational(m));
+    }
+    return result;
+}
+/**
+ * Applies power reduction to all trig powers in an expression.
+ * Descends into sums and products.
+ */
+function trigReduce(x) {
+    // Direct trig function
+    if ((x.isFunction(constants_1.SIN) || x.isFunction(constants_1.COS)) && x.getPower().isInteger()) {
+        const p = x.getPower();
+        if (p.abs().gte((0, shortcuts_1.two)())) {
+            return reduceTrigPower(x);
+        }
+    }
+    // Sum: reduce 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(trigReduce(term));
+        }
+        if (!p.isOne()) {
+            result = result.pow(p);
+        }
+        if (!m.isOne()) {
+            result = result.times(Expression_1.Expression.fromRational(m));
+        }
+        return result;
+    }
+    // Product: reduce 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(trigReduce(element));
+        }
+        if (!p.isOne()) {
+            result = result.pow(p);
+        }
+        if (!m.isOne()) {
+            result = result.times(Expression_1.Expression.fromRational(m));
+        }
+        return result;
+    }
+    return x;
+}
+// ============================================================================
+// DOUBLE ANGLE IDENTITIES
+//
+// Expansion direction (useful for simplification):
+//   sin(2u) → 2·sin(u)·cos(u)
+//   cos(2u) → cos²(u) - sin²(u)
+//          → 2·cos²(u) - 1
+//          → 1 - 2·sin²(u)
+//
+// Reverse direction (useful for reducing products):
+//   2·sin(u)·cos(u) → sin(2u)
+//   cos²(u) - sin²(u) → cos(2u)
+// ============================================================================
+/**
+ * Expands double angle: sin(2u) → 2·sin(u)·cos(u)
+ * Only applies if the argument has a factor of 2.
+ */
+function expandDoubleAngleSin(e) {
+    if (!e.isFunction(constants_1.SIN)) {
+        return null;
+    }
+    const args = e.getArguments();
+    if (args.length === 0) {
+        return null;
+    }
+    const arg = args[0];
+    const m = e.getMultiplier();
+    const p = e.getPower();
+    // Check if argument is 2*u for some u
+    const u = extractHalfArgument(arg);
+    if (!u) {
+        return null;
+    }
+    // sin(2u) = 2·sin(u)·cos(u)
+    let result = (0, shortcuts_1.two)().times((0, trig_1.sin)(u)).times((0, trig_1.cos)(u));
+    if (!p.isOne()) {
+        result = result.pow(p);
+    }
+    if (!m.isOne()) {
+        result = result.times(Expression_1.Expression.fromRational(m));
+    }
+    return result;
+}
+/**
+ * Expands double angle: cos(2u) → cos²(u) - sin²(u)
+ * Only applies if the argument has a factor of 2.
+ */
+function expandDoubleAngleCos(e) {
+    if (!e.isFunction(constants_1.COS)) {
+        return null;
+    }
+    const args = e.getArguments();
+    if (args.length === 0) {
+        return null;
+    }
+    const arg = args[0];
+    const m = e.getMultiplier();
+    const p = e.getPower();
+    const u = extractHalfArgument(arg);
+    if (!u) {
+        return null;
+    }
+    // cos(2u) = cos²(u) - sin²(u)
+    let result = (0, trig_1.cos)(u).pow((0, shortcuts_1.two)()).minus((0, trig_1.sin)(u).pow((0, shortcuts_1.two)()));
+    if (!p.isOne()) {
+        result = result.pow(p);
+    }
+    if (!m.isOne()) {
+        result = result.times(Expression_1.Expression.fromRational(m));
+    }
+    return result;
+}
+/**
+ * If the argument is of the form 2*u, returns u. Otherwise returns null.
+ */
+function extractHalfArgument(arg) {
+    const m = arg.getMultiplier();
+    // Check if the multiplier is even (has a factor of 2)
+    if (m.numerator % 2n === 0n) {
+        // Divide multiplier by 2
+        const half = arg.div((0, shortcuts_1.two)());
+        return half;
+    }
+    return null;
+}
+/**
+ * Expands all double-angle trig functions in an expression.
+ */
+function expandDoubleAngle(x) {
+    if (x.isFunction(constants_1.SIN)) {
+        const expanded = expandDoubleAngleSin(x);
+        if (expanded) {
+            return expanded;
+        }
+    }
+    if (x.isFunction(constants_1.COS)) {
+        const expanded = expandDoubleAngleCos(x);
+        if (expanded) {
+            return expanded;
+        }
+    }
+    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(expandDoubleAngle(term));
+        }
+        if (!p.isOne()) {
+            result = result.pow(p);
+        }
+        if (!m.isOne()) {
+            result = result.times(Expression_1.Expression.fromRational(m));
+        }
+        return result;
+    }
+    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(expandDoubleAngle(element));
+        }
+        if (!p.isOne()) {
+            result = result.pow(p);
+        }
+        if (!m.isOne()) {
+            result = result.times(Expression_1.Expression.fromRational(m));
+        }
+        return result;
+    }
+    return x;
+}
+/**
+ * Extracts sin/cos factors from a product for product-to-sum conversion.
+ * Only extracts factors with power = 1 (linear trig factors).
+ */
+function extractTrigFactors(x) {
+    const trigFactors = [];
+    let rest = Expression_1.Expression.fromRational(x.getMultiplier());
+    if (!x.isProduct()) {
+        // Check if x itself is a single trig function
+        if ((x.isFunction(constants_1.SIN) || x.isFunction(constants_1.COS)) && x.getPower().eq((0, shortcuts_1.one)())) {
+            const args = x.getArguments();
+            if (args.length > 0) {
+                trigFactors.push({
+                    fn: x.isFunction(constants_1.SIN) ? constants_1.SIN : constants_1.COS,
+                    arg: args[0],
+                    power: x.getPower(),
+                });
+                rest = Expression_1.Expression.fromRational(x.getMultiplier());
+                return { trigFactors, rest };
+            }
+        }
+        return { trigFactors: [], rest: x };
+    }
+    for (const element of x.elementsArray()) {
+        if ((element.isFunction(constants_1.SIN) || element.isFunction(constants_1.COS)) && element.getPower().eq((0, shortcuts_1.one)())) {
+            const args = element.getArguments();
+            if (args.length > 0) {
+                trigFactors.push({
+                    fn: element.isFunction(constants_1.SIN) ? constants_1.SIN : constants_1.COS,
+                    arg: args[0],
+                    power: element.getPower(),
+                });
+                // Include the element's own multiplier in rest
+                if (!element.getMultiplier().isOne()) {
+                    rest = rest.times(Expression_1.Expression.fromRational(element.getMultiplier()));
+                }
+                continue;
+            }
+        }
+        rest = rest.times(element);
+    }
+    return { trigFactors, rest };
+}
+/**
+ * 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)]
+ */
+function productToSum(x) {
+    const { trigFactors, rest } = extractTrigFactors(x);
+    // Need at least 2 trig factors to apply product-to-sum
+    if (trigFactors.length < 2) {
+        return x;
+    }
+    // Process pairs of trig factors
+    let result = rest;
+    let i = 0;
+    while (i < trigFactors.length - 1) {
+        const f1 = trigFactors[i];
+        const f2 = trigFactors[i + 1];
+        const a = f1.arg;
+        const b = f2.arg;
+        const aPlusB = a.plus(b);
+        const aMinusB = a.minus(b);
+        const half = (0, shortcuts_1.one)().div((0, shortcuts_1.two)());
+        let converted;
+        if (f1.fn === constants_1.SIN && f2.fn === constants_1.COS) {
+            // sin(a)·cos(b) = (1/2)[sin(a+b) + sin(a-b)]
+            converted = half.times((0, trig_1.sin)(aPlusB).plus((0, trig_1.sin)(aMinusB)));
+        }
+        else if (f1.fn === constants_1.COS && f2.fn === constants_1.SIN) {
+            // cos(a)·sin(b) = (1/2)[sin(a+b) - sin(a-b)]
+            converted = half.times((0, trig_1.sin)(aPlusB).minus((0, trig_1.sin)(aMinusB)));
+        }
+        else if (f1.fn === constants_1.COS && f2.fn === constants_1.COS) {
+            // cos(a)·cos(b) = (1/2)[cos(a-b) + cos(a+b)]
+            converted = half.times((0, trig_1.cos)(aMinusB).plus((0, trig_1.cos)(aPlusB)));
+        }
+        else {
+            // sin(a)·sin(b) = (1/2)[cos(a-b) - cos(a+b)]
+            converted = half.times((0, trig_1.cos)(aMinusB).minus((0, trig_1.cos)(aPlusB)));
+        }
+        result = result.times(converted);
+        i += 2;
+    }
+    // If there's an unpaired trig factor, multiply it back in
+    if (i < trigFactors.length) {
+        const leftover = trigFactors[i];
+        const fn = leftover.fn === constants_1.SIN ? trig_1.sin : trig_1.cos;
+        result = result.times(fn(leftover.arg));
+    }
+    return result;
+}
+/**
+ * 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.
+ */
+function convertToDoubleAngle(x) {
+    if (!x.isProduct()) {
+        return x;
+    }
+    const { trigFactors, rest } = extractTrigFactors(x);
+    // Look for sin(u)·cos(u) pairs with matching arguments
+    const usedIndices = new Set();
+    let result = rest;
+    for (let i = 0; i < trigFactors.length; i++) {
+        if (usedIndices.has(i)) {
+            continue;
+        }
+        for (let j = i + 1; j < trigFactors.length; j++) {
+            if (usedIndices.has(j)) {
+                continue;
+            }
+            const a = trigFactors[i];
+            const b = trigFactors[j];
+            // Check for sin(u)·cos(u) or cos(u)·sin(u) with same argument
+            if (a.arg.eq(b.arg) &&
+                ((a.fn === constants_1.SIN && b.fn === constants_1.COS) || (a.fn === constants_1.COS && b.fn === constants_1.SIN))) {
+                // sin(u)·cos(u) = (1/2)·sin(2u)
+                const u = a.arg;
+                result = result.times((0, shortcuts_1.one)()
+                    .div((0, shortcuts_1.two)())
+                    .times((0, trig_1.sin)(u.times((0, shortcuts_1.two)()))));
+                usedIndices.add(i);
+                usedIndices.add(j);
+                break;
+            }
+        }
+    }
+    // Add back any unmatched trig factors
+    for (let i = 0; i < trigFactors.length; i++) {
+        if (!usedIndices.has(i)) {
+            const f = trigFactors[i];
+            const fn = f.fn === constants_1.SIN ? trig_1.sin : trig_1.cos;
+            result = result.times(fn(f.arg));
+        }
+    }
+    return result;
+}

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

@@ -0,0 +1,17 @@
+import { Expression } from '../../core/classes/expression/Expression';
+/**
+ * Determines whether an expression contains any tan, sec, csc, or cot functions.
+ */
+export declare function hasDerivedTrig(x: Expression): boolean;
+/**
+ * Recursively rewrites all tan, sec, csc, cot in an expression tree to sin/cos form.
+ * This is a deep rewrite — it descends into sums, products, and function arguments.
+ */
+export declare function rewrite(x: Expression): Expression;
+/**
+ * Attempts to rewrite derived trig functions to sin/cos and checks if the result
+ * is simpler (fewer terms or lower complexity). Returns the simpler form.
+ *
+ * This is the "only rewrite when it leads to cancellation" strategy.
+ */
+export declare function tryRewriteTrig(x: Expression): Expression;

package/output/algebra/simplify/trigrewrite.js

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasDerivedTrig = hasDerivedTrig;
+exports.rewrite = rewrite;
+exports.tryRewriteTrig = tryRewriteTrig;
+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 trig_1 = require("../../math/trig");
+/**
+ * Determines whether an expression contains any tan, sec, csc, or cot functions.
+ */
+function hasDerivedTrig(x) {
+    let found = false;
+    x.forEveryElement(e => {
+        if (e.isFunction(constants_1.TAN) || e.isFunction(constants_1.SEC) || e.isFunction(constants_1.CSC) || e.isFunction(constants_1.COT)) {
+            found = true;
+        }
+        return e;
+    });
+    return found;
+}
+/**
+ * Rewrites a single trig function element in terms of sin and cos.
+ *
+ *   tan(u)^n  →  sin(u)^n * cos(u)^(-n)
+ *   cot(u)^n  →  cos(u)^n * sin(u)^(-n)
+ *   sec(u)^n  →  cos(u)^(-n)
+ *   csc(u)^n  →  sin(u)^(-n)
+ *
+ * Multiplier and arguments are preserved.
+ */
+function rewriteTrigElement(e) {
+    const m = e.getMultiplier();
+    const p = e.getPower();
+    const args = e.getArguments();
+    if (e.isFunction(constants_1.TAN) && args.length > 0) {
+        const u = args[0];
+        return Expression_1.Expression.fromRational(m).times((0, trig_1.sin)(u).pow(p)).times((0, trig_1.cos)(u).pow(p.neg()));
+    }
+    if (e.isFunction(constants_1.COT) && args.length > 0) {
+        const u = args[0];
+        return Expression_1.Expression.fromRational(m).times((0, trig_1.cos)(u).pow(p)).times((0, trig_1.sin)(u).pow(p.neg()));
+    }
+    if (e.isFunction(constants_1.SEC) && args.length > 0) {
+        const u = args[0];
+        return Expression_1.Expression.fromRational(m).times((0, trig_1.cos)(u).pow(p.neg()));
+    }
+    if (e.isFunction(constants_1.CSC) && args.length > 0) {
+        const u = args[0];
+        return Expression_1.Expression.fromRational(m).times((0, trig_1.sin)(u).pow(p.neg()));
+    }
+    return e;
+}
+/**
+ * Recursively rewrites all tan, sec, csc, cot in an expression tree to sin/cos form.
+ * This is a deep rewrite — it descends into sums, products, and function arguments.
+ */
+function rewrite(x) {
+    // If it's a direct derived trig function, rewrite it
+    if (x.isFunction(constants_1.TAN) || x.isFunction(constants_1.COT) || x.isFunction(constants_1.SEC) || x.isFunction(constants_1.CSC)) {
+        return rewriteTrigElement(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(rewrite(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(rewrite(element));
+        }
+        if (!p.isOne()) {
+            result = result.pow(p);
+        }
+        if (!m.isOne()) {
+            result = result.times(Expression_1.Expression.fromRational(m));
+        }
+        return result;
+    }
+    // For other functions (sin, cos, log, etc.): rewrite the arguments
+    if (x.isFunction()) {
+        // Don't rewrite inside sin/cos arguments — the derived trig functions
+        // inside arguments would be unusual, but handle it for completeness
+        return x;
+    }
+    return x;
+}
+/**
+ * Attempts to rewrite derived trig functions to sin/cos and checks if the result
+ * is simpler (fewer terms or lower complexity). Returns the simpler form.
+ *
+ * This is the "only rewrite when it leads to cancellation" strategy.
+ */
+function tryRewriteTrig(x) {
+    if (!hasDerivedTrig(x)) {
+        return x;
+    }
+    const rewritten = rewrite(x);
+    // Heuristic: the rewritten form is "better" if it has fewer elements,
+    // fewer distinct function types, or leads to cancellation (becomes simpler text).
+    // A simple proxy: compare text length or element count.
+    if (complexity(rewritten) <= complexity(x)) {
+        return rewritten;
+    }
+    return x;
+}
+/**
+ * Simple complexity metric for an expression.
+ * Lower is simpler.
+ */
+function complexity(x) {
+    const text = x.text();
+    // Count the number of function calls, operations, and terms as a rough proxy
+    let score = text.length;
+    // Bonus: fewer distinct trig function types is better
+    const types = new Set();
+    x.forEveryElement(e => {
+        if (e.isFunction(constants_1.SIN)) {
+            types.add(constants_1.SIN);
+        }
+        if (e.isFunction(constants_1.COS)) {
+            types.add(constants_1.COS);
+        }
+        if (e.isFunction(constants_1.TAN)) {
+            types.add(constants_1.TAN);
+        }
+        if (e.isFunction(constants_1.SEC)) {
+            types.add(constants_1.SEC);
+        }
+        if (e.isFunction(constants_1.CSC)) {
+            types.add(constants_1.CSC);
+        }
+        if (e.isFunction(constants_1.COT)) {
+            types.add(constants_1.COT);
+        }
+        return e;
+    });
+    score += types.size * 10;
+    return score;
+}

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

@@ -0,0 +1,11 @@
+import { Expression } from '../../core/classes/expression/Expression';
+/**
+ * Simplifies trig identities in a sum expression.
+ *
+ * Applies:
+ *   a·sin(u)² + a·cos(u)² = a                (Pythagorean)
+ *   a·sec(u)² - a·tan(u)² = a                (sec²-tan²=1)
+ *   a·csc(u)² - a·cot(u)² = a                (csc²-cot²=1)
+ *   Partial Pythagorean for mismatched coefficients
+ */
+export declare function simplifyTrigSum(x: Expression): Expression;