nerdamer 1.1.13 → 2.0.0-rc.2

package/output/core/common/functions/functions.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Reads the array of operators and breaks it up into individual symbols
+ *
+ * @returns An array with operator symbol
+ */
+export declare function getOperatorSymbolArray(): string[];
+/**
+ * Links operator actions to operator objects
+ *
+ * @returns The operators object
+ */
+export declare function getOperators(): Record<string, import("../common").Operator & {
+    action: import("../common").OperatorAction;
+}>;

package/output/core/common/functions/functions.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOperatorSymbolArray = getOperatorSymbolArray;
+exports.getOperators = getOperators;
+const common_1 = require("../common");
+/**
+ * Reads the array of operators and breaks it up into individual symbols
+ *
+ * @returns An array with operator symbol
+ */
+function getOperatorSymbolArray() {
+    // make them one long string and then filter out duplicates
+    const symbolSet = new Set(Object.keys(common_1.operators).join('').split(''));
+    //filter out letters used in keyword operators
+    const symbolArray = [...symbolSet].filter(x => {
+        return !/[a-z]/i.test(x);
+    });
+    return symbolArray;
+}
+/**
+ * Links operator actions to operator objects
+ *
+ * @returns The operators object
+ */
+function getOperators() {
+    // for (const operator in operators) {
+    //     // Get the object
+    //     let operatorObject: Operator = operators[operator];
+    //     // Link the operation function to the operator object or overwrite it
+    //     operatorObject.operation = _[operatorObject.action]
+    // }
+    return common_1.operators;
+}

package/output/core/common/functions/structuredEntityUtils.d.ts

@@ -0,0 +1,27 @@
+import { Expression } from '../../classes/expression/Expression';
+import type { SolutionSet } from '../../../solve/classes/SolutionSet';
+import type { Collection } from '../../classes/collection/Collection';
+import type { Dictionary } from '../../classes/dictionary/Dictionary';
+import type { Matrix } from '../../classes/matrix/Matrix';
+import type { ValuesSet } from '../../classes/valuesSet/ValuesSet';
+import type { Vector } from '../../classes/vector/Vector';
+import type { NerdamerInput, ParserEntity, ExpressionInput } from '../../types';
+/**
+ * Checks to see if an obj is a set of values
+ *
+ * @param obj
+ * @returns
+ */
+export declare function isEnumerable(obj: unknown): obj is Vector | Collection | Matrix | ValuesSet | SolutionSet | Dictionary;
+/**
+ * Converts string and numbers to a parser supported type.
+ * @param elements
+ * @returns
+ */
+export declare function toParserEntities(elements: NerdamerInput[]): ParserEntity[];
+/**
+ * Converts all inputs to Expression
+ * @param inputs
+ * @returns
+ */
+export declare function toExpressions(inputs: ExpressionInput[]): Expression[];

package/output/core/common/functions/structuredEntityUtils.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEnumerable = isEnumerable;
+exports.toParserEntities = toParserEntities;
+exports.toExpressions = toExpressions;
+const Expression_1 = require("../../classes/expression/Expression");
+/**
+ * Checks to see if an obj is a set of values
+ *
+ * @param obj
+ * @returns
+ */
+function isEnumerable(obj) {
+    if (obj === undefined) {
+        return false;
+    }
+    return !!obj
+        .isEnumerable;
+}
+/**
+ * Converts string and numbers to a parser supported type.
+ * @param elements
+ * @returns
+ */
+function toParserEntities(elements) {
+    const retval = [];
+    for (let i = 0; i < elements.length; i++) {
+        const element = elements[i];
+        retval.push(isEnumerable(element) ? element : Expression_1.Expression.create(element));
+    }
+    return retval;
+}
+/**
+ * Converts all inputs to Expression
+ * @param inputs
+ * @returns
+ */
+function toExpressions(inputs) {
+    return inputs.map(e => Expression_1.Expression.create(e));
+}

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

