nerdamer 1.1.13 → 2.0.0-rc.2

package/output/core/classes/parser/helpers.d.ts

@@ -0,0 +1,21 @@
+import { scopedBlock } from '../../Settings';
+import { Expression } from '../expression/Expression';
+import type { ExpressionInput, StructuredEntityType } from '../../types';
+import type { ParserValuesObject } from './types';
+export { scopedBlock };
+/**
+ * Forces the expression to be evaluated
+ *
+ * @param expression The expression to be evaluated
+ * @param values The values to be substituted
+ * @returns
+ */
+export declare function evaluate(expression: string, values?: ParserValuesObject): import("../../types").ParserEntity;
+export declare function inert(expression: string): import("../../types").ParserEntity;
+export declare function _(expr: ExpressionInput): Expression;
+/**
+ * Returns true if the object is a structured entity
+ * @param obj
+ * @returns
+ */
+export declare function isStructuredEntity(obj: unknown): obj is StructuredEntityType;

package/output/core/classes/parser/helpers.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scopedBlock = void 0;
+exports.evaluate = evaluate;
+exports.inert = inert;
+exports._ = _;
+exports.isStructuredEntity = isStructuredEntity;
+const Settings_1 = require("../../Settings");
+Object.defineProperty(exports, "scopedBlock", { enumerable: true, get: function () { return Settings_1.scopedBlock; } });
+const Expression_1 = require("../expression/Expression");
+const Parser_1 = require("./Parser");
+/**
+ * Forces the expression to be evaluated
+ *
+ * @param expression The expression to be evaluated
+ * @param values The values to be substituted
+ * @returns
+ */
+function evaluate(expression, values) {
+    return Parser_1.Parser.evaluate(expression, values);
+}
+function inert(expression) {
+    return (0, Settings_1.scopedBlock)('EVALUATE', false, () => {
+        return (0, Settings_1.scopedBlock)('SUBSTITUTE', false, () => {
+            return Parser_1.Parser.parse(expression);
+        });
+    });
+}
+function _(expr) {
+    return Expression_1.Expression.create(expr);
+}
+/**
+ * Returns true if the object is a structured entity
+ * @param obj
+ * @returns
+ */
+function isStructuredEntity(obj) {
+    if (typeof obj === 'undefined') {
+        return false;
+    }
+    return obj.isEnumerable;
+}

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

@@ -0,0 +1,15 @@
+import { Expression } from '../../expression/Expression';
+export declare function add(a: Expression, b: Expression): Expression;
+export declare function addPrefix(a: Expression): Expression;
+/**
+ * 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
+ */
+export declare function join(a: Expression, b: Expression, isGroup?: boolean): Expression;

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

@@ -0,0 +1,236 @@
+"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 only when an operand can actually change. distributeMultiplier()
+        // returns an independent deep copy, so calling it for ordinary operands adds
+        // substantial copy work without affecting the result.
+        if (Expression_1.Expression.DISTRIBUTE_MULTIPLIER) {
+            if (a.isSum() && !a.getMultiplier().isOne() && a.isLinear()) {
+                a = a.distributeMultiplier();
+            }
+            if (b.isSum() && !b.getMultiplier().isOne() && b.isLinear()) {
+                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 = b.copy();
+        }
+        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 {
+                const multiplier = a.getMultiplier().plus(b.getMultiplier());
+                if (multiplier.isZero()) {
+                    retval = Expression_1.Expression.Number('0');
+                }
+                else if (a.isSum() && b.isSum() && a.isLinear() && b.isLinear()) {
+                    retval = join(a, b);
+                }
+                else {
+                    retval = a.copy();
+                    retval.multiplier = multiplier;
+                }
+            }
+        }
+        // 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 derived aggregate state after the element collection changes.
+            retval.updateValue(elements);
+        }
+    }
+    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;