nerdamer 1.1.13 → 2.0.0-rc.1

package/output/core/functions/complex.js

@@ -0,0 +1,482 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.realPart = realPart;
+exports.imagPart = imagPart;
+exports.simplifyImaginary = simplifyImaginary;
+exports.toPolarFormArray = toPolarFormArray;
+exports.polarForm = polarForm;
+exports.rectForm = rectForm;
+exports.arg = arg;
+exports.conjugate = conjugate;
+exports.csgn = csgn;
+const geometry_1 = require("../../math/geometry");
+const trig_1 = require("../../math/trig");
+const Expression_1 = require("../classes/expression/Expression");
+const shortcuts_1 = require("../classes/expression/shortcuts");
+const constants_1 = require("../classes/parser/constants");
+const add_1 = require("../classes/parser/operations/add");
+const divide_1 = require("../classes/parser/operations/divide");
+const multiply_1 = require("../classes/parser/operations/multiply");
+const power_1 = require("../classes/parser/operations/power");
+const expand_1 = require("./expand/expand");
+/**
+ * Retrieves the real part of a complex number
+ *
+ * @param a
+ * @returns
+ */
+/**
+ * Retrieves the real part of a complex number
+ *
+ * @param a
+ * @returns
+ */
+function realPart(a) {
+    let retval;
+    const x = (0, expand_1.expand)(a);
+    // i^p: use principal branch i = exp(i*pi/2). The multiplier is an outer
+    // coefficient and must not be folded into the powered base.
+    if (x.isVAR() && x.isI()) {
+        const p = x.getPower();
+        const theta = (0, divide_1.divide)(Expression_1.Expression.Pi(), (0, shortcuts_1.two)());
+        const re = (0, trig_1.cos)((0, multiply_1.multiply)(p, theta));
+        retval = (0, multiply_1.multiply)(Expression_1.Expression.fromRational(x.getMultiplier()), re);
+    }
+    // EXP nodes also carry their multiplier outside the powered base.
+    else if (x.isEXP()) {
+        const p = x.getPower();
+        const multiplier = Expression_1.Expression.fromRational(x.getMultiplier());
+        if (p.isInteger()) {
+            retval = (0, multiply_1.multiply)(multiplier, realPart((0, power_1.power)(x.getBase(), p)));
+        }
+        else {
+            const [r, theta] = toPolarFormArray(x.getBase());
+            const rp = (0, power_1.power)(r, p);
+            const re = (0, trig_1.cos)((0, multiply_1.multiply)(p, theta));
+            retval = (0, multiply_1.multiply)(multiplier, (0, multiply_1.multiply)(rp, re));
+        }
+    }
+    // realpart(...) and imagpart(...) are real-valued by definition. Preserve
+    // other functions without complex inputs, and keep explicitly complex
+    // function components symbolic rather than treating them as zero.
+    else if (x.isComplexComponentFunction()) {
+        retval = new Expression_1.Expression(x);
+    }
+    else if (x.isFunction()) {
+        retval = x.isComplex()
+            ? Expression_1.Expression.toFunction(constants_1.REALPART, [x])
+            : new Expression_1.Expression(x);
+    }
+    // Decompose products through their complex factors while preserving real
+    // factors as an outer scale.
+    else if (x.isProduct() && x.isComplex()) {
+        const multiplier = Expression_1.Expression.fromRational(x.getMultiplier());
+        let realFactor = (0, shortcuts_1.one)();
+        let complexFactor;
+        let complexFactorCount = 0;
+        const elements = x.getElements();
+        for (const e in elements) {
+            const factor = elements[e];
+            if (factor.isComplex()) {
+                complexFactor = factor;
+                complexFactorCount++;
+            }
+            else {
+                realFactor = (0, multiply_1.multiply)(realFactor, factor);
+            }
+        }
+        // A real product scales the components of its single complex factor.
+        if (complexFactorCount === 1 && complexFactor) {
+            retval = (0, multiply_1.multiply)(multiplier, (0, multiply_1.multiply)(realFactor, realPart(complexFactor)));
+        }
+        else {
+            let productReal = (0, shortcuts_1.one)();
+            let productImaginary = (0, shortcuts_1.zero)();
+            for (const e in elements) {
+                const factor = elements[e];
+                if (factor.isComplex()) {
+                    const factorReal = realPart(factor);
+                    const factorImaginary = imagPart(factor);
+                    const previousReal = productReal;
+                    const previousImaginary = productImaginary;
+                    productReal = (0, multiply_1.multiply)(previousReal, factorReal).minus((0, multiply_1.multiply)(previousImaginary, factorImaginary));
+                    productImaginary = (0, multiply_1.multiply)(previousReal, factorImaginary).plus((0, multiply_1.multiply)(previousImaginary, factorReal));
+                }
+            }
+            retval = (0, multiply_1.multiply)(multiplier, (0, multiply_1.multiply)(realFactor, productReal));
+        }
+    }
+    // The real part will be any known constants.
+    // Handle pi, e, numbers, x, a*b
+    else if (x.isConstant() ||
+        (x.isVAR() && !x.isI()) ||
+        (x.isProduct() && !x.isComplex())) {
+        retval = new Expression_1.Expression(a);
+    }
+    // Deal with x+1, y+y^2, ...
+    else if (x.isSum()) {
+        // Check if the sum has a power attached - if so, treat as single term
+        if (!x.getPower().isOne()) {
+            retval = new Expression_1.Expression(a);
+        }
+        else {
+            retval = (0, shortcuts_1.zero)();
+            const elements = x.getElements();
+            for (const e in elements) {
+                const re = realPart(elements[e]);
+                retval = (0, add_1.add)(retval, re);
+            }
+        }
+    }
+    // Otherwise it's zero
+    else {
+        retval = (0, shortcuts_1.zero)();
+    }
+    return retval;
+}
+/**
+ * Retrieves the imaginary part of a complex number
+ *
+ * @param a
+ * @returns
+ */
+function imagPart(a) {
+    let retval;
+    const x = (0, expand_1.expand)(a);
+    // i^p: use principal branch i = exp(i*pi/2). The multiplier is an outer
+    // coefficient and must not be folded into the powered base.
+    if (x.isVAR() && x.isI()) {
+        const p = x.getPower();
+        const theta = (0, divide_1.divide)(Expression_1.Expression.Pi(), (0, shortcuts_1.two)());
+        const im = (0, trig_1.sin)((0, multiply_1.multiply)(p, theta));
+        retval = (0, multiply_1.multiply)(Expression_1.Expression.fromRational(x.getMultiplier()), im);
+    }
+    // EXP nodes also carry their multiplier outside the powered base.
+    else if (x.isEXP()) {
+        const p = x.getPower();
+        const multiplier = Expression_1.Expression.fromRational(x.getMultiplier());
+        if (p.isInteger()) {
+            retval = (0, multiply_1.multiply)(multiplier, imagPart((0, power_1.power)(x.getBase(), p)));
+        }
+        else {
+            const [r, theta] = toPolarFormArray(x.getBase());
+            const rp = (0, power_1.power)(r, p);
+            const im = (0, trig_1.sin)((0, multiply_1.multiply)(p, theta));
+            retval = (0, multiply_1.multiply)(multiplier, (0, multiply_1.multiply)(rp, im));
+        }
+    }
+    // realpart(...) and imagpart(...) are real-valued by definition. For other
+    // explicitly complex functions, keep the component symbolic rather than
+    // silently treating an unevaluated function as zero.
+    else if (x.isComplexComponentFunction()) {
+        retval = (0, shortcuts_1.zero)();
+    }
+    else if (x.isFunction() && x.isComplex()) {
+        retval = Expression_1.Expression.toFunction(constants_1.IMAGPART, [x]);
+    }
+    else if (x.isSum()) {
+        retval = (0, shortcuts_1.zero)();
+        const elements = x.getElements();
+        for (const e in elements) {
+            retval = (0, add_1.add)(retval, imagPart(elements[e]));
+        }
+    }
+    else if (x.isProduct()) {
+        if (x.isComplex()) {
+            const multiplier = Expression_1.Expression.fromRational(x.getMultiplier());
+            let realFactor = (0, shortcuts_1.one)();
+            let complexFactor;
+            let complexFactorCount = 0;
+            const elements = x.getElements();
+            for (const e in elements) {
+                const factor = elements[e];
+                if (factor.isComplex()) {
+                    complexFactor = factor;
+                    complexFactorCount++;
+                }
+                else {
+                    realFactor = (0, multiply_1.multiply)(realFactor, factor);
+                }
+            }
+            // A real product scales the components of its single complex factor.
+            if (complexFactorCount === 1 && complexFactor) {
+                retval = (0, multiply_1.multiply)(multiplier, (0, multiply_1.multiply)(realFactor, imagPart(complexFactor)));
+            }
+            else {
+                let productReal = (0, shortcuts_1.one)();
+                let productImaginary = (0, shortcuts_1.zero)();
+                for (const e in elements) {
+                    const factor = elements[e];
+                    if (factor.isComplex()) {
+                        const factorReal = realPart(factor);
+                        const factorImaginary = imagPart(factor);
+                        const previousReal = productReal;
+                        const previousImaginary = productImaginary;
+                        productReal = (0, multiply_1.multiply)(previousReal, factorReal).minus((0, multiply_1.multiply)(previousImaginary, factorImaginary));
+                        productImaginary = (0, multiply_1.multiply)(previousReal, factorImaginary).plus((0, multiply_1.multiply)(previousImaginary, factorReal));
+                    }
+                }
+                retval = (0, multiply_1.multiply)(multiplier, (0, multiply_1.multiply)(realFactor, productImaginary));
+            }
+        }
+        else {
+            retval = (0, shortcuts_1.zero)();
+        }
+    }
+    else {
+        retval = (0, shortcuts_1.zero)();
+    }
+    return retval;
+}
+/**
+ * Simplifies a*i^n with numeric powers and coefficients
+ *
+ * @param x
+ */
+function simplifyImaginary(x) {
+    const power = x.getPower();
+    if (x.isI() && power.isInteger()) {
+        const r = power.mod('4').abs();
+        // const sgn = power.sign();
+        const rText = r.text();
+        let retval;
+        switch (rText) {
+            case '1':
+                retval = Expression_1.Expression.Img();
+                break;
+            case '2':
+                retval = (0, shortcuts_1.minusOne)();
+                break;
+            case '3':
+                retval = Expression_1.Expression.Img().neg();
+                break;
+            default:
+                retval = (0, shortcuts_1.one)();
+                break;
+        }
+        retval = (0, multiply_1.multiply)(retval, Expression_1.Expression.fromRational(x.getMultiplier()));
+        return retval;
+    }
+    return x;
+}
+function toPolarFormArray(x) {
+    const re = x.realPart();
+    const im = x.imagPart();
+    const r = (0, geometry_1.hypot)(re, im);
+    // Principal argument (theta)
+    let theta;
+    if (re.isZero()) {
+        if (im.isZero()) {
+            theta = (0, shortcuts_1.zero)();
+        }
+        else if (im.isConstant()) {
+            // On the imaginary axis: choose ±pi/2 based on sign(im)
+            theta =
+                im.sign() < 0
+                    ? (0, multiply_1.multiply)((0, shortcuts_1.minusOne)(), (0, divide_1.divide)(Expression_1.Expression.Pi(), (0, shortcuts_1.two)()))
+                    : (0, divide_1.divide)(Expression_1.Expression.Pi(), (0, shortcuts_1.two)());
+        }
+        else {
+            theta = (0, trig_1.atan2)(im, re);
+        }
+    }
+    else {
+        theta = (0, trig_1.atan2)(im, re);
+    }
+    return [r, theta];
+}
+/**
+ * Calculates the polar from of a complex number
+ * //IMPROVE: Potential speed boost by just returning i.
+ *
+ * @param x
+ * @returns
+ */
+function polarForm(x) {
+    let retval;
+    if (x.isNUM() || (x.isI() && x.isLinear())) {
+        // The polarform of a number is just the number
+        retval = new Expression_1.Expression(x);
+    }
+    else {
+        // Get r and theta. Theta will come back as (atan(x) or a*pi/n)
+        const [r, theta] = toPolarFormArray((0, expand_1.expand)(x));
+        // Calculate the power i * theta
+        const p = (0, multiply_1.multiply)(Expression_1.Expression.Img(), theta);
+        // return r*e^(i*theta)
+        const t = (0, power_1.power)(Expression_1.Expression.Variable(constants_1.E), p);
+        retval = (0, multiply_1.multiply)(t, r);
+    }
+    return retval;
+}
+/**
+ * Attempts to convert a polar form complex to rectangular form. If no exact identity
+ * is found, the decimal representation in rectangular form is returned.
+ *
+ * @param x
+ * @returns
+ */
+function rectForm(x) {
+    x = Expression_1.Expression.create(x);
+    let retval;
+    function toTheta(t) {
+        const elements = t.elementsArray();
+        let complexPart = (0, shortcuts_1.one)();
+        let realPart = (0, shortcuts_1.one)();
+        for (const e of elements) {
+            if (e.isComplex()) {
+                complexPart = complexPart.times(e);
+            }
+            else {
+                realPart = realPart.times(e);
+            }
+        }
+        // Check if it's in the form i*θ
+        if (complexPart.value === Expression_1.Expression.imaginary) {
+            if (realPart.isFunction(constants_1.ATAN)) {
+                return realPart;
+            }
+            return realPart.times(t.getMultiplier());
+        }
+        if (complexPart.isFunction(constants_1.ATAN) &&
+            complexPart.getArguments()[0].value === Expression_1.Expression.imaginary) {
+            const arg = complexPart.getArguments()[0];
+            return Expression_1.Expression.toFunction(constants_1.ATANH, [
+                Expression_1.Expression.fromRational(arg.getMultiplier()),
+            ]).times(t.getMultiplier());
+        }
+    }
+    if (x.isE()) {
+        const p = x.getPower();
+        const m = x.getMultiplier();
+        if (p.isComplex()) {
+            const theta = toTheta(p);
+            if (theta) {
+                retval = (0, trig_1.cos)(theta).times(m).plus((0, trig_1.sin)(theta).times(m).i());
+            }
+        }
+    }
+    else if (x.isProduct()) {
+        let result = Expression_1.Expression.fromRational(x.getMultiplier());
+        x.each((e) => {
+            result = result.times(rectForm(e));
+        });
+        retval = result;
+    }
+    else if (x.isSum()) {
+        let result = (0, shortcuts_1.zero)();
+        x.each((e) => {
+            result = result.plus(rectForm(e));
+        });
+        retval = result;
+    }
+    const result = retval ? retval.expand() : x.isComplex() ? x.evaluate() : x;
+    return result;
+}
+/**
+ * Returns the argument of an expression
+ *
+ * @param x
+ * @returns
+ */
+function arg(x) {
+    x = Expression_1.Expression.create(x);
+    const [, theta] = toPolarFormArray(x);
+    return theta;
+}
+/**
+ * Returns the complex conjugate of an expression.
+ * For a complex number z = a + bi, the conjugate is a - bi.
+ * Distributes over sums, products, integer powers, and powers whose
+ * constant base is known not to lie on the principal logarithm's branch cut.
+ *
+ * @param expr - The expression to conjugate
+ * @returns The complex conjugate of the expression
+ *
+ * @example
+ * conjugate('3+2*i')    // 3-2*i
+ * conjugate('i')        // -i
+ * conjugate('a+b*i')    // a-b*i
+ * conjugate('(1+i)^i')  // (1-i)^(-i)
+ */
+function conjugate(x) {
+    x = Expression_1.Expression.create(x);
+    const expr = (0, expand_1.expand)(x);
+    let retval = undefined;
+    const p = expr.getPower();
+    // A power belongs to the whole expression, even when the base is stored as
+    // a SUM, PRD, or VAR rather than an EXP node. Handle that before distributing
+    // conjugation through the underlying structure. NUM uses a synthetic power of
+    // zero, so it must remain a terminal real value rather than entering this path.
+    if (expr.isEXP() || (!expr.isNUM() && !p.isOne())) {
+        const multiplier = Expression_1.Expression.fromRational(expr.getMultiplier());
+        const base = expr.getBase();
+        const re = realPart(base);
+        const im = imagPart(base);
+        const knownOffBranchCut = re.isConstant() &&
+            im.isConstant() &&
+            (!im.isZero() || (!re.isZero() && re.sign() > 0));
+        if (p.isInteger() || knownOffBranchCut) {
+            const conjBase = conjugate(base);
+            const conjPow = p.isComplex() ? conjugate(p) : p;
+            retval = multiplier.times(conjBase.pow(conjPow));
+        }
+        else {
+            retval = Expression_1.Expression.toFunction(constants_1.CONJUGATE, [expr]);
+        }
+    }
+    else if (expr.isVAR() && expr.isI()) {
+        retval = expr.neg();
+    }
+    else if (expr.isSum()) {
+        retval = (0, shortcuts_1.zero)();
+        for (const e of expr.elementsArray()) {
+            retval = retval.plus(conjugate(e));
+        }
+    }
+    else if (expr.isProduct()) {
+        retval = Expression_1.Expression.fromRational(expr.getMultiplier());
+        for (const e of expr.elementsArray()) {
+            retval = retval.times(conjugate(e));
+        }
+    }
+    return retval ?? x;
+}
+/**
+ * Returns the complex signum (csgn) of an expression, following the
+ * Maple/SymPy convention. Returns 1 if Re(z) > 0, -1 if Re(z) < 0,
+ * and sgn(Im(z)) if Re(z) = 0. Returns 0 for z = 0.
+ *
+ * For expressions containing free variables where the sign cannot be
+ * determined, returns an unevaluated symbolic csgn(z).
+ *
+ * Useful for branch cut decisions in sqrt, log, and power simplification.
+ *
+ * @param expr - The expression to evaluate the complex sign of
+ * @returns 1, -1, 0, or an unevaluated csgn expression
+ *
+ * @example
+ * csgn('3+2*i')   // 1
+ * csgn('-1+3*i')  // -1
+ * csgn('2*i')     // 1
+ * csgn('-5*i')    // -1
+ * csgn('0')       // 0
+ * csgn('x+2*i')   // csgn(x+2*i)
+ */
+function csgn(x) {
+    x = Expression_1.Expression.create(x);
+    const expr = (0, expand_1.expand)(x);
+    const re = realPart(expr);
+    const im = imagPart(expr);
+    let retval = undefined;
+    if (re.isZero() && im.isZero()) {
+        retval = (0, shortcuts_1.zero)();
+    }
+    else if (!re.isZero() && re.isConstant()) {
+        retval = re.sign() > 0 ? (0, shortcuts_1.one)() : (0, shortcuts_1.minusOne)();
+    }
+    else if (re.isZero() && im.isConstant()) {
+        retval = im.sign() > 0 ? (0, shortcuts_1.one)() : (0, shortcuts_1.minusOne)();
+    }
+    return retval ?? Expression_1.Expression.toFunction(constants_1.CSGN, [expr]);
+}