@@ -0,0 +1,97 @@
+import { Expression } from '../classes/expression/Expression';
+import type { FracArray } from '../classes/parser/types';
+import type { OptionsObject } from '../classes/parser/types';
+import type { Rational } from '../classes/rational/Rational';
+import type { ParserEntity } from '../types';
+type BracketType = 'parens' | 'square' | 'brace' | 'abs';
+/**
+ * Shared formatting pipeline for Nerdamer converters.
+ *
+ * @remarks
+ * This is an implementation base class. Public callers should construct `Converter`
+ * through `nerdamer.classes.Converter`; subclasses provide the
+ * expression-specific formatting hooks used by {@link BaseConverter.convert}.
+ *
+ * Conversion separates every expression into multiplier, value, and power fragments,
+ * each with numerator and denominator slots. Keeping those fragments separate lets the
+ * final formatting step place negative powers and rational multipliers into one
+ * denominator without algebraically rewriting the caller's symbolic value.
+ */
+export declare class BaseConverter {
+    protected static readonly GREEK_LETTERS: string[];
+    static readonly modes: {
+        TeX: string;
+        TEXT: string;
+    };
+    protected greek: string[];
+    private readonly modes;
+    protected mode: string;
+    static convertNtRoot(input: Expression, root: Expression): Expression;
+    static convertSQRT(input: Expression): Expression;
+    private static join;
+    private static merge;
+    private static strip;
+    protected cleanup(): void;
+    protected convertPower(input: Expression, power: Expression, options: OptionsObject): string;
+    protected finalizePowerAndInput(power: Expression, input: Expression, _options?: OptionsObject): [Expression, Expression];
+    protected formatPowerOutput(pArray: FracArray, requiresBrackets: boolean): FracArray;
+    protected formatSubscripts(value: string): string;
+    protected getMultiplicationSymbol(): string;
+    protected inBraces(value: string): string;
+    protected inBrackets(value: string, type?: BracketType): string;
+    protected initInput(input: Expression): Expression;
+    protected isBracketed(v: string): boolean;
+    protected requiresMultiplicationSymbol(input: Expression): boolean;
+    protected set(m: FracArray, v: FracArray, p: FracArray, input: Expression): string;
+    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 convertCollection;
+    private convertDictionary;
+    private convertEquation;
+    private convertExpression;
+    private convertMatrix;
+    private convertValuesSet;
+    /**
+     * Removes a single outer \left(...\right) wrapper when the contents
+     * will already be visually grouped (e.g. inside \frac{}{}).
+     */
+    private stripOuterBrackets;
+    /**
+     * Formats a supported Nerdamer value in the converter's current mode.
+     *
+     * @remarks
+     * String input is parsed before formatting, so current parser settings, constants,
+     * and known values apply. Numbers are converted with JavaScript's string conversion.
+     * Expressions, equations, collections, vectors, matrices, solution sets, value sets,
+     * and dictionaries use their structured representations rather than being reparsed
+     * from display text.
+     * Reading an expression can initialize its lazily stored multiplier or power fields,
+     * but conversion does not change the expression's mathematical value.
+     *
+     * `convertRoots` defaults to `true`, rendering reciprocal integer powers as roots
+     * where the active mode supports that form. `decimal` requests decimal rational
+     * multipliers, `precision` is forwarded to rational formatting, `matrixStyle`
+     * selects the TeX matrix environment prefix, and `ignoreMultiplier` omits an
+     * expression's top-level multiplier. `insideMatrix` is used while formatting matrix
+     * elements and is normally managed by the converter itself.
+     *
+     * @param input - The parser entity, expression string, or number to format.
+     * @param options - Formatting options for this conversion and recursive child conversions.
+     * @returns The formatted text or TeX string for `input`.
+     * @throws Error When `input` is not one of the supported parser entity types.
+     */
+    convert(input: ParserEntity | string | number, options?: OptionsObject): string;
+    /**
+     * Selects the output syntax used by subsequent conversions.
+     *
+     * @remarks
+     * The mode is mutable converter state. Supported values are `"TeX"` and `"text"`;
+     * changing the mode does not alter parser settings or previously returned strings.
+     *
+     * @param mode - The output mode to activate.
+     * @throws Error When `mode` is not `"TeX"` or `"text"`.
+     */
+    setMode(mode: string): void;
+}
+export {};

package/output/core/converters/BaseConverter.js

