nerdamer 1.1.13 → 2.0.0-rc.1

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

@@ -0,0 +1,461 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assume = void 0;
+exports.equal = equal;
+exports.gt = gt;
+exports.gte = gte;
+exports.lt = lt;
+exports.lte = lte;
+const errors_1 = require("../../../errors");
+const rationalNormalization_1 = require("../../../functions/rationalNormalization");
+const assume_1 = require("../../assumption/assume");
+const Expression_1 = require("../../expression/Expression");
+const multiply_1 = require("./multiply");
+const subtract_1 = require("./subtract");
+var assume_2 = require("../../assumption/assume");
+Object.defineProperty(exports, "assume", { enumerable: true, get: function () { return assume_2.assume; } });
+function getAffineForm(x) {
+    let retval = undefined;
+    if (!x.isComplex() && x.getPower().isOne()) {
+        if (x.isVAR()) {
+            if ((0, assume_1.getAssumptionFor)(x.value)) {
+                retval = {
+                    coefficient: Expression_1.Expression.fromRational(x.getMultiplier()),
+                    constant: Expression_1.Expression.Number(0),
+                    symbol: x.value,
+                };
+            }
+        }
+        else if (x.isSum()) {
+            const terms = x.elementsArray();
+            let symbol = undefined;
+            let valid = true;
+            for (const term of terms) {
+                if (term.isNUM()) {
+                    continue;
+                }
+                if (!term.isVAR() || !term.getPower().isOne()) {
+                    valid = false;
+                    break;
+                }
+                if (symbol === undefined) {
+                    symbol = term.value;
+                    if (!(0, assume_1.getAssumptionFor)(symbol)) {
+                        valid = false;
+                        break;
+                    }
+                }
+                else if (symbol !== term.value) {
+                    valid = false;
+                    break;
+                }
+            }
+            if (valid && symbol !== undefined) {
+                let coefficient = Expression_1.Expression.Number(0);
+                let constant = Expression_1.Expression.Number(0);
+                for (const term of terms) {
+                    if (term.isNUM()) {
+                        constant = constant.plus(term);
+                    }
+                    else {
+                        coefficient = coefficient.plus(Expression_1.Expression.fromRational(term.getMultiplier()));
+                    }
+                }
+                if (!coefficient.isZero()) {
+                    retval = { coefficient, constant, symbol };
+                }
+            }
+        }
+    }
+    return retval;
+}
+function compareAffineToValue(x, value, relation) {
+    const affine = getAffineForm(x);
+    let retval = undefined;
+    if (affine) {
+        const assumption = (0, assume_1.getAssumptionFor)(affine.symbol);
+        if (assumption) {
+            const bound = value.minus(affine.constant).div(affine.coefficient);
+            let resolvedRelation = relation;
+            if (affine.coefficient.getMultiplier().isNegative()) {
+                if (relation === 'gt') {
+                    resolvedRelation = 'lt';
+                }
+                else if (relation === 'gte') {
+                    resolvedRelation = 'lte';
+                }
+                else if (relation === 'lt') {
+                    resolvedRelation = 'gt';
+                }
+                else {
+                    resolvedRelation = 'gte';
+                }
+            }
+            retval = assumption[resolvedRelation](bound);
+        }
+    }
+    return retval;
+}
+function compareAffineExpressions(a, b, relation) {
+    let retval = undefined;
+    const aCandidate = a.isSum() || (a.isVAR() && !a.isPlainVariable());
+    const bCandidate = b.isSum() || (b.isVAR() && !b.isPlainVariable());
+    if (aCandidate && b.isNUM()) {
+        retval = compareAffineToValue(a, b, relation);
+    }
+    else if (a.isNUM() && bCandidate) {
+        let reversedRelation;
+        if (relation === 'gt') {
+            reversedRelation = 'lt';
+        }
+        else if (relation === 'gte') {
+            reversedRelation = 'lte';
+        }
+        else if (relation === 'lt') {
+            reversedRelation = 'gt';
+        }
+        else {
+            reversedRelation = 'gte';
+        }
+        retval = compareAffineToValue(b, a, reversedRelation);
+    }
+    return retval;
+}
+function getAffineSign(x) {
+    const affine = getAffineForm(x);
+    let retval = undefined;
+    if (affine) {
+        const assumption = (0, assume_1.getAssumptionFor)(affine.symbol);
+        if (assumption) {
+            const bound = affine.constant.neg().div(affine.coefficient);
+            const coefficientIsNegative = affine.coefficient.getMultiplier().isNegative();
+            const positive = coefficientIsNegative ? assumption.lt(bound) : assumption.gt(bound);
+            const negative = coefficientIsNegative ? assumption.gt(bound) : assumption.lt(bound);
+            if (positive === true) {
+                retval = 1;
+            }
+            else if (negative === true) {
+                retval = -1;
+            }
+            else if (assumption.eq(bound) === true) {
+                retval = 0;
+            }
+        }
+    }
+    return retval;
+}
+/**
+ * Returns a sign only when it can be proved from numeric values, assumptions, or
+ * simple multiplicative structure. Unknown symbolic signs stay unknown.
+ */
+function getProvenSign(x) {
+    let retval = undefined;
+    if (!x.isComplex()) {
+        if (x.isNUM()) {
+            retval = x.getMultiplier().sign();
+        }
+        else {
+            const multiplierSign = x.getMultiplier().sign();
+            const exponent = x.getPower();
+            if (multiplierSign === 0) {
+                retval = 0;
+            }
+            else if (!exponent.isOne() && exponent.isNUM()) {
+                // Powers are stored directly on many node types, not only EXP nodes.
+                // Use the common base-extraction API so x^-1, (x*y)^2, and explicit
+                // EXP nodes all follow the same sign reasoning.
+                const base = x.toLinearAndUnitMultiplier();
+                const baseSign = getProvenSign(base);
+                let poweredSign = undefined;
+                if (baseSign === 1) {
+                    poweredSign = 1;
+                }
+                else if (baseSign === -1 && exponent.isInteger()) {
+                    poweredSign = exponent.isEven() ? 1 : -1;
+                }
+                else if (baseSign === 0 && exponent.getMultiplier().gt('0')) {
+                    poweredSign = 0;
+                }
+                if (poweredSign !== undefined) {
+                    retval = (multiplierSign * poweredSign);
+                }
+            }
+            else if (x.isProduct()) {
+                let productSign = multiplierSign;
+                let allKnown = true;
+                for (const element of x.elementsArray()) {
+                    const elementSign = getProvenSign(element);
+                    if (elementSign === undefined) {
+                        allKnown = false;
+                        break;
+                    }
+                    productSign *= elementSign;
+                    if (productSign === 0) {
+                        break;
+                    }
+                }
+                if (allKnown) {
+                    retval = productSign;
+                }
+            }
+            if (retval === undefined && exponent.isOne()) {
+                const base = x.toLinearAndUnitMultiplier();
+                const assumption = (0, assume_1.getAssumptionFor)(base);
+                if (assumption) {
+                    const zero = Expression_1.Expression.Number(0);
+                    let assumedSign = undefined;
+                    if (assumption.gt(zero) === true) {
+                        assumedSign = 1;
+                    }
+                    else if (assumption.lt(zero) === true) {
+                        assumedSign = -1;
+                    }
+                    else if (assumption.eq(zero) === true) {
+                        assumedSign = 0;
+                    }
+                    if (assumedSign !== undefined) {
+                        retval = (multiplierSign * assumedSign);
+                    }
+                }
+                else if (x.isSum() && (0, assume_1.hasAssumptions)()) {
+                    retval = getAffineSign(x);
+                }
+            }
+        }
+    }
+    return retval;
+}
+/**
+ * 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.
+ */
+function equal(a, b) {
+    a = Expression_1.Expression.create(a);
+    b = Expression_1.Expression.create(b);
+    const sameVariable = a.isPlainVariable() && b.isPlainVariable() && a.value === b.value;
+    const x = (0, assume_1.getAssumptionFor)(a);
+    const y = (0, assume_1.getAssumptionFor)(b);
+    let assumptionResult = undefined;
+    let retval;
+    // An assumption describes the admissible values of a variable; it does not erase
+    // the identity of the variable itself. x == x remains true even when x ranges over
+    // more than one value.
+    if (sameVariable) {
+        retval = true;
+    }
+    else {
+        if (x && y) {
+            assumptionResult = x.eq(y);
+        }
+        else if (x) {
+            assumptionResult = x.eq(b);
+        }
+        else if (y) {
+            assumptionResult = y.eq(a);
+        }
+        if (assumptionResult !== undefined) {
+            retval = assumptionResult;
+        }
+        else {
+            let result;
+            // Try the cheap comparison first. If they're NUM just extract the difference.
+            if (a.isNUM() && b.isNUM()) {
+                result = (0, subtract_1.subtract)(a, b);
+            }
+            else {
+                // Canonicalize numeric radicals so equivalent exact forms compare consistently.
+                a = (0, multiply_1.canonicalizeRadicals)(a);
+                b = (0, multiply_1.canonicalizeRadicals)(b);
+                result = (0, rationalNormalization_1.toCommonDenominator)((0, subtract_1.subtract)(a, b).expand()).expand();
+            }
+            retval = result.isNUM() && result.getMultiplier().eq('0');
+        }
+    }
+    return retval;
+}
+/** Checks whether Nerdamer can establish that `a` is strictly greater than `b`. */
+function gt(a, b) {
+    a = Expression_1.Expression.create(a);
+    b = Expression_1.Expression.create(b);
+    if (a.isComplex() || b.isComplex()) {
+        throw new errors_1.UnsupportedOperationError((0, errors_1.message)('unsupportedOperation'));
+    }
+    const x = (0, assume_1.getAssumptionFor)(a);
+    const y = (0, assume_1.getAssumptionFor)(b);
+    let assumptionResult = undefined;
+    let retval;
+    if (x && y) {
+        assumptionResult = x.gt(y);
+    }
+    else if (x) {
+        assumptionResult = x.gt(b);
+    }
+    else if (y) {
+        assumptionResult = y.lt(a);
+    }
+    if (assumptionResult !== undefined) {
+        retval = assumptionResult;
+    }
+    else {
+        let sign = undefined;
+        if (b.isZero()) {
+            sign = getProvenSign(a);
+        }
+        else if (a.isZero()) {
+            const rightSign = getProvenSign(b);
+            if (rightSign !== undefined) {
+                sign = -rightSign;
+            }
+        }
+        if (sign !== undefined) {
+            retval = sign > 0;
+        }
+        else {
+            const affineResult = (0, assume_1.hasAssumptions)() && !(a.isZero() || b.isZero())
+                ? compareAffineExpressions(a, b, 'gt')
+                : undefined;
+            if (affineResult !== undefined) {
+                retval = affineResult;
+            }
+            else {
+                // E.g. 9 > 6 is decided from the sign of 9 - 6.
+                const result = (0, subtract_1.subtract)(a.evaluate(), b.evaluate()).expand();
+                retval = result.isNUM() && result.getMultiplier().gt('0');
+            }
+        }
+    }
+    return retval;
+}
+/** Checks whether Nerdamer can establish that `a` is greater than or equal to `b`. */
+function gte(a, b) {
+    a = Expression_1.Expression.create(a);
+    b = Expression_1.Expression.create(b);
+    if (a.isComplex() || b.isComplex()) {
+        throw new errors_1.UnsupportedOperationError((0, errors_1.message)('unsupportedOperation'));
+    }
+    const sameVariable = a.isPlainVariable() && b.isPlainVariable() && a.value === b.value;
+    const x = (0, assume_1.getAssumptionFor)(a);
+    const y = (0, assume_1.getAssumptionFor)(b);
+    let assumptionResult = undefined;
+    let retval;
+    if (sameVariable) {
+        retval = true;
+    }
+    else {
+        if (x && y) {
+            assumptionResult = x.gte(y);
+        }
+        else if (x) {
+            assumptionResult = x.gte(b);
+        }
+        else if (y) {
+            assumptionResult = y.lte(a);
+        }
+        if (assumptionResult !== undefined) {
+            retval = assumptionResult;
+        }
+        else {
+            const affineResult = (0, assume_1.hasAssumptions)()
+                ? compareAffineExpressions(a, b, 'gte')
+                : undefined;
+            retval = affineResult === undefined ? gt(a, b) || equal(a, b) : affineResult;
+        }
+    }
+    return retval;
+}
+/** Checks whether Nerdamer can establish that `a` is strictly less than `b`. */
+function lt(a, b) {
+    a = Expression_1.Expression.create(a);
+    b = Expression_1.Expression.create(b);
+    if (a.isComplex() || b.isComplex()) {
+        throw new errors_1.UnsupportedOperationError((0, errors_1.message)('unsupportedOperation'));
+    }
+    const x = (0, assume_1.getAssumptionFor)(a);
+    const y = (0, assume_1.getAssumptionFor)(b);
+    let assumptionResult = undefined;
+    let retval;
+    if (x && y) {
+        assumptionResult = x.lt(y);
+    }
+    else if (x) {
+        assumptionResult = x.lt(b);
+    }
+    else if (y) {
+        assumptionResult = y.gt(a);
+    }
+    if (assumptionResult !== undefined) {
+        retval = assumptionResult;
+    }
+    else {
+        let sign = undefined;
+        if (b.isZero()) {
+            sign = getProvenSign(a);
+        }
+        else if (a.isZero()) {
+            const rightSign = getProvenSign(b);
+            if (rightSign !== undefined) {
+                sign = -rightSign;
+            }
+        }
+        if (sign !== undefined) {
+            retval = sign < 0;
+        }
+        else {
+            const affineResult = (0, assume_1.hasAssumptions)() && !(a.isZero() || b.isZero())
+                ? compareAffineExpressions(a, b, 'lt')
+                : undefined;
+            if (affineResult !== undefined) {
+                retval = affineResult;
+            }
+            else {
+                // E.g. 6 < 9 is decided from the sign of 6 - 9.
+                const result = (0, subtract_1.subtract)(a.evaluate(), b.evaluate()).expand();
+                retval = result.isNUM() && result.getMultiplier().lt('0');
+            }
+        }
+    }
+    return retval;
+}
+/** Checks whether Nerdamer can establish that `a` is less than or equal to `b`. */
+function lte(a, b) {
+    a = Expression_1.Expression.create(a);
+    b = Expression_1.Expression.create(b);
+    if (a.isComplex() || b.isComplex()) {
+        throw new errors_1.UnsupportedOperationError((0, errors_1.message)('unsupportedOperation'));
+    }
+    const sameVariable = a.isPlainVariable() && b.isPlainVariable() && a.value === b.value;
+    const x = (0, assume_1.getAssumptionFor)(a);
+    const y = (0, assume_1.getAssumptionFor)(b);
+    let assumptionResult = undefined;
+    let retval;
+    if (sameVariable) {
+        retval = true;
+    }
+    else {
+        if (x && y) {
+            assumptionResult = x.lte(y);
+        }
+        else if (x) {
+            assumptionResult = x.lte(b);
+        }
+        else if (y) {
+            assumptionResult = y.gte(a);
+        }
+        if (assumptionResult !== undefined) {
+            retval = assumptionResult;
+        }
+        else {
+            const affineResult = (0, assume_1.hasAssumptions)()
+                ? compareAffineExpressions(a, b, 'lte')
+                : undefined;
+            retval = affineResult === undefined ? lt(a, b) || equal(a, b) : affineResult;
+        }
+    }
+    return retval;
+}

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

