nerdamer 1.1.13 → 2.0.0-rc.1

package/output/core/classes/parser/operations/add.js

@@ -0,0 +1,238 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.add = add;
+exports.addPrefix = addPrefix;
+exports.join = join;
+const errors_1 = require("../../../errors");
+const Settings_1 = require("../../../Settings");
+const Expression_1 = require("../../expression/Expression");
+const constants_1 = require("../constants");
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const { NUM, VAR, EXP, FUN, GRP, PRD, SUM, INF } = constants_1.EXPRESSION_TYPES;
+function add(a, b) {
+    let retval;
+    if (Settings_1.Settings.DEFER_SIMPLIFICATION) {
+        retval = join(a, b, false);
+        retval.deferred = true;
+    }
+    else {
+        const keyA = a.keyValue();
+        const keyB = b.keyValue();
+        // Distribute the multiplier if true
+        if (Expression_1.Expression.DISTRIBUTE_MULTIPLIER) {
+            a = a.distributeMultiplier();
+            b = b.distributeMultiplier();
+        }
+        // It suffices to check if their keyValues are the same since x+x will be handled.
+        // We're only dealing with x^n+x^(!n) at this point.
+        const isGroup = !a.isNUM() && keyA === keyB;
+        if (a.isNUM() && b.isNUM()) {
+            retval = Expression_1.Expression.fromRational(a.getMultiplier().plus(b.getMultiplier()));
+        }
+        else if (a.isComplex() && b.isComplex()) {
+            const re = a.realPart().plus(b.realPart());
+            const im = a.imagPart().plus(b.imagPart()).times(Expression_1.Expression.Img());
+            // Do a zero check here rather than placing that additional burden on join.
+            retval = re.isZero() ? im : im.isZero() ? re : join(re, im); // Don't use add
+        }
+        else if (a.isZero()) {
+            retval = Expression_1.Expression.create(b);
+        }
+        else if (a.value === b.value && a.type === b.type && a.getPower().eq(b.getPower())) {
+            // Infinity has no finite coefficient magnitude. Same-sign infinities remain
+            // canonical infinity, while opposite signs are undefined.
+            if (a.isInf()) {
+                const x = a.getMultiplier();
+                const y = b.getMultiplier();
+                if ((x.isNegative() && !y.isNegative()) || (y.isNegative() && !x.isNegative())) {
+                    throw new errors_1.UndefinedError((0, errors_1.message)('infinityMinusInfinityUndefined'));
+                }
+                retval = a.isNegInf() ? Expression_1.Expression.NegInf() : Expression_1.Expression.Inf();
+            }
+            else {
+                retval = Expression_1.Expression.create(a);
+                const multiplier = a.getMultiplier().plus(b.getMultiplier());
+                if (multiplier.isZero()) {
+                    retval = Expression_1.Expression.Number('0');
+                }
+                if (a.isSum() && b.isSum() && a.isLinear() && b.isLinear()) {
+                    retval = join(a, b);
+                }
+                else {
+                    retval.multiplier = multiplier;
+                    if (retval.power) {
+                        // We can do this since a.power === b.power
+                        retval = Expression_1.Expression.setPower(retval, a.getPower().copy());
+                    }
+                }
+                // Put back the power
+                if (a.power) {
+                    retval = Expression_1.Expression.setPower(retval, a.getPower().copy());
+                }
+            }
+        }
+        // Since we've already check for equal power and value we're not dealing with groups
+        // These are stored by power rather than their value so x^n+x^(n+1) will be stored as
+        // {n: x^n, n+1: x^(n+1)} for any power !== 0
+        else if (isGroup) {
+            retval = join(a, b, isGroup);
+        }
+        else if (a.isInf() && b.isInf()) {
+            const x = a.getMultiplier();
+            const y = b.getMultiplier();
+            if ((x.isNegative() && !y.isNegative()) || (y.isNegative() && !x.isNegative())) {
+                throw new errors_1.UndefinedError((0, errors_1.message)('infinityMinusInfinityUndefined'));
+            }
+        }
+        // We can just flip because of commutativity. Add can figure out the rest.
+        // ******************** RECIPROCALS ******************** //
+        else if (constants_1.RANK[a.type] > constants_1.RANK[b.type]) {
+            retval = add(b, a);
+        }
+        // This is a catch all for all unhandled cases so do not use else above.
+        retval = retval || join(a, b, isGroup);
+    }
+    return retval;
+}
+function addPrefix(a) {
+    // This does nothing but return the Expression
+    return a;
+}
+function canJoin(a, b) {
+    // In order for SUM or GRP to be able to join, it needs to have a multiplier and a power of one
+    return (
+    // Any value can be added to SUM
+    (a.type === SUM ||
+        // b can only be added to a if the keyValue matches
+        (a.type === GRP && a.keyValue() === b.keyValue())) &&
+        // Both the power and multiplier must be one, basically it's wrapped in parentheses
+        a.isLinear() &&
+        (!a.multiplier || (a.multiplier && a.getMultiplier().isOne())));
+}
+/**
+ * This method is not designed for cases where a = b; This should be handled before getting here.
+ * This method only does element wise addition for powers of 1. For all else it just creates a new expression
+ * and puts them in a new container.
+ *
+ * @param a
+ * @param b
+ * @param action
+ * @param skipAction
+ * @returns
+ */
+function join(a, b, isGroup = false) {
+    let retval;
+    let elements = [];
+    const expressionType = isGroup ? GRP : SUM;
+    let aCanJoin = canJoin(a, b);
+    let bCanJoin = canJoin(b, a);
+    // Always keep the joinable expression on the right
+    if (aCanJoin && !bCanJoin) {
+        [b, a] = [a, b]; // Swap them
+        [bCanJoin, aCanJoin] = [aCanJoin, bCanJoin]; // Swap the join condition
+    }
+    // Case 1: Neither has an expression object so make an empty container and append a copy of the second.
+    // If skipAction is true then it will just append and skip everything else. Remember, a != b
+    if (!bCanJoin) {
+        let asSubExpression = false;
+        // Case 1.a: We first get the keys and assume they're not sub-symbolics. For x^-1 and (x+x^2)^-1 for
+        // instance we get a tie. Not only are they key values the same, but so are their powers. They should
+        // be joined as sub-symbolics at this point. We perform this check to break the tie. We'll know this
+        // because we'll have two matching keys which shouldn't happen.
+        let keyA = a.keyValue(asSubExpression, isGroup);
+        let keyB = b.keyValue(asSubExpression, isGroup);
+        // Check for matching keys and recalculate the keys if that's the case
+        if (keyA === keyB) {
+            asSubExpression = true;
+            isGroup = false;
+            keyA = a.keyValue(asSubExpression, isGroup);
+            keyB = b.keyValue(asSubExpression, isGroup);
+        }
+        retval = Expression_1.Expression.Number('1');
+        retval.elements = {};
+        // Copy the elements
+        retval.elements[keyA] = a.copy();
+        retval.elements[keyB] = b.copy();
+        elements = [a, b];
+    }
+    // Case 2
+    // e.g. x + (x+1) or 2*(x+1) + (x+1)+y
+    else if (!aCanJoin && bCanJoin) {
+        retval = b.copy();
+        const subExpressions = retval.getElements();
+        // We start with the more restrictive assumption. Taking the example from case 1,
+        // we now have an expression in the form x^-1 + (x+x^2)^-1. The simpler from of the key
+        // would just be x but we first want to make sure we're not dealing with case 1.a
+        let asSubExpression = true;
+        let key = a.keyValue(asSubExpression, false);
+        // If no value was found then it's safe to use the less restrictive key so recalculate it
+        if (!(key in subExpressions)) {
+            asSubExpression = false;
+            key = a.keyValue(asSubExpression, isGroup);
+        }
+        // Append the expression or add it to any existing expression if there's one
+        if (key in subExpressions) {
+            const result = add(a, subExpressions[key]);
+            // It may have resulted in zero, so only add if that's not the case
+            if (!result.isZero()) {
+                subExpressions[key] = result;
+            }
+            else {
+                // Otherwise remove it
+                delete subExpressions[key];
+            }
+        }
+        else {
+            subExpressions[key] = a.copy();
+        }
+        elements = Object.values(subExpressions);
+    }
+    // Case 3
+    else {
+        retval = a.copy();
+        retval.multiplier = a.getMultiplier().times(b.getMultiplier());
+        const retvalExpressions = retval.getElements();
+        const bExpressions = b.getElements();
+        for (const x in bExpressions) {
+            const e = bExpressions[x];
+            if (x in retvalExpressions) {
+                const result = add(e, retvalExpressions[x]);
+                // Don't add it if it's zero
+                if (result.isZero()) {
+                    // Remove the entry if it's zero
+                    delete retvalExpressions[x];
+                }
+                else {
+                    retvalExpressions[x] = result;
+                }
+            }
+            else {
+                retvalExpressions[x] = e.copy();
+            }
+        }
+        elements = Object.values(retvalExpressions);
+    }
+    // Some cleanup. The expression may have now become a single element. We'll know this because
+    // the sub-elements will only be one element long. If that's the case then that become the reval
+    if ((retval.isSum() || retval.isProduct()) && elements.length === 1) {
+        const onlyElement = elements[0];
+        // Move the multiplier
+        if (retval.multiplier || onlyElement.multiplier) {
+            onlyElement.multiplier = onlyElement.getMultiplier().times(retval.getMultiplier());
+        }
+        retval = onlyElement;
+    }
+    else {
+        // If it's empty then the value is zero
+        if (elements.length === 0) {
+            retval = Expression_1.Expression.Number('0');
+        }
+        else {
+            // Set the type
+            retval.type = expressionType;
+            // Update the value
+            retval.value = Expression_1.Expression.getValue(elements, 'text', expressionType);
+        }
+    }
+    return retval;
+}

