nerdamer 2.0.0-rc.1 → 2.0.0

package/output/core/common/common.js

@@ -17,234 +17,36 @@ function isNerdamerNativeType(obj, dataType) {
     return retval;
 }
 exports.brackets = {
-    '(': {
-        type: 'parenthesis',
-        id: 1,
-        isOpen: true,
-        isClose: false,
-        matches: ')',
-    },
-    ')': {
-        type: 'parenthesis',
-        id: 2,
-        isOpen: false,
-        isClose: true,
-        matches: '(',
-    },
-    '[': {
-        type: 'square',
-        id: 3,
-        isOpen: true,
-        isClose: false,
-        matches: ']',
-    },
-    ']': {
-        type: 'square',
-        id: 4,
-        isOpen: false,
-        isClose: true,
-        matches: '[',
-    },
-    '{': {
-        type: 'curly',
-        id: 5,
-        isOpen: true,
-        isClose: false,
-        matches: '}',
-    },
-    '}': {
-        type: 'curly',
-        id: 6,
-        isOpen: false,
-        isClose: true,
-        matches: '{',
-    },
-    '|': {
-        type: 'pipe',
-        id: 7,
-        isOpen: true,
-        isClose: true,
-        matches: '|',
-    },
+    '(': { type: 'parenthesis', id: 1, isOpen: true, isClose: false, matches: ')' },
+    ')': { type: 'parenthesis', id: 2, isOpen: false, isClose: true, matches: '(' },
+    '[': { type: 'square', id: 3, isOpen: true, isClose: false, matches: ']' },
+    ']': { type: 'square', id: 4, isOpen: false, isClose: true, matches: '[' },
+    '{': { type: 'curly', id: 5, isOpen: true, isClose: false, matches: '}' },
+    '}': { type: 'curly', id: 6, isOpen: false, isClose: true, matches: '{' },
+    '|': { type: 'pipe', id: 7, isOpen: true, isClose: true, matches: '|' },
 };
 exports.operators = {
-    '.': {
-        precedence: 9,
-        operator: '.',
-        action: 'dot',
-        isPrefix: false,
-        isPostfix: false,
-        leftAssoc: false,
-        iterates: false,
-    },
-    '!!': {
-        precedence: 7,
-        operator: '!!',
-        action: 'doubleFactorial',
-        isPrefix: false,
-        isPostfix: true,
-        leftAssoc: false,
-        iterates: true,
-    },
-    '!': {
-        precedence: 7,
-        operator: '!',
-        action: 'factorial',
-        isPrefix: false,
-        isPostfix: true,
-        leftAssoc: false,
-        iterates: true,
-    },
-    '^': {
-        precedence: 6,
-        operator: '^',
-        action: 'pow',
-        isPrefix: false,
-        isPostfix: false,
-        leftAssoc: false,
-        iterates: true,
-    },
-    '**': {
-        precedence: 6,
-        operator: '**',
-        action: 'pow',
-        isPrefix: false,
-        isPostfix: false,
-        leftAssoc: false,
-        iterates: true,
-    },
+    '.': { precedence: 9, operator: '.', action: 'dot', isPrefix: false, isPostfix: false, leftAssoc: false, iterates: false },
+    '!!': { precedence: 7, operator: '!!', action: 'doubleFactorial', isPrefix: false, isPostfix: true, leftAssoc: false, iterates: true },
+    '!': { precedence: 7, operator: '!', action: 'factorial', isPrefix: false, isPostfix: true, leftAssoc: false, iterates: true },
+    '^': { precedence: 6, operator: '^', action: 'pow', isPrefix: false, isPostfix: false, leftAssoc: false, iterates: true },
+    '**': { precedence: 6, operator: '**', action: 'pow', isPrefix: false, isPostfix: false, leftAssoc: false, iterates: true },
     '%': {
-        precedence: 4,
-        operator: '%',
-        action: 'mod',
-        isPrefix: false,
-        isPostfix: false,
-        leftAssoc: true,
-        iterates: true,
-        postfixVariant: {
-            precedence: 7,
-            operator: '%',
-            action: 'percent',
-            isPrefix: false,
-            isPostfix: true,
-            leftAssoc: false,
-            iterates: true,
-        },
-    },
-    '*': {
-        precedence: 4,
-        operator: '*',
-        action: 'times',
-        isPrefix: false,
-        isPostfix: false,
-        leftAssoc: true,
-        iterates: true,
-    },
-    '/': {
-        precedence: 4,
-        operator: '/',
-        action: 'div',
-        isPrefix: false,
-        isPostfix: false,
-        leftAssoc: true,
-        iterates: true,
-    },
-    '+': {
-        precedence: 3,
-        operator: '+',
-        action: 'plus',
-        isPrefix: true,
-        isPostfix: false,
-        leftAssoc: true,
-        iterates: true,
-    },
-    '-': {
-        precedence: 3,
-        operator: '-',
-        action: 'minus',
-        isPrefix: true,
-        isPostfix: false,
-        leftAssoc: true,
-        iterates: true,
-    },
-    '=': {
-        precedence: 2,
-        operator: '=',
-        action: 'setEqual',
-        assertiveAction: 'assertEQ',
-        isPrefix: false,
-        isPostfix: false,
-        leftAssoc: true,
-        iterates: false,
-    },
-    '==': {
-        precedence: 1,
-        operator: '==',
-        action: 'eq',
-        assertiveAction: 'assertEQ',
-        isPrefix: false,
-        isPostfix: false,
-        leftAssoc: true,
-        iterates: false,
-    },
-    '<': {
-        precedence: 1,
-        operator: '<',
-        action: 'lt',
-        assertiveAction: 'assertLT',
-        isPrefix: false,
-        isPostfix: false,
-        leftAssoc: true,
-        iterates: false,
-    },
-    '<=': {
-        precedence: 1,
-        operator: '<=',
-        action: 'lte',
-        assertiveAction: 'assertLTE',
-        isPrefix: false,
-        isPostfix: false,
-        leftAssoc: true,
-        iterates: false,
-    },
-    '>': {
-        precedence: 1,
-        operator: '>',
-        action: 'gt',
-        assertiveAction: 'assertGT',
-        isPrefix: false,
-        isPostfix: false,
-        leftAssoc: true,
-        iterates: false,
-    },
-    '>=': {
-        precedence: 1,
-        operator: '>=',
-        action: 'gte',
-        assertiveAction: 'assertGTE',
-        isPrefix: false,
-        isPostfix: false,
-        leftAssoc: true,
-        iterates: false,
-    },
-    '=>': {
-        precedence: 0,
-        operator: '=>',
-        action: 'mapTo',
-        isPrefix: false,
-        isPostfix: false,
-        leftAssoc: true,
-        iterates: false,
-    },
-    ',': {
-        precedence: 0,
-        operator: ',',
-        action: 'comma',
-        isPrefix: false,
-        isPostfix: false,
-        leftAssoc: true,
-        iterates: false,
-    },
+        precedence: 4, operator: '%', action: 'mod', isPrefix: false, isPostfix: false, leftAssoc: true, iterates: true,
+        postfixVariant: { precedence: 7, operator: '%', action: 'percent', isPrefix: false, isPostfix: true, leftAssoc: false, iterates: true },
+    },
+    '*': { precedence: 4, operator: '*', action: 'times', isPrefix: false, isPostfix: false, leftAssoc: true, iterates: true },
+    '/': { precedence: 4, operator: '/', action: 'div', isPrefix: false, isPostfix: false, leftAssoc: true, iterates: true },
+    '+': { precedence: 3, operator: '+', action: 'plus', isPrefix: true, isPostfix: false, leftAssoc: true, iterates: true },
+    '-': { precedence: 3, operator: '-', action: 'minus', isPrefix: true, isPostfix: false, leftAssoc: true, iterates: true },
+    '=': { precedence: 2, operator: '=', action: 'setEqual', assertiveAction: 'assertEQ', isPrefix: false, isPostfix: false, leftAssoc: true, iterates: false },
+    '==': { precedence: 1, operator: '==', action: 'eq', assertiveAction: 'assertEQ', isPrefix: false, isPostfix: false, leftAssoc: true, iterates: false },
+    '<': { precedence: 1, operator: '<', action: 'lt', assertiveAction: 'assertLT', isPrefix: false, isPostfix: false, leftAssoc: true, iterates: false },
+    '<=': { precedence: 1, operator: '<=', action: 'lte', assertiveAction: 'assertLTE', isPrefix: false, isPostfix: false, leftAssoc: true, iterates: false },
+    '>': { precedence: 1, operator: '>', action: 'gt', assertiveAction: 'assertGT', isPrefix: false, isPostfix: false, leftAssoc: true, iterates: false },
+    '>=': { precedence: 1, operator: '>=', action: 'gte', assertiveAction: 'assertGTE', isPrefix: false, isPostfix: false, leftAssoc: true, iterates: false },
+    '=>': { precedence: 0, operator: '=>', action: 'mapTo', isPrefix: false, isPostfix: false, leftAssoc: true, iterates: false },
+    ',': { precedence: 0, operator: ',', action: 'comma', isPrefix: false, isPostfix: false, leftAssoc: true, iterates: false },
     ':': {
         precedence: 0,
         operator: ':',
@@ -254,6 +56,7 @@ exports.operators = {
         leftAssoc: true,
         iterates: false,
         deferLHSResolution: true,
+        deferRHSResolution: true,
     },
     ':=': {
         precedence: 0,
@@ -266,14 +69,6 @@ exports.operators = {
         deferLHSResolution: true,
         deferRHSResolution: true,
     },
-    in: {
-        precedence: 0,
-        operator: 'in',
-        action: 'in',
-        isPrefix: false,
-        isPostfix: false,
-        leftAssoc: true,
-        iterates: false,
-    },
+    in: { precedence: 0, operator: 'in', action: 'in', isPrefix: false, isPostfix: false, leftAssoc: true, iterates: false },
 };
 exports.ASSERTIVE_FUNCTIONS = ['assume'];

package/output/core/converters/BaseConverter.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseConverter = void 0;
 const Expression_1 = require("../classes/expression/Expression");
+const shortcuts_1 = require("../classes/expression/shortcuts");
 const constants_1 = require("../classes/parser/constants");
 const errors_1 = require("../errors");
 const modes = {
@@ -85,7 +86,7 @@ class BaseConverter {
         return [a[0] + b[0], a[1] + b[1]];
     }
     static strip(input) {
-        const arg = new Expression_1.Expression(input);
+        const arg = input.copy();
         delete arg.power;
         delete arg.multiplier;
         return arg;
@@ -247,7 +248,7 @@ class BaseConverter {
         // Preserve them verbatim instead of trying to move them into the denominator.
         const isComplexPower = pExpr.isComplex();
         const power = isComplexPower ? pExpr : pExpr.signFree();
-        const isInverted = !isComplexPower && (pExpr.lt(0) || pExpr.sign() === -1);
+        const isInverted = !isComplexPower && (pExpr.lt((0, shortcuts_1.zero)()) || pExpr.sign() === -1);
         const isNegative = input.getMultiplier().isNegative();
         const m = input.getMultiplier().abs();
         const multiplierArray = ['', ''];

package/output/core/converters/Converter.js

@@ -12,6 +12,7 @@ const ValuesSet_1 = require("../classes/valuesSet/ValuesSet");
 const Vector_1 = require("../classes/vector/Vector");
 const Scope_1 = require("../common/classes/Scope");
 const dispatch_1 = require("../dispatch");
+const errors_1 = require("../errors");
 const BaseConverter_1 = require("./BaseConverter");
 const { TeX, TEXT } = BaseConverter_1.BaseConverter.modes;
 /**
@@ -203,7 +204,7 @@ class Converter extends BaseConverter_1.BaseConverter {
             else if (item.type === Token_1.Token.FUNCTION) {
                 const argsScope = rpn[++i];
                 if (!Scope_1.Scope.isScope(argsScope)) {
-                    throw new Error(`Missing argument scope for function ${item.value}`);
+                    throw new Error((0, errors_1.message)('converterMissingArgumentScope', { function: item.value }));
                 }
                 let args = [];
                 if (argsScope.length > 0) {
@@ -244,7 +245,7 @@ class Converter extends BaseConverter_1.BaseConverter {
             else if (item.type === Token_1.Token.PREFIX) {
                 const operand = stack.pop();
                 if (!operand) {
-                    throw new Error(`Missing operand for prefix operator ${item.value}`);
+                    throw new Error((0, errors_1.message)('converterMissingPrefixOperand', { operator: item.value }));
                 }
                 stack.push({
                     text: item.value + operand.text,
@@ -255,7 +256,7 @@ class Converter extends BaseConverter_1.BaseConverter {
                 const operator = item.resolvedOperator ?? Parser_1.Parser.getOperator(item.value);
                 const right = stack.pop();
                 if (!operator || !right) {
-                    throw new Error(`Missing operand or metadata for operator ${item.value}`);
+                    throw new Error((0, errors_1.message)('converterMissingOperandMetadata', { operator: item.value }));
                 }
                 if (operator.isPostfix) {
                     const symbol = item.value === '%' ? '\\%' : item.value;
@@ -267,7 +268,7 @@ class Converter extends BaseConverter_1.BaseConverter {
                 }
                 const left = stack.pop();
                 if (!left) {
-                    throw new Error(`Missing left operand for operator ${item.value}`);
+                    throw new Error((0, errors_1.message)('converterMissingLeftOperand', { operator: item.value }));
                 }
                 if (operator.action === 'comma') {
                     const args = [...(left.args ?? [left]), ...(right.args ?? [right])];
@@ -324,7 +325,7 @@ class Converter extends BaseConverter_1.BaseConverter {
             }
         }
         if (stack.length !== 1) {
-            throw new Error('Unable to convert source expression to TeX');
+            throw new Error((0, errors_1.message)('converterTexConversionFailed'));
         }
         const retval = stack[0];
         return retval;
@@ -401,9 +402,12 @@ class Converter extends BaseConverter_1.BaseConverter {
                 return `\\mathrm${this.inBraces(Expression_1.Expression.LOG)}${subscript}${this.inBrackets(output[0])}`;
             },
             [Expression_1.Expression.LOG10]: () => `\\mathrm${this.inBraces(Expression_1.Expression.LOG)}_${this.inBraces('10')}${this.inBrackets(output[0])}`,
+            log10: () => `\\mathrm${this.inBraces(Expression_1.Expression.LOG)}_${this.inBraces('10')}${this.inBrackets(output[0])}`,
             // Special functions
             exp: std,
             gamma: () => `\\Gamma${this.inBrackets(output[0])}`,
+            gamma_incomplete: () => `\\Gamma${this.inBrackets(output.join(','), 'parens')}`,
+            gamma_incomplete_lower: () => `\\gamma${this.inBrackets(output.join(','), 'parens')}`,
             erf: std,
             erfc: std,
             sinc: std,

package/output/core/converters/Pattern.js

@@ -121,7 +121,7 @@ class Pattern extends BaseConverter_1.BaseConverter {
         // return input.isSum() || input.isEXP();
     }
     setMultiplier(m, multiplierArray, _input, _options) {
-        const ref = this.createConstantReference(new Expression_1.Expression(m));
+        const ref = this.createConstantReference(Expression_1.Expression.create(m));
         this.multiplier = ref;
         multiplierArray[0] = ref;
     }

package/output/core/dispatch.d.ts

@@ -29,6 +29,24 @@ export interface MathFunctionEntry {
     /** Whether this function was registered at the system or user level */
     level: ParserRegistrationLevel;
 }
+/**
+ * Registers a system-level function in the dispatch table. Registered functions can use
+ * narrower parameter types, so `RegisteredMathFunction` does not define a common argument
+ * type. Dynamic invocation is handled by `callFunction`.
+ */
+export declare function systemFunction(opts: {
+    fn: RegisteredMathFunction;
+    minArgs: number;
+    maxArgs: number;
+    maxPrecision?: number;
+    equationArgs?: number[];
+    distElWise: boolean;
+    deferArguments?: boolean;
+    normalizeDeferredArguments?: (argumentScopes: Scope[]) => Scope[];
+    bracketlessStatement?: boolean;
+    returnBoundary?: boolean;
+    usage?: ParserUsage;
+}): MathFunctionEntry;
 export declare const mathFunctionRegistry: {
     [functionName: string]: MathFunctionEntry;
 };