@@ -0,0 +1,2 @@
+import { Expression } from '../../expression/Expression';
+export declare function divide(a: Expression, b: Expression): Expression;

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

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.divide = divide;
+const errors_1 = require("../../../errors");
+const Settings_1 = require("../../../Settings");
+const Expression_1 = require("../../expression/Expression");
+const shortcuts_1 = require("../../expression/shortcuts");
+const multiply_1 = require("./multiply");
+const power_1 = require("./power");
+function divide(a, b) {
+    let retval;
+    if (Settings_1.Settings.DEFER_SIMPLIFICATION) {
+        // Explicitly add a power to a NUM so it can be inverted.
+        if (b.isNUM()) {
+            b.power = (0, shortcuts_1.one)();
+        }
+        retval = div(a, b);
+        retval.deferred = true;
+    }
+    else {
+        // Disallow division by zero
+        if (b.isZero()) {
+            throw new errors_1.DivisionByZeroError((0, errors_1.message)('divisionByZero'));
+        }
+        if (a.isZero() && !b.isInf()) {
+            retval = Expression_1.Expression.Number('0');
+        }
+        else if (a.isNUM() && b.isNUM()) {
+            retval = Expression_1.Expression.fromRational(a.getMultiplier().div(b.getMultiplier()));
+        }
+        else if (b.isNUM()) {
+            retval = a.copy(); // create a new copy
+            const multiplier = a.getMultiplier().div(b.getMultiplier());
+            retval.multiplier = multiplier;
+        }
+        else if (a.isComplex() || b.isComplex()) {
+            const realA = a.realPart();
+            const realB = b.realPart();
+            const imA = a.imagPart();
+            const imB = b.imagPart();
+            const den = realB.sq().plus(imB.sq());
+            const re = realA.times(realB).plus(imA.times(imB)).div(den);
+            const im = imA.times(realB).minus(realA.times(imB)).div(den).times(Expression_1.Expression.Img());
+            return re.plus(im);
+        }
+        else if (b.isInf() && !a.isZero()) {
+            if (!b.getMultiplier().isNegative() && !a.isInf()) {
+                retval = Expression_1.Expression.Number('0');
+            }
+        }
+        else {
+            retval = div(a, b);
+            // Only rationalize if the result is a simple numeric radical
+            // e.g. 1/sqrt(2) → sqrt(2)/2
+            // Don't rationalize complex products or higher roots where it makes things worse
+            if (retval.isEXP() && retval.hasRadical()) {
+                retval = (0, power_1.rationalizeRadical)(retval);
+            }
+        }
+        if (!retval) {
+            throw new errors_1.UndefinedError((0, errors_1.message)('undefinedDivision', { type: `${a}/${b}` }));
+        }
+    }
+    return retval;
+}
+function div(a, b) {
+    b = b.copy();
+    // Negate and send it to multiplier
+    b.power = b.getPower().neg();
+    b.multiplier = b.getMultiplier().invert();
+    return (0, multiply_1.multiply)(a, b);
+}

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

