nerdamer 1.1.13 → 2.0.0-rc.1

package/output/core/common/common.js

@@ -0,0 +1,279 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ASSERTIVE_FUNCTIONS = exports.operators = exports.brackets = void 0;
+exports.isNerdamerNativeType = isNerdamerNativeType;
+/**
+ * Checks Nerdamer's runtime data-type discriminator without importing a concrete class.
+ *
+ * Class-specific guards such as `Matrix.isMatrix` should remain the normal call site when
+ * that class can be imported safely. This lower-level check backs those guards and provides
+ * the same discriminator in code where a concrete import would introduce a cycle.
+ */
+function isNerdamerNativeType(obj, dataType) {
+    let retval = false;
+    if (typeof obj === 'object' && obj !== null && 'dataType' in obj) {
+        retval = obj.dataType === 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: '|',
+    },
+};
+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: 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: ':',
+        action: 'assign',
+        isPrefix: false,
+        isPostfix: false,
+        leftAssoc: true,
+        iterates: false,
+        deferLHSResolution: true,
+    },
+    ':=': {
+        precedence: 0,
+        operator: ':=',
+        action: 'functionAssign',
+        isPrefix: false,
+        isPostfix: false,
+        leftAssoc: false,
+        iterates: false,
+        deferLHSResolution: true,
+        deferRHSResolution: true,
+    },
+    in: {
+        precedence: 0,
+        operator: 'in',
+        action: 'in',
+        isPrefix: false,
+        isPostfix: false,
+        leftAssoc: true,
+        iterates: false,
+    },
+};
+exports.ASSERTIVE_FUNCTIONS = ['assume'];

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 {};