package/output/core/classes/parser/operations/comma.d.ts

@@ -0,0 +1,7 @@
+import type { ParserStackValue } from '../types';
+/**
+ * The comma is essentially a prefix operator that just returns the object.
+ *
+ * @param a
+ */
+export declare function comma(a: ParserStackValue, b: ParserStackValue): ParserStackValue[];

package/output/core/classes/parser/operations/comma.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.comma = comma;
+/**
+ * The comma is essentially a prefix operator that just returns the object.
+ *
+ * @param a
+ */
+function comma(a, b) {
+    return [a, b];
+}

package/output/core/classes/parser/operations/compare.d.ts

@@ -0,0 +1,21 @@
+import type { ExpressionInput } from '../../../types';
+export { assume } from '../../assumption/assume';
+/**
+ * Checks whether Nerdamer can establish that `a` and `b` are equal.
+ *
+ * @remarks
+ * The public expression comparison remains boolean for compatibility. Assumptions
+ * supply a result when they can prove or disprove the relation; an unknown assumption
+ * result falls through to the ordinary symbolic comparison. If neither path can prove
+ * equality, this function returns `false`. Use the corresponding `Assumption` relation
+ * directly when a caller needs to distinguish a disproved relation from an unknown one.
+ */
+export declare function equal(a: ExpressionInput, b: ExpressionInput): boolean;
+/** Checks whether Nerdamer can establish that `a` is strictly greater than `b`. */
+export declare function gt(a: ExpressionInput, b: ExpressionInput): boolean;
+/** Checks whether Nerdamer can establish that `a` is greater than or equal to `b`. */
+export declare function gte(a: ExpressionInput, b: ExpressionInput): boolean;
+/** Checks whether Nerdamer can establish that `a` is strictly less than `b`. */
+export declare function lt(a: ExpressionInput, b: ExpressionInput): boolean;
+/** Checks whether Nerdamer can establish that `a` is less than or equal to `b`. */
+export declare function lte(a: ExpressionInput, b: ExpressionInput): boolean;