nerdamer 1.1.13 → 2.0.0-rc.2

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

@@ -0,0 +1,438 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._ = void 0;
+exports.callFunction = callFunction;
+exports.distribute = distribute;
+exports.setEqual = setEqual;
+exports.functionAssign = functionAssign;
+exports.route = route;
+const math_1 = require("../../../../math/math");
+const structuredEntityUtils_1 = require("../../../common/functions/structuredEntityUtils");
+const dispatch_1 = require("../../../dispatch");
+const errors_1 = require("../../../errors");
+const setFunction_1 = require("../../../functions/setFunction");
+const Settings_1 = require("../../../Settings");
+const assertiveFunctions_1 = require("../../assumption/assertiveFunctions");
+const Collection_1 = require("../../collection/Collection");
+const Equation_1 = require("../../equation/Equation");
+const Expression_1 = require("../../expression/Expression");
+const utils_1 = require("../../expression/utils");
+const Matrix_1 = require("../../matrix/Matrix");
+const Vector_1 = require("../../vector/Vector");
+const constants_1 = require("../constants");
+const controlFlow_1 = require("../scripting/controlFlow");
+const functions_1 = require("../scripting/functions");
+const scope_1 = require("../scripting/scope");
+const add_1 = require("./add");
+const comma_1 = require("./comma");
+const divide_1 = require("./divide");
+const multiply_1 = require("./multiply");
+const power_1 = require("./power");
+const subtract_1 = require("./subtract");
+/**
+ * Invokes a function selected dynamically from the dispatch table. Registered functions do
+ * not share one parameter signature, so the parser cannot verify the argument types after
+ * resolving a function name at runtime. Arity has already been validated by `callFunction`.
+ */
+function invokeMathFunction(fn, args) {
+    const callable = fn;
+    return callable(...args);
+}
+/**
+ * The wrapper used to call functions within the parser.
+ *
+ * @param functionName The name of the function being called
+ * @param args
+ * @returns
+ */
+function callFunction(functionName, args) {
+    // An empty parser argument scope currently resolves to undefined. Normalize that internal
+    // sentinel before arity validation so registered zero-argument functions receive no arguments.
+    if (args.length === 1 && args[0] === undefined) {
+        args = [];
+    }
+    // The details regarding the function
+    const attributes = dispatch_1.mathFunctionRegistry[functionName];
+    if (attributes === undefined) {
+        throw new errors_1.ParserError((0, errors_1.message)('unsupportedFunction', { function: functionName }));
+    }
+    const { fn, minArgs, maxArgs, maxPrecision, equationArgs, distElWise, deferArguments, returnBoundary, } = attributes;
+    // Complain if the number of arguments provided is less that what is allowed
+    if (minArgs > -1 && args.length < minArgs) {
+        throw new errors_1.ParserError((0, errors_1.message)('functionMinArgs', {
+            function: functionName,
+            min: String(minArgs),
+            actual: String(args.length),
+        }));
+    }
+    // Complain if the number of arguments provided is greater than what is allowed
+    if (maxArgs > -1 && args.length > maxArgs) {
+        throw new errors_1.ParserError((0, errors_1.message)('functionMaxArgs', {
+            function: functionName,
+            max: String(maxArgs),
+            actual: String(args.length),
+        }));
+    }
+    let result;
+    if (deferArguments) {
+        // Deferred functions own the timing and frequency of argument evaluation.
+        const invoke = () => invokeMathFunction(fn, args);
+        result = returnBoundary ? (0, controlFlow_1.parserReturnBoundary)(invoke) : invoke();
+    }
+    else {
+        const entityArgs = [];
+        for (const arg of args) {
+            if (typeof arg === 'function') {
+                throw new errors_1.ParserError((0, errors_1.message)('malformedExpression'));
+            }
+            entityArgs.push(arg);
+        }
+        // A structured entity carrying symbolic bracket access represents one unresolved
+        // scalar value. Normalize it before equation checks, distribution, or invocation.
+        const normalizedArgs = entityArgs.map(arg => Expression_1.Expression.fromSymbolicAccess(arg) ?? arg);
+        if (attributes.level === 'system') {
+            for (let i = 0; i < normalizedArgs.length; i++) {
+                if (Equation_1.Equation.isEquation(normalizedArgs[i]) && !equationArgs?.includes(i)) {
+                    throw new errors_1.UnexpectedDataType((0, errors_1.message)('expressionExpected', { type: 'Equation' }));
+                }
+            }
+        }
+        const elementWiseArgs = distElWise
+            ? normalizedArgs.filter((arg) => Vector_1.Vector.isVector(arg) || Matrix_1.Matrix.isMatrix(arg))
+            : [];
+        if (elementWiseArgs.length > 0) {
+            const structure = elementWiseArgs[0];
+            for (const arg of elementWiseArgs) {
+                let dimensionsMatch;
+                if (Vector_1.Vector.isVector(structure)) {
+                    dimensionsMatch = Vector_1.Vector.isVector(arg) && structure.count() === arg.count();
+                }
+                else {
+                    dimensionsMatch = Matrix_1.Matrix.isMatrix(arg) && structure.dimensionsMatch(arg);
+                }
+                if (!dimensionsMatch) {
+                    throw new errors_1.DimensionError((0, errors_1.message)('mismatchedDimensions', { function: functionName }));
+                }
+            }
+            result = distribute((_element, i, j) => {
+                const scalarArgs = normalizedArgs.map(arg => {
+                    let scalarArg = arg;
+                    if (Vector_1.Vector.isVector(arg)) {
+                        scalarArg = arg.__get__([i]);
+                    }
+                    else if (Matrix_1.Matrix.isMatrix(arg)) {
+                        scalarArg = arg.get(i, j);
+                    }
+                    return scalarArg;
+                });
+                return callFunction(functionName, scalarArgs);
+            }, structure);
+        }
+        // Call and return
+        else if (!fn || Settings_1.Settings.DEFER_SIMPLIFICATION) {
+            result = Expression_1.Expression.toFunction(functionName, normalizedArgs);
+        }
+        else {
+            result = invokeMathFunction(fn, normalizedArgs);
+        }
+        // Ensure that this function always returns even if it's a symbolic function. This will
+        // occur if the function didn't return a value.
+        if (!result) {
+            result = Expression_1.Expression.toFunction(functionName, normalizedArgs);
+        }
+    }
+    // Let all future calls know that an inferior precision was used.
+    if (maxPrecision) {
+        result.precision = maxPrecision;
+    }
+    return result;
+}
+/**
+ * Combines all base operations into one object for parser.
+ */
+exports._ = {
+    plus: add_1.add,
+    minus: subtract_1.subtract,
+    times: multiply_1.multiply,
+    div: divide_1.divide,
+    pow: power_1.power,
+    mod: modulo,
+    percent: percentage,
+    // ASSERTIVE FUNCTIONS
+    assertEQ: assertiveFunctions_1.assertEQ,
+    assertGT: assertiveFunctions_1.assertGT,
+    assertGTE: assertiveFunctions_1.assertGTE,
+    assertLT: assertiveFunctions_1.assertLT,
+    assertLTE: assertiveFunctions_1.assertLTE,
+    comma: comma_1.comma,
+    assign: scope_1.assign,
+    functionAssign: functionAssign,
+    setEqual: setEqual,
+    lt: lt,
+    lte: lte,
+    eq: eq,
+    gt: gt,
+    gte: gte,
+    minusPrefix: subtract_1.subtractPrefix,
+    plusPrefix: add_1.addPrefix,
+    factorial: math_1.factorial,
+    doubleFactorial: math_1.doubleFactorial,
+    // dot: dot,
+    // IN: IN,
+};
+/**
+ * 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.
+ */
+function distribute(fn, structure) {
+    let retval;
+    if (Vector_1.Vector.isVector(structure)) {
+        retval = structure.copy().each((v, i) => {
+            return fn(v, i);
+        });
+    }
+    else {
+        retval = structure.copy().each((v, i, j) => {
+            const result = fn(v, Number(i), Number(j));
+            if (!Expression_1.Expression.isExpression(result)) {
+                throw new errors_1.UnexpectedDataType((0, errors_1.message)('expressionExpected', { type: constants_1.dataTypes[result.dataType] }));
+            }
+            return result;
+        });
+    }
+    return retval;
+}
+/**
+ * Set's one expression equal to the other
+ * @param a
+ * @param b
+ * @returns
+ */
+function setEqual(a, b) {
+    if (!(Expression_1.Expression.isExpression(a) || Expression_1.Expression.isExpression(b))) {
+        throw new errors_1.UnsupportedOperationError((0, errors_1.message)('unsupportedOperation'));
+    }
+    return new Equation_1.Equation(a, b);
+}
+/**
+ * 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.
+ */
+function functionAssign(a, body) {
+    if (!Collection_1.Collection.isCollection(a)) {
+        throw new errors_1.UnexpectedInputError((0, errors_1.message)('invalidFunctionDeclaration', { declaration: a.text() }));
+    }
+    const signature = [...a.getElements()];
+    const functionExpression = signature.pop();
+    if (!Expression_1.Expression.isExpression(functionExpression)) {
+        throw new errors_1.UnexpectedInputError((0, errors_1.message)('invalidFunctionDeclaration', { declaration: a.text() }));
+    }
+    const name = (0, utils_1.assertPlainVariableAndGetString)(functionExpression);
+    const args = signature.map(argument => {
+        if (!Expression_1.Expression.isExpression(argument)) {
+            throw new errors_1.UnexpectedInputError((0, errors_1.message)('plainVariableExpected', { input: argument.text() }));
+        }
+        return (0, utils_1.assertPlainVariableAndGetString)(argument);
+    });
+    (0, setFunction_1.setFunction)({
+        type: 'symbolic',
+        name,
+        minArgs: args.length,
+        maxArgs: args.length,
+        fn: (0, functions_1.wrappedFunction)(body, args),
+    });
+    return Expression_1.Expression.toFunction(name, args.map(argument => Expression_1.Expression.Variable(argument)));
+}
+/**
+ * Returns 1 if two values are equal otherwise 0
+ * @param a
+ * @param b
+ * @returns
+ */
+function eq(a, b) {
+    return Expression_1.Expression.create(Number(a.eq(b)));
+}
+/**
+ * Returns 1 if a is greater than b otherwise 0
+ * @param a
+ * @param b
+ * @returns
+ */
+function gt(a, b) {
+    return Expression_1.Expression.create(Number(a.gt(b)));
+}
+/**
+ * Returns 1 if a is less than b otherwise 0
+ * @param a
+ * @param b
+ * @returns
+ */
+function lt(a, b) {
+    return Expression_1.Expression.create(Number(a.lt(b)));
+}
+/**
+ * Computes the remainder for the parser's infix `%` operator.
+ *
+ * The symbolic implementation already lives on {@link Expression.mod}; this adapter keeps
+ * operator dispatch in the same parser layer as the other arithmetic operations.
+ */
+function modulo(a, b) {
+    if (!Expression_1.Expression.isExpression(a) || !Expression_1.Expression.isExpression(b)) {
+        throw new errors_1.UnsupportedOperationError((0, errors_1.message)('unsupportedOperation'));
+    }
+    return a.mod(b);
+}
+/**
+ * Converts an expression from percentage notation to its exact fractional value.
+ */
+function percentage(a) {
+    if (!Expression_1.Expression.isExpression(a)) {
+        throw new errors_1.UnsupportedOperationError((0, errors_1.message)('unsupportedOperation'));
+    }
+    const retval = a.div(100);
+    return retval;
+}
+/**
+ * Returns 1 if a is greater than or equal to b otherwise 0
+ * @param a
+ * @param b
+ * @returns
+ */
+function gte(a, b) {
+    return Expression_1.Expression.create(Number(a.gte(b)));
+}
+/**
+ * Returns 1 if a is less than or equal to b otherwise 0
+ * @param a
+ * @param b
+ * @returns
+ */
+function lte(a, b) {
+    return Expression_1.Expression.create(Number(a.lte(b)));
+}
+function isRoutedOperation(operation) {
+    return (operation === 'pow' ||
+        operation === 'times' ||
+        operation === 'div' ||
+        operation === 'minus' ||
+        operation === 'plus' ||
+        operation === 'eq' ||
+        operation === 'lt' ||
+        operation === 'lte' ||
+        operation === 'gt' ||
+        operation === 'gte');
+}
+function routeOperation(target, operand, operation) {
+    const retval = target[operation](operand);
+    return typeof retval === 'boolean' ? Expression_1.Expression.create(Number(retval)) : retval;
+}
+function dispatchDynamicOperation(a, b, operation) {
+    // Preserve the parser's historically loose dispatch for operator actions outside
+    // RoutedOperation. Tightening these actions may change existing runtime behavior.
+    const useA = a.isEnumerable || Equation_1.Equation.isEquation(a);
+    const target = useA ? a : b;
+    const operand = useA ? b : a;
+    const dynamicTarget = target;
+    const dynamicOperation = dynamicTarget[operation];
+    if (!dynamicOperation) {
+        throw new errors_1.UnsupportedOperationError((0, errors_1.message)('unsupportedOperation'));
+    }
+    const retval = dynamicOperation.call(target, operand);
+    // Wrap booleans since those are used both inside and outside of the parser
+    return typeof retval === 'boolean' ? Expression_1.Expression.create(Number(retval)) : retval;
+}
+function route(a, b, operation) {
+    let retval;
+    if (operation === 'assign') {
+        retval = (0, scope_1.assign)(a, b);
+    }
+    else if (operation === 'comma') {
+        retval = (0, comma_1.comma)(a, b);
+    }
+    else if (operation === 'in') {
+        // Membership is the infix form of contains(container, value), so reverse the operands.
+        retval = callFunction('contains', [b, a]);
+    }
+    else if (isRoutedOperation(operation)) {
+        if (Equation_1.Equation.isEquation(a) || Equation_1.Equation.isEquation(b)) {
+            if (Equation_1.Equation.isEquation(a) && Equation_1.Equation.isEquation(b)) {
+                if (['eq', 'lt', 'lte', 'gt', 'gte'].includes(operation)) {
+                    retval = dispatchDynamicOperation(a, b, operation);
+                }
+                else {
+                    throw new errors_1.UnsupportedOperationError((0, errors_1.message)('unsupportedOperation'));
+                }
+            }
+            else if (Equation_1.Equation.isEquation(a)) {
+                if (['plus', 'minus', 'times', 'div'].includes(operation)) {
+                    retval = dispatchDynamicOperation(a, b, operation);
+                }
+                else {
+                    throw new errors_1.UnsupportedOperationError((0, errors_1.message)('unsupportedOperation'));
+                }
+            }
+            else if (operation === 'plus' || operation === 'times') {
+                retval = dispatchDynamicOperation(a, b, operation);
+            }
+            else {
+                throw new errors_1.UnsupportedOperationError((0, errors_1.message)('unsupportedOperation'));
+            }
+        }
+        else if ((0, structuredEntityUtils_1.isEnumerable)(a)) {
+            retval = routeOperation(a, b, operation);
+        }
+        else if ((Vector_1.Vector.isVector(b) || Matrix_1.Matrix.isMatrix(b)) &&
+            (operation === 'minus' || operation === 'div' || operation === 'pow')) {
+            // Scalar-left operations are not commutative. Preserve operand order while
+            // distributing the operation over the structured right-hand operand.
+            if (!Expression_1.Expression.isExpression(a)) {
+                throw new errors_1.UnsupportedOperationError((0, errors_1.message)('unsupportedOperation'));
+            }
+            // A scalar base with a Matrix exponent is a matrix-function question. It must
+            // not be reversed into Matrix.pow() or silently treated as element-wise power.
+            if (Matrix_1.Matrix.isMatrix(b) && operation === 'pow') {
+                throw new errors_1.UnsupportedOperationError((0, errors_1.message)('unsupportedOperation'));
+            }
+            retval = distribute(element => {
+                let elementResult;
+                if (Expression_1.Expression.isExpression(element)) {
+                    if (operation === 'minus') {
+                        elementResult = (0, subtract_1.subtract)(a, element);
+                    }
+                    else if (operation === 'div') {
+                        elementResult = (0, divide_1.divide)(a, element);
+                    }
+                    else {
+                        elementResult = (0, power_1.power)(a, element);
+                    }
+                }
+                else {
+                    const nestedResult = route(a, element, operation);
+                    if (Array.isArray(nestedResult)) {
+                        throw new errors_1.UnsupportedOperationError((0, errors_1.message)('unsupportedOperation'));
+                    }
+                    elementResult = nestedResult;
+                }
+                return elementResult;
+            }, b);
+        }
+        else if ((0, structuredEntityUtils_1.isEnumerable)(b)) {
+            retval = routeOperation(b, a, operation);
+        }
+        else {
+            retval = dispatchDynamicOperation(a, b, operation);
+        }
+    }
+    else {
+        retval = dispatchDynamicOperation(a, b, operation);
+    }
+    return retval;
+}

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

@@ -0,0 +1,11 @@
+import { Expression } from '../../expression/Expression';
+/**
+ * Multiplies two Expressions
+ *
+ * @param a
+ * @param b
+ * @returns
+ */
+export declare function multiply(a: Expression, b: Expression): Expression;
+export declare function merge(a: Expression, b: Expression): Expression;
+export declare function canonicalizeRadicals(x: Expression): Expression;