nerdamer 1.1.13 → 2.0.0-rc.1

package/output/core/common/classes/MathematicalAggregate.js

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MathematicalAggregate = void 0;
+const StructuredEntity_1 = require("./StructuredEntity");
+/**
+ * MathematicalAggregate
+ *
+ * Base class for linear iterable parser entities (Vector, ValuesSet, SolutionSet, ...).
+ *
+ * Elements are ParserEntity values at this shared level. Concrete subclasses may
+ * narrow their public element storage where their own method guarantees it.
+ */
+class MathematicalAggregate extends StructuredEntity_1.StructuredEntity {
+    /**
+     * Returns the element at the given index.
+     * @param indices A single-element array [i]
+     */
+    __get__(indices) {
+        const index = indices[0];
+        if (index < 0 || index >= this.elements.length) {
+            throw new RangeError(`Index ${index} out of bounds for ${this.dataType} of length ${this.elements.length}`);
+        }
+        return this.elements[index];
+    }
+    /**
+     * Sets the element at the given index.
+     * @param indices A single-element array [i]
+     * @param value The value to set
+     */
+    __set__(indices, value) {
+        const index = indices[0];
+        if (index < 0 || index >= this.elements.length) {
+            throw new RangeError(`Index ${index} out of bounds for ${this.dataType} of length ${this.elements.length}`);
+        }
+        this.elements[index] = value;
+    }
+    clear() {
+        this.elements.length = 0;
+        return this;
+    }
+    /**
+     * Gets the number of current elements.
+     */
+    count() {
+        return this.elements.length;
+    }
+    dimensions() {
+        return [this.elements.length];
+    }
+    /**
+     * Visits or replaces elements in place.
+     * Returning `void` leaves the current element unchanged.
+     */
+    each(callback) {
+        for (let i = 0; i < this.elements.length; i++) {
+            const result = callback(this.elements[i], i);
+            if (result !== undefined) {
+                this.elements[i] = result;
+            }
+        }
+        return this;
+    }
+    eq(other) {
+        if (!this.dimensionsMatch(other)) {
+            return false;
+        }
+        const otherElements = other.elements;
+        for (let i = 0; i < this.elements.length; i++) {
+            if (!this.elements[i].eq(otherElements[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Visits every current element without changing the aggregate.
+     *
+     * This is the observation-only counterpart to {@link each}. Concrete subclasses may
+     * narrow the callback element type when their membership method guarantees a more
+     * specific entity.
+     */
+    forEach(callback) {
+        const elements = this.elements;
+        for (let i = 0; i < elements.length; i++) {
+            callback(elements[i], i);
+        }
+    }
+    gt(other) {
+        if (!this.dimensionsMatch(other)) {
+            return false;
+        }
+        const otherElements = other.elements;
+        for (let i = 0; i < this.elements.length; i++) {
+            if (!this.elements[i].gt(otherElements[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    //  Element-wise comparisons
+    gte(other) {
+        return this.gt(other) || this.eq(other);
+    }
+    lt(other) {
+        if (!this.dimensionsMatch(other)) {
+            return false;
+        }
+        const otherElements = other.elements;
+        for (let i = 0; i < this.elements.length; i++) {
+            if (!this.elements[i].lt(otherElements[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    lte(other) {
+        return this.lt(other) || this.eq(other);
+    }
+    sort(compareFn) {
+        if (compareFn) {
+            this.elements.sort(compareFn);
+            return this;
+        }
+        this.elements.sort((a, b) => {
+            const ta = a && typeof a.text === 'function' ? a.text() : String(a);
+            const tb = b && typeof b.text === 'function' ? b.text() : String(b);
+            return ta < tb ? -1 : ta > tb ? 1 : 0;
+        });
+        return this;
+    }
+    /** Returns an iterator over the aggregate's current public element view. */
+    [Symbol.iterator]() {
+        return this.elements[Symbol.iterator]();
+    }
+    /** Returns a new array containing the aggregate's current public element view. */
+    toArray() {
+        return [...this.elements];
+    }
+}
+exports.MathematicalAggregate = MathematicalAggregate;

package/output/core/common/classes/Scope.d.ts

@@ -0,0 +1,62 @@
+import { SCOPE } from '../../classes/parser/constants';
+import type { Token } from '../../classes/parser/Token';
+export declare class Scope extends Array<Scope | Token> {
+    /**
+     * The column at which the scope was encountered
+     */
+    column: number;
+    dataType: typeof SCOPE;
+    /**
+     * If true, the operator following this scope requires its left-hand structure to remain
+     * unresolved until the operator action is evaluated.
+     */
+    deferLHSResolution: boolean;
+    /**
+     * If true, this scope is a compiled right-hand operand whose evaluation is deferred
+     * until the receiving operator action chooses to execute it.
+     */
+    deferRHSResolution: boolean;
+    /**
+     * The current depth of the scope.
+     */
+    depth: number;
+    /**
+     * If true, adjacency before this scope may need a later parser decision. Square
+     * scopes defer indexing vs implicit multiplication. Parenthesis scopes retain their
+     * implicit-multiplication fallback so a later function registration can reinterpret
+     * the adjacency before RPN conversion.
+     */
+    implicitMultiply: boolean;
+    /**
+     * If the scope was properly closed then this should be closed.
+     */
+    isOpen: boolean;
+    /**
+     * The parent of the current scope
+     */
+    parent?: Scope;
+    /**
+     * The scope type, parentheses, or square, or curly, or pipe.
+     * This will be used to determine what it maps to during parsing.
+     */
+    type: string;
+    constructor(type: string, column: number, parent?: Scope);
+    static isScope(obj: unknown): obj is Scope;
+    /**
+     * Adds a nested scope to the current scope and then returns it, essentially
+     * pointing to the new scope.
+     *
+     * @param column The column number at which the scope was encountered
+     * @param type
+     * @returns
+     */
+    addScope(type: string, column: number): Scope;
+    text(valuesOnly?: boolean): string;
+    /**
+     * This essentially removes the scope and then returns the current scope,
+     * essentially going back up to the previous scope.
+     *
+     * @returns The current scope
+     */
+    upperScope(): Scope | undefined;
+}

package/output/core/common/classes/Scope.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Scope = void 0;
+const constants_1 = require("../../classes/parser/constants");
+const common_1 = require("../common");
+class Scope extends Array {
+    /**
+     * The column at which the scope was encountered
+     */
+    column;
+    dataType;
+    /**
+     * If true, the operator following this scope requires its left-hand structure to remain
+     * unresolved until the operator action is evaluated.
+     */
+    deferLHSResolution = false;
+    /**
+     * If true, this scope is a compiled right-hand operand whose evaluation is deferred
+     * until the receiving operator action chooses to execute it.
+     */
+    deferRHSResolution = false;
+    /**
+     * The current depth of the scope.
+     */
+    depth = 0;
+    /**
+     * If true, adjacency before this scope may need a later parser decision. Square
+     * scopes defer indexing vs implicit multiplication. Parenthesis scopes retain their
+     * implicit-multiplication fallback so a later function registration can reinterpret
+     * the adjacency before RPN conversion.
+     */
+    implicitMultiply = false;
+    /**
+     * If the scope was properly closed then this should be closed.
+     */
+    isOpen = false;
+    /**
+     * The parent of the current scope
+     */
+    parent;
+    /**
+     * The scope type, parentheses, or square, or curly, or pipe.
+     * This will be used to determine what it maps to during parsing.
+     */
+    type;
+    constructor(type, column, parent) {
+        super();
+        this.dataType = constants_1.SCOPE;
+        // The column where this scope was encountered
+        this.column = column;
+        // Scopes typically map to something
+        this.type = type;
+        // A temporary link to the parent of the parent scope;
+        this.parent = parent;
+    }
+    static isScope(obj) {
+        return (0, common_1.isNerdamerNativeType)(obj, constants_1.SCOPE);
+    }
+    /**
+     * Adds a nested scope to the current scope and then returns it, essentially
+     * pointing to the new scope.
+     *
+     * @param column The column number at which the scope was encountered
+     * @param type
+     * @returns
+     */
+    addScope(type, column) {
+        // Yup a circular reference but should be easy to understand.
+        const scope = new Scope(type, column, this);
+        // Mark that this is one scope deeper than this one.
+        scope.depth = this.depth + 1;
+        // Mark it as open
+        scope.isOpen = true;
+        // Add it to the current scope
+        this.push(scope);
+        return scope;
+    }
+    text(valuesOnly = true) {
+        return this.map(token => {
+            // Call scope recursively
+            if (Scope.isScope(token)) {
+                const scopedStr = token.text(valuesOnly);
+                // Put back the parenthesis
+                switch (token.type) {
+                    case 'parenthesis':
+                        return `( ${scopedStr} )`;
+                    case 'square':
+                        return `[ ${scopedStr} ]`;
+                    case 'curly':
+                        return `{ ${scopedStr} }`;
+                    case 'pipe':
+                        return `| ${scopedStr} |`;
+                    default:
+                        return scopedStr;
+                }
+            }
+            else {
+                if (valuesOnly) {
+                    return token.toString();
+                }
+                return `<${token.toString()}, ${token.type}>`;
+            }
+        })
+            .join(valuesOnly ? ' ' : ', ')
+            .replace(/\s+/gi, ' ');
+    }
+    /**
+     * This essentially removes the scope and then returns the current scope,
+     * essentially going back up to the previous scope.
+     *
+     * @returns The current scope
+     */
+    upperScope() {
+        // Close the bracket
+        this.isOpen = false;
+        const parent = this.parent;
+        // This reference is no longer needed. This isn't critical but helps a little with cleanup.
+        delete this.parent;
+        return parent;
+    }
+}
+exports.Scope = Scope;

package/output/core/common/classes/StructuredEntity.d.ts

@@ -0,0 +1,55 @@
+import type { Expression } from '../../classes/expression/Expression';
+import type { ParserEntity } from '../../types';
+import type { NerdamerInput } from '../../types';
+/**
+ * Abstract base class for Vector, Matrix, and Collection classes.
+ * Consolidates common arithmetic operations and parser mappings.
+ *
+ * `TProduct` is reserved for multiplication results that differ from the
+ * concrete structured entity type. Most structures use the default `never`,
+ * so their inherited multiplication continues to return `T` exactly.
+ */
+export declare abstract class StructuredEntity<T extends StructuredEntity<T, TProduct>, TProduct extends ParserEntity = never> {
+    abstract dataType: string;
+    abstract elements: ParserEntity[] | ParserEntity[][];
+    abstract isEnumerable: boolean;
+    abstract precision?: number;
+    /**
+     * Public index expressions retained when bracket access cannot yet be resolved.
+     * This state belongs to a copied structured entity, never the stored source value.
+     */
+    symbolicAccessor?: Expression[];
+    /** Original symbolic target used to render and later re-evaluate bracket access. */
+    symbolicTarget?: Expression;
+    /** Copies symbolic access metadata alongside a concrete structured copy. */
+    protected copySymbolicAccessTo(copy: T): T;
+    /** Renders symbolic access without exposing the carrier's concrete contents. */
+    protected formatSymbolicAccess(baseText: string): string;
+    private binaryOp;
+    abstract __get__(indices: number[] | string): ParserEntity;
+    abstract __set__(indices: number[] | string, value: ParserEntity): void;
+    abs(): T;
+    abstract copy(): T;
+    abstract dimensions(): number[];
+    dimensionsMatch(x: ParserEntity): x is ParserEntity & T;
+    div(x: NerdamerInput): T;
+    abstract each(callback: (e: ParserEntity, i?: string | number, j?: string | number) => ParserEntity | void): T;
+    abstract eq(other: ParserEntity): boolean;
+    abstract evaluate(): T;
+    abstract expand(): T;
+    abstract gt(other: ParserEntity): boolean;
+    abstract gte(other: ParserEntity): boolean;
+    abstract lt(other: ParserEntity): boolean;
+    abstract lte(other: ParserEntity): boolean;
+    minus(x: NerdamerInput): T;
+    plus(x: NerdamerInput): T;
+    pow(x: NerdamerInput): T;
+    abstract text(): string;
+    times(x: NerdamerInput): T | TProduct;
+    toString(): string;
+    /**
+     * Returns a copied structured entity carrying an unresolved bracket access.
+     * Existing accessor state is retained so chained symbolic access can be extended.
+     */
+    withSymbolicAccessor(target: Expression, indices: Expression[]): T;
+}

package/output/core/common/classes/StructuredEntity.js

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StructuredEntity = void 0;
+function isEnumerableLike(x) {
+    if (typeof x !== 'object' || x === null) {
+        return false;
+    }
+    const r = x;
+    return (r['isEnumerable'] === true &&
+        typeof r['dataType'] === 'string' &&
+        Array.isArray(r['elements']));
+}
+function getAggregateElement(agg, i, j) {
+    if (i === undefined) {
+        return undefined;
+    }
+    const idx = typeof i === 'number' ? i : Number(i);
+    if (!Number.isFinite(idx)) {
+        return undefined;
+    }
+    const row = agg.elements[idx];
+    if (row === undefined) {
+        return undefined;
+    }
+    // If matrix-like (array of arrays), index into row using j.
+    if (Array.isArray(row)) {
+        if (j === undefined) {
+            return undefined;
+        }
+        const jdx = typeof j === 'number' ? j : Number(j);
+        if (!Number.isFinite(jdx)) {
+            return undefined;
+        }
+        return row[jdx];
+    }
+    // Vector/collection-like
+    return row;
+}
+function applyBinaryOp(op, lhs, rhs) {
+    switch (op) {
+        case 'plus': {
+            const target = lhs;
+            return target.plus(rhs);
+        }
+        case 'minus': {
+            const target = lhs;
+            return target.minus(rhs);
+        }
+        case 'times': {
+            const target = lhs;
+            return target.times(rhs);
+        }
+        case 'div': {
+            const target = lhs;
+            return target.div(rhs);
+        }
+        case 'pow': {
+            const target = lhs;
+            // Preserve the historical dynamic failure if an Equation reaches element-wise power.
+            return target.pow(rhs);
+        }
+    }
+}
+/**
+ * Abstract base class for Vector, Matrix, and Collection classes.
+ * Consolidates common arithmetic operations and parser mappings.
+ *
+ * `TProduct` is reserved for multiplication results that differ from the
+ * concrete structured entity type. Most structures use the default `never`,
+ * so their inherited multiplication continues to return `T` exactly.
+ */
+class StructuredEntity {
+    /**
+     * Public index expressions retained when bracket access cannot yet be resolved.
+     * This state belongs to a copied structured entity, never the stored source value.
+     */
+    symbolicAccessor;
+    /** Original symbolic target used to render and later re-evaluate bracket access. */
+    symbolicTarget;
+    /** Copies symbolic access metadata alongside a concrete structured copy. */
+    copySymbolicAccessTo(copy) {
+        if (this.symbolicTarget) {
+            copy.symbolicTarget = this.symbolicTarget.copy();
+        }
+        if (this.symbolicAccessor) {
+            copy.symbolicAccessor = this.symbolicAccessor.map(index => index.copy());
+        }
+        return copy;
+    }
+    /** Renders symbolic access without exposing the carrier's concrete contents. */
+    formatSymbolicAccess(baseText) {
+        let retval = baseText;
+        if (this.symbolicAccessor && this.symbolicAccessor.length > 0) {
+            const target = this.symbolicTarget ? this.symbolicTarget.text() : baseText;
+            retval = `${target}[${this.symbolicAccessor.map(index => index.text()).join(', ')}]`;
+        }
+        return retval;
+    }
+    binaryOp(op, x) {
+        const rhsAgg = isEnumerableLike(x) && x.dataType === this.dataType ? x : undefined;
+        return this.copy().each((e, i, j) => {
+            const rhs = rhsAgg ? (getAggregateElement(rhsAgg, i, j) ?? x) : x;
+            return applyBinaryOp(op, e, rhs);
+        });
+    }
+    abs() {
+        return this.copy().each((e) => {
+            return e.abs();
+        });
+    }
+    dimensionsMatch(x) {
+        if (!isEnumerableLike(x) || this.dataType !== x.dataType) {
+            return false;
+        }
+        return x.elements.length === this.elements.length;
+    }
+    div(x) {
+        return this.binaryOp('div', x);
+    }
+    minus(x) {
+        return this.binaryOp('minus', x);
+    }
+    plus(x) {
+        return this.binaryOp('plus', x);
+    }
+    pow(x) {
+        return this.binaryOp('pow', x);
+    }
+    times(x) {
+        return this.binaryOp('times', x);
+    }
+    toString() {
+        return this.text();
+    }
+    /**
+     * Returns a copied structured entity carrying an unresolved bracket access.
+     * Existing accessor state is retained so chained symbolic access can be extended.
+     */
+    withSymbolicAccessor(target, indices) {
+        const retval = this.copy();
+        if (!retval.symbolicTarget) {
+            retval.symbolicTarget = target.copy();
+        }
+        retval.symbolicAccessor = [
+            ...(retval.symbolicAccessor ?? []),
+            ...indices.map(index => index.copy()),
+        ];
+        return retval;
+    }
+}
+exports.StructuredEntity = StructuredEntity;

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

@@ -0,0 +1,63 @@
+export interface Base<Type> {
+    dataType: string;
+    isEnumerable: boolean;
+    text: () => string;
+    copy: () => Type;
+}
+/**
+ * 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.
+ */
+export declare function isNerdamerNativeType(obj: unknown, dataType: string): boolean;
+/**
+ * The supported operator actions
+ */
+export type BinaryArithmeticOperation = 'pow' | 'times' | 'div' | 'minus' | 'plus';
+export type ComparisonOperation = 'eq' | 'lt' | 'lte' | 'gt' | 'gte';
+export type OperatorAction = 'dot' | 'doubleFactorial' | 'factorial' | 'mod' | 'percent' | BinaryArithmeticOperation | 'setEqual' | ComparisonOperation | 'mapTo' | 'comma' | 'assign' | 'functionAssign' | 'in';
+/**
+ * Operator metadata accepted by the parser registry.
+ *
+ * Registration accepts custom action names and the legacy `prefix`/`postfix` aliases.
+ * Prefix, postfix, and iteration flags are optional because the parser supplies defaults.
+ */
+export interface OperatorDefinition {
+    precedence: number;
+    operator: string;
+    action: string;
+    isPrefix?: boolean;
+    isPostfix?: boolean;
+    leftAssoc: boolean;
+    iterates?: boolean;
+    prefix?: boolean;
+    postfix?: boolean;
+    assertiveAction?: string;
+    deferLHSResolution?: boolean;
+    deferRHSResolution?: boolean;
+    postfixVariant?: Operator;
+}
+/** Fully normalized operator metadata stored by the parser. */
+export interface Operator extends OperatorDefinition {
+    isPrefix: boolean;
+    isPostfix: boolean;
+    iterates: boolean;
+    prefix?: never;
+    postfix?: never;
+}
+export interface Bracket {
+    type: string;
+    id: number;
+    isOpen: boolean;
+    isClose: boolean;
+    matches: string;
+}
+export declare const brackets: {
+    [key: string]: Bracket;
+};
+export declare const operators: Record<string, Operator & {
+    action: OperatorAction;
+}>;
+export declare const ASSERTIVE_FUNCTIONS: string[];