nerdamer 1.1.13 → 2.0.0-rc.1

package/output/core/converters/Pattern.d.ts

@@ -0,0 +1,71 @@
+import { Expression } from '../classes/expression/Expression';
+import { BaseConverter } from './BaseConverter';
+import type { OptionsObject } from '../classes/parser/types';
+import type { FracArray } from '../classes/parser/types';
+import type { Rational } from '../classes/rational/Rational';
+import type { ExpressionInput } from '../types';
+export declare class Pattern extends BaseConverter {
+    private allEqualArguments;
+    private args;
+    private c;
+    private constCount;
+    private expression;
+    private multiplier;
+    private p;
+    private powerCount;
+    private referenceMap;
+    private reuseReferences;
+    private v;
+    private variables;
+    patternString: string;
+    references: {
+        [label: string]: Expression;
+    };
+    stack: Expression[];
+    constructor(expression: ExpressionInput, variables?: string[], options?: OptionsObject);
+    /**
+     * Shows the structure of a pattern with respect to x
+     * @param str
+     * @returns
+     */
+    static showStructure(str: string, variable?: string): string;
+    protected convertPower(input: Expression, power: Expression, options: OptionsObject): string;
+    protected createConstantReference(input: Expression, toPower?: boolean): string;
+    protected createVariableReference(input: Expression, options: OptionsObject): string;
+    protected finalizePowerAndInput(power: Expression, input: Expression, _options?: OptionsObject): [Expression, Expression];
+    protected hasAsVariable(input: Expression): boolean;
+    protected isBracketed(v: string): boolean;
+    protected multiplyToMultiplier(input: Expression): void;
+    protected requiresMultiplicationSymbol(_input: Expression): boolean;
+    protected setMultiplier(m: Rational, multiplierArray: FracArray, _input: Expression, _options?: OptionsObject): void;
+    protected toFraction(n: string, d: string): string;
+    protected value(input: Expression, isInverted: boolean, isNegative: boolean, options: OptionsObject): FracArray;
+    private addReference;
+    private formatFunctionCall;
+    private getReferenceFromMap;
+    private handlePatternProduct;
+    private handlePatternSum;
+    private initializeVariables;
+    private nextConstant;
+    private nextPower;
+    /**
+     * Checks to make sure that all the arguments match
+     * @returns
+     */
+    argumentsMatch(): boolean;
+    /**
+     * Checks if one or more values equals a given value
+     * @param references
+     * @param value
+     * @returns
+     */
+    equal(references: string, value: string): boolean;
+    equal(references: string[], value: string): boolean;
+    fromPattern(p: string): Expression;
+    /**
+     * Gets the value of a reference
+     * @param reference
+     * @returns
+     */
+    get(reference: string): Expression;
+}

package/output/core/converters/Pattern.js