package/output/core/functions/decimal.d.ts

@@ -0,0 +1,24 @@
+import Decimal from 'decimal.js';
+import type { DecimalType } from '../classes/parser/types';
+export declare const EULER_GAMMA: Decimal;
+export declare function erf(x: DecimalType): Decimal;
+/**
+ * The gamma function using Spouge approximation.
+ * This function is slow converging but appropriate for arbitrary precision. It relies on Decimal.js.
+ *
+ * Ported from: https://rosettacode.org/wiki/Gamma_function#C++ (the implementation)
+ * https://math.stackexchange.com/questions/2204020/definition-of-the-gamma-function-for-non-integer-negative-values (negative gamma)
+ * https://en.wikipedia.org/wiki/Spouge%27s_approximation (Spouge's Approximation)
+ *
+ * @param n The number of elements to be calculated in the coefficient array
+ * @param x The number being evaluated
+ * @returns
+ */
+export declare function gamma(x: DecimalType): Decimal;
+export declare function sinc(x: DecimalType): Decimal;
+export declare function Si(x: DecimalType): Decimal;
+export declare function Shi(x: DecimalType): Decimal;
+export declare function Ci(x: DecimalType): Decimal;
+export declare function Chi(x: DecimalType): Decimal;
+export declare function Ei(x: DecimalType): Decimal;
+export declare function Li(x: DecimalType): Decimal;