@@ -0,0 +1,405 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseConverter = void 0;
+const Expression_1 = require("../classes/expression/Expression");
+const constants_1 = require("../classes/parser/constants");
+const errors_1 = require("../errors");
+const modes = {
+    TeX: 'TeX',
+    TEXT: 'text',
+};
+/**
+ * Shared formatting pipeline for Nerdamer converters.
+ *
+ * @remarks
+ * This is an implementation base class. Public callers should construct `Converter`
+ * through `nerdamer.classes.Converter`; subclasses provide the
+ * expression-specific formatting hooks used by {@link BaseConverter.convert}.
+ *
+ * Conversion separates every expression into multiplier, value, and power fragments,
+ * each with numerator and denominator slots. Keeping those fragments separate lets the
+ * final formatting step place negative powers and rational multipliers into one
+ * denominator without algebraically rewriting the caller's symbolic value.
+ */
+class BaseConverter {
+    static GREEK_LETTERS = [
+        'alpha',
+        'beta',
+        'gamma',
+        'delta',
+        'epsilon',
+        'zeta',
+        'eta',
+        'theta',
+        'iota',
+        'kappa',
+        'lambda',
+        'mu',
+        'nu',
+        'xi',
+        'omnikron',
+        'pi',
+        'rho',
+        'sigma',
+        'tau',
+        'upsilon',
+        'phi',
+        'chi',
+        'psi',
+        'omega',
+        'Gamma',
+        'Delta',
+        'Epsilon',
+        'Theta',
+        'Lambda',
+        'Xi',
+        'Pi',
+        'Sigma',
+        'Phi',
+        'Psi',
+        'Omega',
+    ];
+    static modes = modes;
+    greek = BaseConverter.GREEK_LETTERS;
+    modes = [modes.TeX, modes.TEXT];
+    mode = this.modes[0];
+    static convertNtRoot(input, root) {
+        return Expression_1.Expression.toFunction(constants_1.NTHROOT, [BaseConverter.strip(input), root]);
+    }
+    static convertSQRT(input) {
+        return Expression_1.Expression.toFunction(constants_1.SQRT, [BaseConverter.strip(input)]);
+    }
+    static join(n, d, glue) {
+        if (!n && !d) {
+            return '';
+        }
+        if (n && !d) {
+            return n;
+        }
+        if (d && !n) {
+            return d;
+        }
+        return n + glue + d;
+    }
+    static merge(a, b) {
+        return [a[0] + b[0], a[1] + b[1]];
+    }
+    static strip(input) {
+        const arg = input.copy();
+        delete arg.power;
+        delete arg.multiplier;
+        return arg;
+    }
+    cleanup() {
+        // Override in subclasses if needed
+    }
+    convertPower(input, power, options) {
+        return power.isOne() || (input.isNUM() && power.isZero())
+            ? ''
+            : this.convert(power, options);
+    }
+    finalizePowerAndInput(power, input, _options) {
+        return [power, input];
+    }
+    formatPowerOutput(pArray, requiresBrackets) {
+        const retval = ['', ''];
+        for (let i = 0; i < pArray.length; i++) {
+            const p = pArray[i];
+            if (p === '') {
+                retval[i] = '';
+                continue;
+            }
+            const formatted = this.mode === BaseConverter.modes.TEXT && requiresBrackets
+                ? this.inBrackets(p)
+                : this.inBraces(p);
+            retval[i] = '^' + formatted;
+        }
+        return retval;
+    }
+    formatSubscripts(value) {
+        const parts = value.split('_');
+        let formatted = '';
+        while (parts.length > 1) {
+            formatted = '_' + this.inBraces(parts.pop() + formatted);
+        }
+        return parts[0] + formatted;
+    }
+    getMultiplicationSymbol() {
+        return this.mode === 'TeX' ? ' \\cdot ' : '*';
+    }
+    inBraces(value) {
+        return this.mode === BaseConverter.modes.TEXT ? value : `{${value}}`;
+    }
+    inBrackets(value, type = 'parens') {
+        const bracketTypes = {
+            parens: ['(', ')'],
+            square: ['[', ']'],
+            brace: ['{', '}'],
+            abs: ['|', '|'],
+        };
+        const [L, R] = bracketTypes[type];
+        if (this.mode === BaseConverter.modes.TEXT) {
+            return `${L}${value}${R}`;
+        }
+        if (type === 'brace') {
+            return `\\left\\{${value}\\right\\}`;
+        }
+        return `\\left${L}${value}\\right${R}`;
+    }
+    initInput(input) {
+        return input;
+    }
+    isBracketed(v) {
+        return /^\\left\(.+\\right\)$/.test(v);
+    }
+    requiresMultiplicationSymbol(input) {
+        return input.isSum();
+    }
+    set(m, v, p, input) {
+        const mul = this.getMultiplicationSymbol();
+        const combinePower = input.isProduct();
+        // Format power
+        let tp;
+        if (p) {
+            const power = input.getPower();
+            const requiresBrackets = ((power.isSum() || power.isProduct()) && power.isLinear()) ||
+                (power.isNUM() && !power.isInteger()) ||
+                power.getPower().sign() === -1;
+            p = this.formatPowerOutput(p, requiresBrackets);
+        }
+        if (combinePower) {
+            tp = p[0];
+            p[0] = '';
+        }
+        // Merge v and p
+        v = BaseConverter.merge(v, p);
+        let [mn, md] = m;
+        const [vn, vd] = v;
+        // Filter out unnecessary ones
+        if (vn && Number(mn) === 1) {
+            mn = '';
+        }
+        if (Number(md) === 1) {
+            md = '';
+        }
+        const addMultiplication = this.requiresMultiplicationSymbol(input);
+        const alwaysMul = this.mode === BaseConverter.modes.TeX;
+        const top = BaseConverter.join(mn, vn, alwaysMul || !this.isBracketed(vn) || addMultiplication ? mul : '');
+        let bottom = BaseConverter.join(md, vd, alwaysMul || !this.isBracketed(vd) || addMultiplication ? mul : '');
+        if (md && vd && this.mode === BaseConverter.modes.TEXT) {
+            bottom = this.inBrackets(bottom);
+        }
+        if (top && bottom) {
+            let frac = this.toFraction(top, bottom);
+            if (combinePower && tp) {
+                frac = this.inBrackets(frac) + tp;
+            }
+            return frac;
+        }
+        return top;
+    }
+    setMultiplier(m, multiplierArray, _input, options) {
+        if (options?.decimal) {
+            multiplierArray[0] = m.isInteger() ? String(m.numerator) : m.text(options);
+        }
+        else {
+            multiplierArray[0] = String(m.numerator);
+            multiplierArray[1] = String(m.denominator);
+        }
+    }
+    toFraction(n, d) {
+        if (this.mode === 'TeX') {
+            return ('\\frac' +
+                this.inBraces(this.stripOuterBrackets(n)) +
+                this.inBraces(this.stripOuterBrackets(d)));
+        }
+        return `${n}/${d}`;
+    }
+    value(_input, _isInverted, _isNegative, _options) {
+        return ['', ''];
+    }
+    convertCollection(input, options) {
+        const elements = input.elements.map(e => this.convert(e, options));
+        const inner = elements.join(this.mode === BaseConverter.modes.TeX ? ', \\, ' : ', ');
+        return this.inBrackets(inner);
+    }
+    convertDictionary(input, options) {
+        const pairs = input.entries().map(([key, value]) => {
+            const convertedValue = this.convert(value, options);
+            if (this.mode === BaseConverter.modes.TeX) {
+                return `${key} \\mapsto ${convertedValue}`;
+            }
+            return `${key} => ${convertedValue}`;
+        });
+        const inner = pairs.join(this.mode === BaseConverter.modes.TeX ? ', \\, ' : ', ');
+        if (this.mode === BaseConverter.modes.TeX) {
+            return `\\left\\{${inner}\\right\\}`;
+        }
+        return `{${inner}}`;
+    }
+    convertEquation(input, options) {
+        return `${this.convert(input.LHS, options)}=${this.convert(input.RHS, options)}`;
+    }
+    convertExpression(input, options) {
+        input = this.initInput(input);
+        const pExpr = input.getPower();
+        // Complex exponents are not ordered, and signFree() would replace them with their modulus.
+        // 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 isNegative = input.getMultiplier().isNegative();
+        const m = input.getMultiplier().abs();
+        const multiplierArray = ['', ''];
+        if (!options.ignoreMultiplier) {
+            this.setMultiplier(m, multiplierArray, input, options);
+        }
+        const [finalPower, finalInput] = this.finalizePowerAndInput(power, input, options);
+        const valueArray = this.value(finalInput, isInverted, isNegative, options);
+        const p = this.convertPower(finalInput, finalPower, options);
+        const powerArray = ['', ''];
+        powerArray[isInverted ? 1 : 0] = p;
+        const result = (isNegative ? '-' : '') + this.set(multiplierArray, valueArray, powerArray, finalInput);
+        this.cleanup();
+        return result.replace(/\+-/g, '-');
+    }
+    convertMatrix(input, options) {
+        let retval;
+        if (this.mode === BaseConverter.modes.TEXT) {
+            const rows = input.elements.map(row => {
+                return `[${row.map(e => this.convert(e, options)).join(', ')}]`;
+            });
+            retval = `matrix(${rows.join(', ')})`;
+        }
+        else {
+            const style = options.matrixStyle || '';
+            const matrixOptions = { ...options, insideMatrix: true };
+            const rows = input.elements.map(row => row.map(e => this.convert(e, matrixOptions)).join(' & '));
+            retval = `\\begin{${style}matrix} ${rows.join(' \\\\ ')} \\end{${style}matrix}`;
+        }
+        return retval;
+    }
+    convertValuesSet(input, options) {
+        const elements = input.elements.map(e => this.convert(e, options));
+        const inner = elements.join(this.mode === BaseConverter.modes.TeX ? ', \\, ' : ', ');
+        if (this.mode === BaseConverter.modes.TeX) {
+            return `\\left\\{${inner}\\right\\}`;
+        }
+        return `{${inner}}`;
+    }
+    /**
+     * Removes a single outer \left(...\right) wrapper when the contents
+     * will already be visually grouped (e.g. inside \frac{}{}).
+     */
+    stripOuterBrackets(s) {
+        const left = '\\left(';
+        const right = '\\right)';
+        let retval = s;
+        if (s.startsWith(left) && s.endsWith(right)) {
+            let depth = 0;
+            let isOuterWrapper = true;
+            for (let i = 0; i < s.length && isOuterWrapper;) {
+                if (s.startsWith(left, i)) {
+                    depth++;
+                    i += left.length;
+                }
+                else if (s.startsWith(right, i)) {
+                    depth--;
+                    i += right.length;
+                    if (depth === 0 && i < s.length) {
+                        isOuterWrapper = false;
+                    }
+                    else if (depth < 0) {
+                        isOuterWrapper = false;
+                    }
+                }
+                else {
+                    i++;
+                }
+            }
+            if (isOuterWrapper && depth === 0) {
+                retval = s.slice(left.length, -right.length);
+            }
+        }
+        return retval;
+    }
+    /**
+     * Formats a supported Nerdamer value in the converter's current mode.
+     *
+     * @remarks
+     * String input is parsed before formatting, so current parser settings, constants,
+     * and known values apply. Numbers are converted with JavaScript's string conversion.
+     * Expressions, equations, collections, vectors, matrices, solution sets, value sets,
+     * and dictionaries use their structured representations rather than being reparsed
+     * from display text.
+     * Reading an expression can initialize its lazily stored multiplier or power fields,
+     * but conversion does not change the expression's mathematical value.
+     *
+     * `convertRoots` defaults to `true`, rendering reciprocal integer powers as roots
+     * where the active mode supports that form. `decimal` requests decimal rational
+     * multipliers, `precision` is forwarded to rational formatting, `matrixStyle`
+     * selects the TeX matrix environment prefix, and `ignoreMultiplier` omits an
+     * expression's top-level multiplier. `insideMatrix` is used while formatting matrix
+     * elements and is normally managed by the converter itself.
+     *
+     * @param input - The parser entity, expression string, or number to format.
+     * @param options - Formatting options for this conversion and recursive child conversions.
+     * @returns The formatted text or TeX string for `input`.
+     * @throws Error When `input` is not one of the supported parser entity types.
+     */
+    convert(input, options) {
+        options = { convertRoots: true, ...options };
+        if (typeof input === 'number') {
+            return String(input);
+        }
+        if (typeof input === 'string' || Expression_1.Expression.isExpression(input)) {
+            return this.convertExpression(Expression_1.Expression.create(input), options);
+        }
+        if (input.dataType === constants_1.COLLECTION) {
+            return this.convertCollection(input, options);
+        }
+        if (input.dataType === constants_1.EQUATION) {
+            return this.convertEquation(input, options);
+        }
+        if (input.dataType === constants_1.VECTOR) {
+            const vector = input;
+            const separator = options.insideMatrix
+                ? ' & '
+                : this.mode === BaseConverter.modes.TeX
+                    ? ', \\, '
+                    : ', ';
+            const inner = vector.arrayMap(e => this.convert(e, options)).join(separator);
+            return options.insideMatrix ? inner : this.inBrackets(inner, 'square');
+        }
+        if (input.dataType === constants_1.MATRIX) {
+            return this.convertMatrix(input, options);
+        }
+        if (input.dataType === constants_1.SOLUTIONS_SET) {
+            return this.convertValuesSet(input, options);
+        }
+        if (input.dataType === constants_1.SET) {
+            return this.convertValuesSet(input, options);
+        }
+        if (input.dataType === constants_1.DICTIONARY) {
+            return this.convertDictionary(input, options);
+        }
+        throw new Error((0, errors_1.message)('unsupportedType', { type: constants_1.dataTypes[input.dataType] || typeof input }));
+    }
+    /**
+     * Selects the output syntax used by subsequent conversions.
+     *
+     * @remarks
+     * The mode is mutable converter state. Supported values are `"TeX"` and `"text"`;
+     * changing the mode does not alter parser settings or previously returned strings.
+     *
+     * @param mode - The output mode to activate.
+     * @throws Error When `mode` is not `"TeX"` or `"text"`.
+     */
+    setMode(mode) {
+        if (!this.modes.includes(mode)) {
+            throw new Error((0, errors_1.message)('unrecognizedMode', { mode }));
+        }
+        this.mode = mode;
+    }
+}
+exports.BaseConverter = BaseConverter;