nerdamer 1.1.13 → 2.0.0-rc.1

package/output/core/classes/seq/SEQ.d.ts

@@ -0,0 +1,13 @@
+export declare class Sequence {
+    private coefficients;
+    private maxPower;
+    private seq;
+    private startsAt;
+    constructor(sequence: (number | bigint)[], opts?: {
+        startsAt?: number;
+        maxPower?: number;
+    });
+    private differenceTable;
+    analyze(): this;
+    toPolynomialString(): string;
+}

package/output/core/classes/seq/SEQ.js

@@ -0,0 +1,137 @@
+"use strict";
+/* SEQ.ts – corrected & optimized */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Sequence = void 0;
+const DEFAULT_MAX_POWER = 50;
+/* ---------- helpers ---------- */
+function factorial(n) {
+    let r = 1n;
+    for (let i = 2; i <= n; i++) {
+        r *= BigInt(i);
+    }
+    return r;
+}
+function binomial(n, k) {
+    if (k < 0 || k > n) {
+        return 0n;
+    }
+    k = Math.min(k, n - k);
+    let r = 1n;
+    for (let i = 1; i <= k; i++) {
+        r = (r * BigInt(n - k + i)) / BigInt(i);
+    }
+    return r;
+}
+/* Precompute signed Stirling numbers of the first kind */
+function stirlingTable(maxN) {
+    const S = Array.from({ length: maxN + 1 }, () => Array(maxN + 1).fill(0n));
+    S[0][0] = 1n;
+    for (let n = 1; n <= maxN; n++) {
+        for (let k = 1; k <= n; k++) {
+            S[n][k] = S[n - 1][k - 1] - BigInt(n - 1) * S[n - 1][k];
+        }
+    }
+    return S;
+}
+/* ---------- main ---------- */
+class Sequence {
+    coefficients = null;
+    maxPower;
+    seq;
+    startsAt;
+    constructor(sequence, opts) {
+        this.seq = sequence.map(v => BigInt(v));
+        this.startsAt = opts?.startsAt ?? 0;
+        this.maxPower = opts?.maxPower ?? DEFAULT_MAX_POWER;
+        if (!Number.isInteger(this.startsAt)) {
+            throw new Error('startsAt must be an integer');
+        }
+    }
+    differenceTable() {
+        const table = [this.seq];
+        while (table[table.length - 1].length > 1) {
+            const prev = table[table.length - 1];
+            const next = [];
+            for (let i = 1; i < prev.length; i++) {
+                next.push(prev[i] - prev[i - 1]);
+            }
+            table.push(next);
+        }
+        return table;
+    }
+    analyze() {
+        if (this.coefficients) {
+            return this;
+        }
+        const table = this.differenceTable();
+        let degree = -1;
+        /* stop at FIRST constant row */
+        for (let i = 0; i < table.length; i++) {
+            const row = table[i];
+            if (row.length >= 2 && row.every(v => v === row[0])) {
+                degree = i;
+                break;
+            }
+        }
+        if (degree < 0 || degree > this.maxPower) {
+            throw new Error('Sequence is not a polynomial or exceeds maxPower');
+        }
+        if (this.seq.length <= degree) {
+            throw new Error('Insufficient data points for detected degree');
+        }
+        const s = BigInt(this.startsAt);
+        const stirling = stirlingTable(degree);
+        /* Newton basis coefficients */
+        const tPoly = [];
+        for (let k = 0; k <= degree; k++) {
+            tPoly[k] = table[k][0] / factorial(k);
+        }
+        /* precompute (-s)^n */
+        const negSPowers = Array(degree + 1).fill(1n);
+        for (let i = 1; i <= degree; i++) {
+            negSPowers[i] = negSPowers[i - 1] * -s;
+        }
+        /* convert to monomial basis (with proper shift) */
+        const poly = Array(degree + 1).fill(0n);
+        for (let k = 0; k <= degree; k++) {
+            for (let m = 0; m <= k; m++) {
+                const sKm = stirling[k][m];
+                if (sKm === 0n) {
+                    continue;
+                }
+                for (let j = 0; j <= m; j++) {
+                    poly[j] += tPoly[k] * sKm * binomial(m, j) * negSPowers[m - j];
+                }
+            }
+        }
+        this.coefficients = poly;
+        return this;
+    }
+    toPolynomialString() {
+        if (!this.coefficients) {
+            this.analyze();
+        }
+        const coeffs = this.coefficients;
+        let out = '';
+        for (let i = coeffs.length - 1; i >= 0; i--) {
+            const c = coeffs[i];
+            if (c === 0n) {
+                continue;
+            }
+            const sign = c < 0n ? '-' : out ? '+' : '';
+            const abs = c < 0n ? -c : c;
+            out += sign;
+            if (i === 0 || abs !== 1n) {
+                out += abs.toString();
+            }
+            if (i >= 1) {
+                out += 'x';
+            }
+            if (i >= 2) {
+                out += '^' + i;
+            }
+        }
+        return out || '0';
+    }
+}
+exports.Sequence = Sequence;