@@ -0,0 +1,46 @@
+import { Equation } from '../../equation/Equation';
+import { Matrix } from '../../matrix/Matrix';
+import { Vector } from '../../vector/Vector';
+import { comma } from './comma';
+import type { ParserEntity } from '../../../types';
+import type { Operation, PreFixFunction, PostFixFunction, EquationConstructorCall, CommaOperation, DeferredFunctionArgument, DeferredOperation } from '../types';
+/**
+ * The wrapper used to call functions within the parser.
+ *
+ * @param functionName The name of the function being called
+ * @param args
+ * @returns
+ */
+export declare function callFunction(functionName: string, args: (ParserEntity | DeferredFunctionArgument)[]): ParserEntity;
+/**
+ * Combines all base operations into one object for parser.
+ */
+export declare const _: {
+    [functionName: string]: Operation | DeferredOperation | PreFixFunction | PostFixFunction | EquationConstructorCall | CommaOperation;
+};
+/**
+ * Applies a scalar function over a copied Vector or Matrix while preserving its shape.
+ * Matrix cells must remain Expressions because Matrix does not permit aggregate elements.
+ */
+export declare function distribute(fn: (v: ParserEntity, i: number, j?: number) => ParserEntity, structure: Vector | Matrix): Vector | Matrix;
+/**
+ * Set's one expression equal to the other
+ * @param a
+ * @param b
+ * @returns
+ */
+export declare function setEqual(a: ParserEntity, b: ParserEntity): Equation;
+/**
+ * Registers a symbolic function from a deferred declaration body.
+ *
+ * The parser preserves the declaration as the parameter expressions followed by
+ * the function name. Each part of the signature must remain a plain variable. The
+ * right-hand callback owns compiled parser RPN and is executed only when the registered
+ * function is called.
+ *
+ * @param a - Deferred function signature.
+ * @param body - Deferred symbolic function body.
+ * @returns The registered function signature.
+ */
+export declare function functionAssign(a: ParserEntity, body: DeferredFunctionArgument): ParserEntity;
+export declare function route(a: ParserEntity, b: ParserEntity, operation: string): ParserEntity | ReturnType<typeof comma>;