@@ -0,0 +1,302 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Pattern = void 0;
+const array_1 = require("../../utils/array");
+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 BaseConverter_1 = require("./BaseConverter");
+class Pattern extends BaseConverter_1.BaseConverter {
+    // Caching elements
+    allEqualArguments = undefined;
+    args = [];
+    c;
+    constCount = 0;
+    expression;
+    multiplier = '';
+    p;
+    powerCount = 0;
+    referenceMap = {};
+    reuseReferences;
+    v;
+    variables = {};
+    patternString = '';
+    references = {};
+    stack = [];
+    constructor(expression, variables = [], options) {
+        super();
+        this.setMode('text');
+        this.expression = Expression_1.Expression.create(expression);
+        const defaults = {
+            constantSymbol: 'a',
+            powerSymbol: 'n',
+            variableSymbol: 'x',
+            reuseReferences: false,
+        };
+        const resolvedOptions = { ...defaults, ...options };
+        this.v = resolvedOptions.variableSymbol;
+        this.p = resolvedOptions.powerSymbol;
+        this.c = resolvedOptions.constantSymbol;
+        this.reuseReferences = resolvedOptions.reuseReferences;
+        this.initializeVariables(variables);
+        this.patternString = this.convert(this.expression, resolvedOptions);
+    }
+    /**
+     * Shows the structure of a pattern with respect to x
+     * @param str
+     * @returns
+     */
+    static showStructure(str, variable = 'x') {
+        let output = `Input: ${str}\n`;
+        const pattern = new Pattern(str, [variable]);
+        output += `patternString: ${pattern.patternString}\n`;
+        output += 'references: {\n';
+        for (const r in pattern.references) {
+            output += `	${r}: ${pattern.references[r]}\n`;
+        }
+        output += '}';
+        return output;
+    }
+    convertPower(input, power, options) {
+        if (input.isEXP()) {
+            // Explicitly include the multiplier
+            return this.inBrackets(this.convert(power, { ...options, ignoreMultiplier: false }));
+        }
+        // If it doesn't have a variable then it's just a constants and does not require a power
+        // Products don't carry powers at the upper level so it's always 1. No need to add it.
+        if (!this.hasAsVariable(input) || input.isProduct()) {
+            return '';
+        }
+        return this.createConstantReference(power, true);
+    }
+    createConstantReference(input, toPower = false) {
+        const isNumeric = input.isNUM();
+        // Namespace the cache key so constant and power references don't collide.
+        const key = `${toPower ? 'pow' : 'cnt'}_${input.text()}`;
+        if (!isNumeric) {
+            const existing = this.referenceMap[key];
+            if (existing) {
+                return existing;
+            }
+        }
+        const ref = toPower ? this.nextPower(input) : this.nextConstant(input);
+        this.addReference(ref, input);
+        if (!isNumeric) {
+            this.referenceMap[key] = ref;
+        }
+        return ref;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    createVariableReference(input, options) {
+        const value = this.variables[input.value];
+        this.addReference(value, input);
+        return value;
+    }
+    finalizePowerAndInput(power, input, _options) {
+        // The power gets stripped from the input e.g. 2^x -> [2, x]
+        // This check fails because the power and not the base now contains the variable.
+        // Return an EXP with power one. This is a workable solution since this expression
+        // is short-lived.
+        let e = input.toLinearAndUnitMultiplier();
+        if (input.isEXP() && !e.isEXP() && this.hasAsVariable(power)) {
+            e = Expression_1.Expression.toEXP(e, (0, shortcuts_1.one)());
+        }
+        return [power, e];
+    }
+    hasAsVariable(input) {
+        if (input.isVAR()) {
+            return !!this.variables[input.value];
+        }
+        return Object.keys(this.variables).some(variable => input.hasVariable(variable));
+    }
+    isBracketed(v) {
+        return /^\(.+\)$/.test(v);
+    }
+    multiplyToMultiplier(input) {
+        this.references[this.multiplier] = this.references[this.multiplier].times(input);
+    }
+    requiresMultiplicationSymbol(_input) {
+        return true;
+        // return input.isSum() || input.isEXP();
+    }
+    setMultiplier(m, multiplierArray, _input, _options) {
+        const ref = this.createConstantReference(new Expression_1.Expression(m));
+        this.multiplier = ref;
+        multiplierArray[0] = ref;
+    }
+    toFraction(n, d) {
+        const wrapIfNeeded = (s) => {
+            if (/[*+]/.test(s) && !this.isBracketed(s)) {
+                return this.inBrackets(s);
+            }
+            return s;
+        };
+        return `${wrapIfNeeded(n)}/${wrapIfNeeded(d)}`;
+    }
+    value(input, isInverted, isNegative, options) {
+        const v = ['', ''];
+        const index = isInverted ? 1 : 0;
+        if (input.isNUM()) {
+            return v;
+        }
+        if (!this.hasAsVariable(input) && !input.isEXP()) {
+            this.multiplyToMultiplier(input);
+            return v;
+        }
+        if (input.isEXP()) {
+            const arg = input.getBase();
+            v[index] = this.inBrackets(this.convert(arg, { ...options, ignoreMultiplier: false }));
+        }
+        else if (input.isInf()) {
+            v[index] = constants_1.INFINITY[0];
+        }
+        else if (!(input.elements || input.args)) {
+            v[index] = this.createVariableReference(input, options);
+        }
+        else if (input.isFunction()) {
+            v[index] = this.formatFunctionCall(input, options);
+        }
+        else if (input.isSum()) {
+            v[index] = this.handlePatternSum(input, options);
+        }
+        else if (input.isProduct()) {
+            return this.handlePatternProduct(input, isInverted, options);
+        }
+        return v;
+    }
+    addReference(ref, input) {
+        if (!this.references[ref]) {
+            this.references[ref] = input;
+        }
+    }
+    formatFunctionCall(input, options) {
+        const args = input.getArguments();
+        // Make a references to the arguments
+        this.args.push(args.map(x => x.text()).join(','));
+        // Ignoring the multiplier is explicitly false
+        const argList = args
+            .map(arg => this.convert(arg, { ...options, ignoreMultiplier: false }))
+            .join(', ');
+        return `${input.name}${this.inBrackets(argList)}`;
+    }
+    getReferenceFromMap(input, toPower = false) {
+        if (input && !input.isNUM()) {
+            const key = `${toPower ? 'pow' : 'cnt'}_${input.text()}`;
+            return this.referenceMap[key];
+        }
+    }
+    handlePatternProduct(input, isInverted, options) {
+        const mul = this.getMultiplicationSymbol();
+        const numOutput = [];
+        const denOutput = [];
+        for (let element of input.elementsArray()) {
+            if (!this.hasAsVariable(element)) {
+                this.multiplyToMultiplier(element);
+                continue;
+            }
+            if (element.isFunction(constants_1.WRAP)) {
+                element = element.getArguments()[0];
+            }
+            // FIX: Account for whether the entire product is inverted
+            const elementPowerSign = element.getPower().sign();
+            const isInDenominator = isInverted
+                ? elementPowerSign !== -1 // If product is inverted, positive powers go to denominator
+                : elementPowerSign === -1; // Normal case: negative powers go to denominator
+            const target = isInDenominator ? denOutput : numOutput;
+            if (isInDenominator && !isInverted) {
+                element = element.invert();
+            }
+            else if (!isInDenominator && isInverted) {
+                // Element stays as-is when inverted product with positive power
+            }
+            let output = this.convert(element, { ...options, ignoreMultiplier: true });
+            if (element.isSum() && element.isLinear() && this.mode === 'text') {
+                output = this.inBrackets(output);
+            }
+            target.push(output);
+        }
+        return [numOutput.join(mul), denOutput.join(mul)];
+    }
+    handlePatternSum(input, options) {
+        let constants = (0, shortcuts_1.zero)();
+        const elements = input.elementsArray();
+        const converted = [];
+        for (const element of elements) {
+            if (this.hasAsVariable(element)) {
+                converted.push(this.convert(element, { ...options, ignoreMultiplier: false }));
+                // converted.push(this.convert(element, options));
+            }
+            else {
+                constants = constants.plus(element);
+            }
+        }
+        // Add the constants if they're not zero
+        if (!constants.isZero()) {
+            converted.push(this.createConstantReference(constants));
+        }
+        return this.inBrackets(converted.join('+'));
+    }
+    initializeVariables(variables) {
+        let counter = 1;
+        variables
+            .slice()
+            .sort()
+            .forEach(x => {
+            this.variables[x] = this.v + counter++;
+        });
+    }
+    nextConstant(constant) {
+        const existing = this.getReferenceFromMap(constant, /*toPower*/ false);
+        return this.reuseReferences && existing ? existing : `${this.c}${++this.constCount}`;
+        // return existing || `${this.c}${++this.constCount}`;
+    }
+    nextPower(power) {
+        const existing = this.getReferenceFromMap(power, /*toPower*/ true);
+        return this.reuseReferences && existing ? existing : `${this.p}${++this.powerCount}`;
+        // return existing || `${this.p}${++this.powerCount}`;
+    }
+    /**
+     * Checks to make sure that all the arguments match
+     * @returns
+     */
+    argumentsMatch() {
+        if (this.allEqualArguments === undefined) {
+            this.allEqualArguments = (0, array_1.allEqual)(this.args);
+        }
+        return this.allEqualArguments;
+    }
+    equal(references, value) {
+        if (typeof references === 'string') {
+            return this.get(references).eq(value);
+        }
+        else {
+            if (references.length == 0) {
+                return false;
+            }
+            // The subsequent
+            for (let i = 0; i < references.length; i++) {
+                if (!this.get(references[i]).eq(value)) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+    fromPattern(p) {
+        return Expression_1.Expression.create(p, this.references);
+    }
+    /**
+     * Gets the value of a reference
+     * @param reference
+     * @returns
+     */
+    get(reference) {
+        const ref = this.references[reference];
+        if (!ref) {
+            throw new errors_1.MissingReferenceError((0, errors_1.message)('missingReference', { ref: reference }));
+        }
+        return ref;
+    }
+}
+exports.Pattern = Pattern;

package/output/core/dispatch.d.ts

@@ -0,0 +1,34 @@
+import type { Scope } from './common/classes/Scope';
+import type { ParserEntity } from './types';
+export type RegisteredMathFunction = (...args: never[]) => ParserEntity;
+export type ParserUsage = 'notation' | 'scripting';
+export type ParserRegistrationLevel = 'system' | 'user';
+export interface MathFunctionEntry {
+    /** The function to be called */
+    fn: RegisteredMathFunction;
+    /** The minimum arguments allowed. Use -1 for variadic. */
+    minArgs: number;
+    /** The maximum arguments allowed. Use -1 for variadic. */
+    maxArgs: number;
+    /** The maximum precision available for the function */
+    maxPrecision?: number;
+    /** Argument positions that explicitly accept Equation values. */
+    equationArgs?: number[];
+    /** Whether Vector and Matrix arguments are distributed element-wise. */
+    distElWise?: boolean;
+    /** Whether argument evaluation is controlled by the registered function. */
+    deferArguments?: boolean;
+    /** Optional syntax normalization applied to deferred argument scopes before evaluation. */
+    normalizeDeferredArguments?: (argumentScopes: Scope[]) => Scope[];
+    /** Whether bracketless notation consumes the rest of the current statement expression. */
+    bracketlessStatement?: boolean;
+    /** Whether parser dispatch consumes an escaping top-level RETURN from this function. */
+    returnBoundary?: boolean;
+    /** Whether the entry belongs to ordinary Nerdamer notation or Nerdamer scripting. */
+    usage: ParserUsage;
+    /** Whether this function was registered at the system or user level */
+    level: ParserRegistrationLevel;
+}
+export declare const mathFunctionRegistry: {
+    [functionName: string]: MathFunctionEntry;
+};