package/output/core/classes/valuesSet/ValuesSet.d.ts

@@ -0,0 +1,179 @@
+import { MathematicalAggregate } from '../../common/classes/MathematicalAggregate';
+import { SET, SOLUTIONS_SET } from '../parser/constants';
+import type { NerdamerInput, ParserEntity } from '../../types';
+/**
+ * A finite mathematical set of Nerdamer parser values.
+ *
+ * @remarks
+ * Membership and uniqueness use each element's `eq()` method rather than JavaScript
+ * reference identity. Two members are considered equal only when both directional equality
+ * checks agree, which keeps mixed-type membership independent of insertion order. This treatment is
+ * conservative for symbolic values: if Nerdamer cannot establish that two
+ * elements are equal, they remain distinct. Values whose entity types cannot be compared are
+ * likewise treated as distinct members. In particular, set membership does not attempt theorem
+ * proving beyond the equality semantics of the stored values.
+ *
+ * `ValuesSet` owns its elements. Values passed to the constructor or {@link add} are copied,
+ * and {@link elements}, {@link at}, and indexed reads return copies. This prevents a caller
+ * from changing a stored mutable object behind the set and silently violating uniqueness.
+ * Mutation therefore goes through the set methods, which re-establish set uniqueness
+ * after every supported change.
+ *
+ * Iteration order is deterministic insertion order so text output and direct traversal are
+ * reproducible, but that order has no mathematical meaning. Equality and subset/superset
+ * comparisons are membership-based and ignore order.
+ *
+ * The arithmetic methods inherited by other structured entities are rejected
+ * here. Pairing two sets by insertion index would make arithmetic depend on a non-mathematical
+ * ordering. Use the explicit finite-set operations on this class instead.
+ */
+export declare class ValuesSet extends MathematicalAggregate<ValuesSet> {
+    private _elements;
+    dataType: typeof SET | typeof SOLUTIONS_SET;
+    isEnumerable: boolean;
+    precision?: number | undefined;
+    constructor(values?: Iterable<ParserEntity>);
+    /**
+     * Tests whether a value is a `ValuesSet` or a specialized `ValuesSet` subtype such as
+     * `SolutionSet`.
+     */
+    static isValuesSet(obj: unknown): obj is ValuesSet;
+    protected getValuesArray(): ParserEntity[];
+    protected setValuesArray(values: ParserEntity[]): void;
+    private indexOf;
+    private membersEqual;
+    /**
+     * Reads an element for parser indexing.
+     *
+     * @throws A `RangeError` if the index is outside the current set size.
+     */
+    __get__(indices: number[]): ParserEntity;
+    /**
+     * Replaces the insertion-order element at an index while preserving uniqueness.
+     *
+     * @remarks
+     * If the replacement is already present elsewhere in the set, the indexed element is
+     * removed instead of creating a duplicate. Indexed mutation is provided for parser
+     * compatibility; the index is not part of the mathematical identity of a set.
+     *
+     * @throws A `RangeError` if the index is outside the current set size.
+     */
+    __set__(indices: number[], value: ParserEntity): void;
+    /** Adds an element if no semantically equal member is already present. */
+    add(x: ParserEntity): ValuesSet;
+    /** Adds every value in the iterable while preserving set uniqueness. */
+    addMany(x: Iterable<ParserEntity>): ValuesSet;
+    /**
+     * Returns a copy of the element at the requested insertion-order index.
+     *
+     * @returns A copy of the stored value, or `undefined` when the index is out of range.
+     */
+    at(i: number): ParserEntity | undefined;
+    /** Removes every member from the set. */
+    clear(): this;
+    /** Returns an independent set containing independent copies of all members. */
+    copy(): ValuesSet;
+    /** Returns the current number of set members. */
+    count(): number;
+    /** Removes the member semantically equal to `x`, if one is present. */
+    delete(x: ParserEntity): boolean;
+    /** Returns a new set containing members of this set that are absent from `other`. */
+    difference(other: ValuesSet): ValuesSet;
+    /** Returns the one-dimensional storage size used by parser indexing. */
+    dimensions(): number[];
+    /**
+     * Rejects binary division because finite sets do not define elementwise quotients.
+     *
+     * @throws {@link core!UnsupportedOperationError} Always.
+     */
+    div(_x: NerdamerInput): ValuesSet;
+    /**
+     * Visits or maps the current members in insertion order.
+     *
+     * Duplicate mapped values collapse to their first occurrence. The callback receives a
+     * copy of each stored member, so mutating an input inside the callback cannot alter the
+     * set unless that value is returned. Returning `void` leaves the current member unchanged.
+     */
+    each(callback: (e: ParserEntity, i?: string | number, j?: string | number) => ParserEntity | void): this;
+    /**
+     * Returns a deep-copied snapshot of the set's current elements.
+     *
+     * Mutating the returned array or its members does not change this set. Use the set's
+     * mutation methods when the stored membership should change.
+     */
+    get elements(): ParserEntity[];
+    /** Tests set equality by membership, independent of insertion order. */
+    eq(other: ParserEntity): boolean;
+    /** Evaluates every member and returns a new set, collapsing equal results. */
+    evaluate(): ValuesSet;
+    /** Expands every member and returns a new set, collapsing equal results. */
+    expand(): ValuesSet;
+    /**
+     * Returns the proper-superset relation for compatibility with parser comparison syntax.
+     * Prefer {@link isProperSupersetOf} in direct set-oriented code.
+     */
+    gt(other: ParserEntity): boolean;
+    /**
+     * Returns the superset relation for compatibility with parser comparison syntax.
+     * Prefer {@link isSupersetOf} in direct set-oriented code.
+     */
+    gte(other: ParserEntity): boolean;
+    /** Tests whether a semantically equal member is present. */
+    has(x: ParserEntity): boolean;
+    /** Returns a new set containing only members present in both sets. */
+    intersection(other: ValuesSet): ValuesSet;
+    /** Returns `true` when this set has no member in common with `other`. */
+    isDisjointFrom(other: ValuesSet): boolean;
+    /** Returns `true` when this set is a strict subset of `other`. */
+    isProperSubsetOf(other: ValuesSet): boolean;
+    /** Returns `true` when this set is a strict superset of `other`. */
+    isProperSupersetOf(other: ValuesSet): boolean;
+    /** Returns `true` when every member of this set is present in `other`. */
+    isSubsetOf(other: ValuesSet): boolean;
+    /** Returns `true` when every member of `other` is present in this set. */
+    isSupersetOf(other: ValuesSet): boolean;
+    /**
+     * Returns the proper-subset relation for compatibility with parser comparison syntax.
+     * Prefer {@link isProperSubsetOf} in direct set-oriented code.
+     */
+    lt(other: ParserEntity): boolean;
+    /**
+     * Returns the subset relation for compatibility with parser comparison syntax.
+     * Prefer {@link isSubsetOf} in direct set-oriented code.
+     */
+    lte(other: ParserEntity): boolean;
+    /**
+     * Rejects binary subtraction because finite sets do not define elementwise subtraction.
+     *
+     * @throws {@link core!UnsupportedOperationError} Always.
+     */
+    minus(_x: NerdamerInput): ValuesSet;
+    /**
+     * Binary addition is not defined for finite sets. Use {@link union} for set union.
+     *
+     * @throws {@link core!UnsupportedOperationError} Always.
+     */
+    plus(_x: NerdamerInput): ValuesSet;
+    /**
+     * Rejects binary exponentiation because finite sets do not define elementwise powers.
+     *
+     * @throws {@link core!UnsupportedOperationError} Always.
+     */
+    pow(_x: NerdamerInput): ValuesSet;
+    /**
+     * Sorts the deterministic iteration order without changing mathematical membership.
+     * A custom comparator receives copies so it cannot mutate stored members as a side effect.
+     */
+    sort(compareFn?: (a: ParserEntity, b: ParserEntity) => number): this;
+    /** Returns a new set containing members present in exactly one of the two sets. */
+    symmetricDifference(other: ValuesSet): ValuesSet;
+    text(): string;
+    /**
+     * Rejects binary multiplication because finite sets do not define elementwise products.
+     *
+     * @throws {@link core!UnsupportedOperationError} Always.
+     */
+    times(_x: NerdamerInput): ValuesSet;
+    /** Returns a new set containing members present in either set. */
+    union(other: ValuesSet): ValuesSet;
+}