nerdamer 1.1.13 → 2.0.0-rc.1

package/output/core/classes/decimalSet/DecimalSet.js

@@ -0,0 +1,453 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DecimalSet = void 0;
+const decimal_js_1 = __importDefault(require("decimal.js"));
+/**
+ * A high-performance set implementation for Decimal.js numbers.
+ *
+ * This class provides a complete set of operations for working with sets of
+ * arbitrary-precision decimal numbers. It uses string representation internally
+ * for efficient equality comparison and hashing.
+ *
+ * @example
+ * ```typescript
+ * const setA = new DecimalSet([1, 2, 3]);
+ * const setB = new DecimalSet([2, 3, 4]);
+ * const union = setA.union(setB); // {1, 2, 3, 4}
+ * const intersection = setA.intersection(setB); // {2, 3}
+ * ```
+ */
+class DecimalSet {
+    elements;
+    /**
+     * Creates a new DecimalSet.
+     *
+     * @param values - Optional array of values to initialize the set
+     */
+    constructor(values) {
+        this.elements = new Map();
+        if (values) {
+            for (const value of values) {
+                this.add(value);
+            }
+        }
+    }
+    /**
+     * Creates a DecimalSet from an array of values.
+     *
+     * @param values - Array of values
+     * @returns A new DecimalSet
+     */
+    static from(values) {
+        return new DecimalSet(values);
+    }
+    /**
+     * Creates a DecimalSet from a range of values.
+     *
+     * @param start - Start value (inclusive)
+     * @param end - End value (exclusive)
+     * @param step - Step size (default 1)
+     * @returns A new DecimalSet
+     * @throws If a bound or step is non-finite, the step is zero, or the configured
+     * Decimal precision is too low for the step to advance the current value.
+     */
+    static range(start, end, step = 1) {
+        const result = new DecimalSet();
+        const startDec = new decimal_js_1.default(start);
+        const endDec = new decimal_js_1.default(end);
+        const stepDec = new decimal_js_1.default(step);
+        if (!startDec.isFinite() || !endDec.isFinite() || !stepDec.isFinite()) {
+            throw new Error('Range values must be finite');
+        }
+        if (stepDec.isZero()) {
+            throw new Error('Step cannot be zero');
+        }
+        if (stepDec.isPositive()) {
+            let current = startDec;
+            while (current.lessThan(endDec)) {
+                result.add(current);
+                const next = current.plus(stepDec);
+                if (next.equals(current)) {
+                    throw new Error('Step does not advance range at current precision');
+                }
+                current = next;
+            }
+        }
+        else {
+            let current = startDec;
+            while (current.greaterThan(endDec)) {
+                result.add(current);
+                const next = current.plus(stepDec);
+                if (next.equals(current)) {
+                    throw new Error('Step does not advance range at current precision');
+                }
+                current = next;
+            }
+        }
+        return result;
+    }
+    /**
+     * Adds a value to the set.
+     *
+     * @param value - The value to add
+     * @returns The set instance for chaining
+     */
+    add(value) {
+        const decimal = new decimal_js_1.default(value);
+        const key = decimal.toString();
+        this.elements.set(key, decimal);
+        return this;
+    }
+    /**
+     * Removes all elements from the set.
+     */
+    clear() {
+        this.elements.clear();
+    }
+    /**
+     * Creates a shallow copy of the set.
+     */
+    clone() {
+        const result = new DecimalSet();
+        for (const [key, value] of this.elements) {
+            result.elements.set(key, value);
+        }
+        return result;
+    }
+    /**
+     * Removes a value from the set.
+     *
+     * @param value - The value to remove
+     * @returns True if the value was present and removed, false otherwise
+     */
+    delete(value) {
+        const key = new decimal_js_1.default(value).toString();
+        return this.elements.delete(key);
+    }
+    /**
+     * Creates a new set containing the difference (this \ other).
+     *
+     * @param other - The other set
+     * @returns A new set containing elements in this set but not in the other
+     */
+    difference(other) {
+        const result = new DecimalSet();
+        for (const [key, value] of this.elements) {
+            if (!other.elements.has(key)) {
+                result.elements.set(key, value);
+            }
+        }
+        return result;
+    }
+    /**
+     * Checks if this set equals another set.
+     *
+     * @param other - The other set
+     * @returns True if both sets contain the same elements
+     */
+    equals(other) {
+        if (this.size !== other.size) {
+            return false;
+        }
+        for (const key of this.elements.keys()) {
+            if (!other.elements.has(key)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Tests whether all elements pass the predicate test.
+     *
+     * @param predicate - Function to test each element
+     * @returns True if all elements pass the test
+     */
+    every(predicate) {
+        for (const value of this.elements.values()) {
+            if (!predicate(value)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Filters the set based on a predicate function.
+     *
+     * @param predicate - Function to test each element
+     * @returns A new set containing only elements that pass the test
+     */
+    filter(predicate) {
+        const result = new DecimalSet();
+        for (const [key, value] of this.elements) {
+            if (predicate(value)) {
+                result.elements.set(key, value);
+            }
+        }
+        return result;
+    }
+    /**
+     * Executes a callback for each element in the set.
+     *
+     * @param callback - Function to execute for each element
+     * @param thisArg - Value to use as 'this' when executing callback
+     */
+    forEach(callback, thisArg) {
+        for (const value of this.elements.values()) {
+            callback.call(thisArg, value, value, this);
+        }
+    }
+    /**
+     * Checks if a value is in the set.
+     *
+     * @param value - The value to check
+     * @returns True if the value is in the set
+     */
+    has(value) {
+        const key = new decimal_js_1.default(value).toString();
+        return this.elements.has(key);
+    }
+    /**
+     * Creates a new set containing the intersection of this set and another.
+     *
+     * @param other - The other set
+     * @returns A new set containing only elements present in both sets
+     */
+    intersection(other) {
+        const result = new DecimalSet();
+        // Iterate over the smaller set for better performance
+        const [smaller, larger] = this.size <= other.size ? [this, other] : [other, this];
+        for (const [key, value] of smaller.elements) {
+            if (larger.elements.has(key)) {
+                result.elements.set(key, value);
+            }
+        }
+        return result;
+    }
+    /**
+     * Checks if this set is disjoint with another set.
+     *
+     * @param other - The other set
+     * @returns True if the sets have no elements in common
+     */
+    isDisjointFrom(other) {
+        // Iterate over the smaller set for better performance
+        const [smaller, larger] = this.size <= other.size ? [this, other] : [other, this];
+        for (const key of smaller.elements.keys()) {
+            if (larger.elements.has(key)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Checks if the set is empty.
+     */
+    isEmpty() {
+        return this.elements.size === 0;
+    }
+    /**
+     * Checks if this set is a proper subset of another set.
+     *
+     * @param other - The other set
+     * @returns True if this is a subset but not equal to the other set
+     */
+    isProperSubsetOf(other) {
+        return this.size < other.size && this.isSubsetOf(other);
+    }
+    /**
+     * Checks if this set is a proper superset of another set.
+     *
+     * @param other - The other set
+     * @returns True if this is a superset but not equal to the other set
+     */
+    isProperSupersetOf(other) {
+        return this.size > other.size && this.isSupersetOf(other);
+    }
+    /**
+     * Checks if this set is a subset of another set.
+     *
+     * @param other - The other set
+     * @returns True if all elements of this set are in the other set
+     */
+    isSubsetOf(other) {
+        if (this.size > other.size) {
+            return false;
+        }
+        for (const key of this.elements.keys()) {
+            if (!other.elements.has(key)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Checks if this set is a superset of another set.
+     *
+     * @param other - The other set
+     * @returns True if all elements of the other set are in this set
+     */
+    isSupersetOf(other) {
+        return other.isSubsetOf(this);
+    }
+    /**
+     * Maps each element to a new value using a transform function.
+     *
+     * @param transform - Function to transform each element
+     * @returns A new set containing the transformed elements
+     */
+    map(transform) {
+        const result = new DecimalSet();
+        for (const value of this.elements.values()) {
+            result.add(transform(value));
+        }
+        return result;
+    }
+    /**
+     * Returns the maximum value in the set.
+     *
+     * @returns The maximum value, or undefined if the set is empty
+     */
+    max() {
+        if (this.elements.size === 0) {
+            return undefined;
+        }
+        let maxValue;
+        for (const value of this.elements.values()) {
+            if (maxValue === undefined || value.greaterThan(maxValue)) {
+                maxValue = value;
+            }
+        }
+        return maxValue;
+    }
+    /**
+     * Returns the minimum value in the set.
+     *
+     * @returns The minimum value, or undefined if the set is empty
+     */
+    min() {
+        if (this.elements.size === 0) {
+            return undefined;
+        }
+        let minValue;
+        for (const value of this.elements.values()) {
+            if (minValue === undefined || value.lessThan(minValue)) {
+                minValue = value;
+            }
+        }
+        return minValue;
+    }
+    /**
+     * Returns the number of elements in the set.
+     */
+    get size() {
+        return this.elements.size;
+    }
+    /**
+     * Tests whether some element passes the predicate test.
+     *
+     * @param predicate - Function to test each element
+     * @returns True if at least one element passes the test
+     */
+    some(predicate) {
+        for (const value of this.elements.values()) {
+            if (predicate(value)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Returns the sum of all values in the set.
+     *
+     * @returns The sum, or zero if the set is empty
+     */
+    sum() {
+        let total = new decimal_js_1.default(0);
+        for (const value of this.elements.values()) {
+            total = total.plus(value);
+        }
+        return total;
+    }
+    /**
+     * Returns an iterator over the values in the set (same as values()).
+     */
+    *[Symbol.iterator]() {
+        yield* this.values();
+    }
+    /**
+     * Creates a new set containing the symmetric difference.
+     *
+     * @param other - The other set
+     * @returns A new set containing elements in either set but not both
+     */
+    symmetricDifference(other) {
+        const result = new DecimalSet();
+        for (const [key, value] of this.elements) {
+            if (!other.elements.has(key)) {
+                result.elements.set(key, value);
+            }
+        }
+        for (const [key, value] of other.elements) {
+            if (!this.elements.has(key)) {
+                result.elements.set(key, value);
+            }
+        }
+        return result;
+    }
+    /**
+     * Converts the set to an array.
+     */
+    toArray() {
+        return Array.from(this.elements.values());
+    }
+    /**
+     * Returns a sorted array of the set's elements.
+     *
+     * @param compareFn - Optional comparison function
+     * @returns Sorted array of elements
+     */
+    toSorted(compareFn) {
+        const array = this.toArray();
+        if (compareFn) {
+            return array.sort(compareFn);
+        }
+        return array.sort((a, b) => a.comparedTo(b));
+    }
+    /**
+     * Creates a string representation of the set.
+     */
+    toString() {
+        const elements = this.toSorted()
+            .map(d => d.toString())
+            .join(', ');
+        return `DecimalSet { ${elements} }`;
+    }
+    /**
+     * Creates a new set containing the union of this set and another.
+     *
+     * @param other - The other set
+     * @returns A new set containing all elements from both sets
+     */
+    union(other) {
+        const result = new DecimalSet();
+        for (const [key, value] of this.elements) {
+            result.elements.set(key, value);
+        }
+        for (const [key, value] of other.elements) {
+            result.elements.set(key, value);
+        }
+        return result;
+    }
+    /**
+     * Returns an iterator over the values in the set.
+     */
+    *values() {
+        for (const decimal of this.elements.values()) {
+            yield decimal;
+        }
+    }
+}
+exports.DecimalSet = DecimalSet;

package/output/core/classes/dictionary/Dictionary.d.ts

@@ -0,0 +1,102 @@
+import { StructuredEntity } from '../../common/classes/StructuredEntity';
+import { DICTIONARY } from '../parser/constants';
+import type { ParserEntity } from '../../types';
+/**
+ * A key-value container where keys are strings (variable names) and values
+ * are any ParserEntity. Supports element-wise arithmetic operations.
+ *
+ * @remarks
+ * The optional constructor Map is retained rather than copied. {@link set} and
+ * {@link merge} also retain value references, while {@link copy} copies every
+ * stored parser entity. Arrays returned by {@link keys}, {@link values}, and
+ * {@link entries} are new arrays, but their values still refer to the stored
+ * entities.
+ *
+ * Iteration and text output preserve Map insertion order. Replacing an existing
+ * key does not move it. {@link each} can replace values in place; returning
+ * nothing from its callback leaves a value unchanged. Use {@link forEach} for
+ * observation-only traversal. Evaluation and expansion return deep copies.
+ * Dictionaries support structural equality by key and value but define no
+ * greater-than or less-than ordering.
+ *
+ * Syntax: {x => 1, y => 2, z => x+3}
+ * Access: d[x] → 1, d[y] → 2
+ * Assign: d[y]: 10
+ */
+export declare class Dictionary extends StructuredEntity<Dictionary> {
+    /**
+     * Internal storage. The ordered map preserves insertion order for
+     * deterministic iteration and text output.
+     */
+    private _entries;
+    dataType: typeof DICTIONARY;
+    isEnumerable: boolean;
+    precision?: number | undefined;
+    /** Creates a Dictionary, retaining the supplied Map when present. */
+    constructor(entries?: Map<string, ParserEntity>);
+    static isDictionary(obj: unknown): obj is Dictionary;
+    /**
+     * Returns the element for the given string key.
+     * Used by the parser for bracket indexing: d[x] → d.getter('x')
+     */
+    __get__(indices: number[] | string): ParserEntity;
+    /**
+     * Sets the element for the given string key.
+     * Used by the parser for bracket assignment: d[x]: 5
+     */
+    __set__(indices: number[] | string, value: ParserEntity): void;
+    /** Copies the Dictionary, including every stored value. */
+    copy(): Dictionary;
+    /** Number of entries. */
+    count(): number;
+    /** Removes a key-value pair. */
+    delete(key: string): boolean;
+    dimensions(): number[];
+    /**
+     * Visits or replaces entries in insertion order.
+     *
+     * Returning a ParserEntity replaces the current value. Returning `void` leaves
+     * that value unchanged, so callers can inspect a Dictionary without a dummy return.
+     * The callback receives the value and string key.
+     */
+    each(callback: (e: ParserEntity, i?: string | number, j?: string | number) => ParserEntity | void): Dictionary;
+    /**
+     * Satisfies the StructuredEntity abstract property.
+     * Returns the values as an array for compatibility with element-wise operations.
+     */
+    get elements(): ParserEntity[];
+    set elements(values: ParserEntity[]);
+    /**
+     * Returns all entries in insertion order as a new pair array.
+     * Stored value objects are not copied.
+     */
+    entries(): [string, ParserEntity][];
+    eq(other: ParserEntity): boolean;
+    /** Evaluates a copied Dictionary, leaving this one unchanged. */
+    evaluate(): Dictionary;
+    expand(): Dictionary;
+    /** Visits stored value references without changing the Dictionary. */
+    forEach(callback: (value: ParserEntity, key: string) => void): void;
+    /** Gets the stored value reference by key, or `undefined` when absent. */
+    get(key: string): ParserEntity | undefined;
+    gt(_other: ParserEntity): boolean;
+    gte(other: ParserEntity): boolean;
+    /** Checks if a key exists. */
+    has(key: string): boolean;
+    /** Returns all keys. */
+    keys(): string[];
+    lt(_other: ParserEntity): boolean;
+    lte(other: ParserEntity): boolean;
+    /**
+     * Merges another Dictionary into this one. Existing keys are overwritten and
+     * incoming value references are retained.
+     */
+    merge(other: Dictionary): Dictionary;
+    /** Sets a key-value pair by reference and returns this Dictionary. */
+    set(key: string, value: ParserEntity): Dictionary;
+    /** Iterates over `[key, value]` pairs in insertion order. */
+    [Symbol.iterator](): IterableIterator<[string, ParserEntity]>;
+    text(): string;
+    /** Returns stored value references in insertion order in a new array. */
+    values(): ParserEntity[];
+}