nerdamer 2.0.0-rc.1 → 2.0.0

package/output/core/classes/rational/Rational.js

@@ -3,7 +3,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Rational = void 0;
+exports.Rational = exports.MAX_SCIENTIFIC_SIGNIFICANT_DIGITS = void 0;
+exports.validateScientificSignificantDigits = validateScientificSignificantDigits;
 const decimal_js_1 = __importDefault(require("decimal.js"));
 const common_1 = require("../../common/common");
 const errors_1 = require("../../errors");
@@ -12,6 +13,20 @@ const bigint_2 = require("../../functions/bigint/bigint");
 const string_1 = require("../../functions/string");
 const Expression_1 = require("../expression/Expression");
 const constants_1 = require("../parser/constants");
+/** Maximum scientific significant-digit count accepted by decimal.js. */
+exports.MAX_SCIENTIFIC_SIGNIFICANT_DIGITS = 1_000_000_000;
+function validateScientificSignificantDigits(value, received = String(value)) {
+    if (typeof value !== 'number' ||
+        !Number.isInteger(value) ||
+        value < 1 ||
+        value > exports.MAX_SCIENTIFIC_SIGNIFICANT_DIGITS) {
+        throw new errors_1.UnexpectedInputError((0, errors_1.message)('wrongInput', {
+            expected: `an integer from 1 to ${exports.MAX_SCIENTIFIC_SIGNIFICANT_DIGITS}`,
+            received,
+        }));
+    }
+    return value;
+}
 /**
  * Represents an exact rational value as a `bigint` numerator and denominator.
  *
@@ -231,19 +246,6 @@ class Rational {
         }
         return retval;
     }
-    /**
-     * Copies a rational's representation and presentation metadata.
-     *
-     * @param x - Rational to copy.
-     * @returns A distinct `Rational` with the same numerator, denominator, `value`, and
-     * decimal-presentation flag.
-     */
-    static makeCopy(x) {
-        const copy = new Rational(x.numerator, x.denominator);
-        copy.value = x.value;
-        copy.asDecimal = x.asDecimal;
-        return copy;
-    }
     /**
      * Updates shared numeric settings used by rational decimal conversion.
      *
@@ -286,7 +288,7 @@ class Rational {
         }
         // If they want a guaranteed copy then just return a copy
         if (ensureCopy) {
-            return Rational.makeCopy(x);
+            return x.copy();
         }
         // Otherwise just return the original rational
         return x;
@@ -308,7 +310,10 @@ class Rational {
      * @returns A new object with the same numeric representation and presentation metadata.
      */
     copy() {
-        return Rational.makeCopy(this);
+        const copy = new Rational(this.numerator, this.denominator);
+        copy.value = this.value;
+        copy.asDecimal = this.asDecimal;
+        return copy;
     }
     div(num) {
         let retval;
@@ -616,21 +621,66 @@ class Rational {
      * Formats this rational as fraction, integer, or decimal text.
      *
      * @remarks
-     * Decimal formatting is selected when {@link Rational.asDecimal} is set or when
+     * Scientific formatting is selected when `options.scientific` supplies an integer significant-digit
+     * count from 1 through 1e9. The requested count is preserved in the coefficient, including
+     * trailing zeroes. Otherwise decimal formatting is selected when {@link Rational.asDecimal} is set or when
      * `options.decimal` is truthy. Non-integer decimal output uses `decimal.js`; an optional
      * `options.precision` temporarily controls its significant-digit precision for this conversion.
      * Integer decimal output includes a `.0` suffix. Without decimal formatting, non-integer
      * fractions are emitted from the stored numerator and denominator, and integers as plain text.
      *
-     * @param options - Formatting options. `decimal` forces decimal output and `precision` controls
-     * decimal conversion precision when applicable.
+     * @param options - Formatting options. `scientific` selects significant-digit scientific output;
+     * `decimal` forces decimal output and `precision` controls decimal conversion precision when applicable.
      * @returns The formatted numeric text.
      */
     text(options) {
         let value;
+        let scientificValue;
         const thisIsInteger = this.isInteger();
+        const integerDigits = thisIsInteger
+            ? (this.numerator < 0n ? -this.numerator : this.numerator).toString().length
+            : 0;
+        const exactScientific = options?.exactScientific === true;
+        const scientificDigits = options && 'scientific' in options && options.scientific !== undefined
+            ? validateScientificSignificantDigits(options.scientific)
+            : undefined;
+        if (scientificDigits !== undefined) {
+            if (this.isZero()) {
+                scientificValue = '0';
+            }
+            else {
+                const previousPrecision = decimal_js_1.default.precision;
+                const precision = Math.max(previousPrecision, scientificDigits);
+                try {
+                    if (precision !== previousPrecision) {
+                        decimal_js_1.default.set({ precision });
+                    }
+                    const scientific = this.toDecimal().toExponential(scientificDigits - 1);
+                    const [coefficient, exponent] = scientific.split('e');
+                    const normalizedExponent = BigInt(exponent);
+                    const candidate = normalizedExponent === 0n
+                        ? coefficient
+                        : `${coefficient}e${normalizedExponent}`;
+                    if (!exactScientific ||
+                        (thisIsInteger &&
+                            integerDigits > scientificDigits &&
+                            normalizedExponent !== 0n &&
+                            Rational.create(candidate).eq(this))) {
+                        scientificValue = candidate;
+                    }
+                }
+                finally {
+                    if (decimal_js_1.default.precision !== previousPrecision) {
+                        decimal_js_1.default.set({ precision: previousPrecision });
+                    }
+                }
+            }
+        }
+        if (scientificValue !== undefined) {
+            value = scientificValue;
+        }
         // Mark it as a decimal if it is such
-        if (this.asDecimal || options?.decimal) {
+        else if (this.asDecimal || options?.decimal) {
             if (thisIsInteger) {
                 value = `${this.numerator}.0`;
             }

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

@@ -1,7 +1,7 @@
 "use strict";
-/* SEQ.ts – corrected & optimized */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Sequence = void 0;
+const errors_1 = require("../../errors");
 const DEFAULT_MAX_POWER = 50;
 /* ---------- helpers ---------- */
 function factorial(n) {
@@ -44,7 +44,7 @@ class Sequence {
         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');
+            throw new Error((0, errors_1.message)('seqStartsAtInteger'));
         }
     }
     differenceTable() {
@@ -74,10 +74,10 @@ class Sequence {
             }
         }
         if (degree < 0 || degree > this.maxPower) {
-            throw new Error('Sequence is not a polynomial or exceeds maxPower');
+            throw new Error((0, errors_1.message)('seqPolynomialOrMaxPower'));
         }
         if (this.seq.length <= degree) {
-            throw new Error('Insufficient data points for detected degree');
+            throw new Error((0, errors_1.message)('seqInsufficientData'));
         }
         const s = BigInt(this.startsAt);
         const stirling = stirlingTable(degree);

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

@@ -1,6 +1,7 @@
 import { MathematicalAggregate } from '../../common/classes/MathematicalAggregate';
 import { SET, SOLUTIONS_SET } from '../parser/constants';
 import type { NerdamerInput, ParserEntity } from '../../types';
+import type { ParserValuesObject } from '../parser/types';
 /**
  * A finite mathematical set of Nerdamer parser values.
  *
@@ -38,6 +39,13 @@ export declare class ValuesSet extends MathematicalAggregate<ValuesSet> {
      * `SolutionSet`.
      */
     static isValuesSet(obj: unknown): obj is ValuesSet;
+    /**
+     * Stores a value whose uniqueness has already been established by a specialized subclass.
+     *
+     * The value is still copied so the set retains ownership of its members. Callers must check
+     * uniqueness before using this method.
+     */
+    protected addKnownUnique(x: ParserEntity): void;
     protected getValuesArray(): ParserEntity[];
     protected setValuesArray(values: ParserEntity[]): void;
     private indexOf;
@@ -105,7 +113,7 @@ export declare class ValuesSet extends MathematicalAggregate<ValuesSet> {
     /** 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;
+    evaluate(values?: ParserValuesObject): ValuesSet;
     /** Expands every member and returns a new set, collapsing equal results. */
     expand(): ValuesSet;
     /**

package/output/core/classes/valuesSet/ValuesSet.js

@@ -4,6 +4,7 @@ exports.ValuesSet = void 0;
 const MathematicalAggregate_1 = require("../../common/classes/MathematicalAggregate");
 const common_1 = require("../../common/common");
 const errors_1 = require("../../errors");
+const Expression_1 = require("../expression/Expression");
 const constants_1 = require("../parser/constants");
 /**
  * A finite mathematical set of Nerdamer parser values.
@@ -51,6 +52,15 @@ class ValuesSet extends MathematicalAggregate_1.MathematicalAggregate {
     static isValuesSet(obj) {
         return ((0, common_1.isNerdamerNativeType)(obj, constants_1.SET) || (0, common_1.isNerdamerNativeType)(obj, constants_1.SOLUTIONS_SET));
     }
+    /**
+     * Stores a value whose uniqueness has already been established by a specialized subclass.
+     *
+     * The value is still copied so the set retains ownership of its members. Callers must check
+     * uniqueness before using this method.
+     */
+    addKnownUnique(x) {
+        this._elements.push(x.copy());
+    }
     getValuesArray() {
         return this.elements;
     }
@@ -91,7 +101,11 @@ class ValuesSet extends MathematicalAggregate_1.MathematicalAggregate {
     __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}`);
+            throw new RangeError((0, errors_1.message)('indexOutOfBounds', {
+                index: String(index),
+                type: String(this.dataType),
+                length: String(this._elements.length),
+            }));
         }
         return this._elements[index].copy();
     }
@@ -108,7 +122,11 @@ class ValuesSet extends MathematicalAggregate_1.MathematicalAggregate {
     __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}`);
+            throw new RangeError((0, errors_1.message)('indexOutOfBounds', {
+                index: String(index),
+                type: String(this.dataType),
+                length: String(this._elements.length),
+            }));
         }
         const replacement = value.copy();
         const duplicateIndex = this.indexOf(replacement);
@@ -234,8 +252,8 @@ class ValuesSet extends MathematicalAggregate_1.MathematicalAggregate {
         return this.isSubsetOf(other);
     }
     /** Evaluates every member and returns a new set, collapsing equal results. */
-    evaluate() {
-        return this.copy().each(e => e.evaluate());
+    evaluate(values) {
+        return this.copy().each(e => Expression_1.Expression.isExpression(e) ? e.evaluate(values) : e.evaluate());
     }
     /** Expands every member and returns a new set, collapsing equal results. */
     expand() {

package/output/core/classes/vector/Vector.d.ts

@@ -107,9 +107,8 @@ export declare class Vector extends MathematicalAggregate<Vector> {
      */
     each(callback: (e: ParserEntity, i: number) => ParserEntity | void): this;
     eq(V: ParserEntity): boolean;
-    /** Evaluates a copied Vector, resolving symbolic bracket access when values are supplied. */
-    evaluate(): Vector;
-    evaluate(values: ParserValuesObject): ParserEntity;
+    /** Evaluates and returns a copied Vector. */
+    evaluate(values?: ParserValuesObject): Vector;
     /** Expands a copied Vector, leaving this one unchanged. */
     expand(): Vector;
     /**

package/output/core/classes/vector/Vector.js

@@ -76,7 +76,11 @@ class Vector extends MathematicalAggregate_1.MathematicalAggregate {
     __get__(indices) {
         const index = indices[0];
         if (index < 0 || index >= this.elements.length) {
-            throw new errors_1.UnexpectedDataType(`Index ${index} out of bounds for Vector of length ${this.elements.length}`);
+            throw new errors_1.UnexpectedDataType((0, errors_1.message)('indexOutOfBounds', {
+                index: String(index),
+                type: 'Vector',
+                length: String(this.elements.length),
+            }));
         }
         return this.elements[index];
     }
@@ -121,7 +125,7 @@ class Vector extends MathematicalAggregate_1.MathematicalAggregate {
             copy.elements[i] = e.copy();
             return e;
         });
-        return this.copySymbolicAccessTo(copy);
+        return copy;
     }
     /**
      * Gets the number of current elements in the Vector.
@@ -218,18 +222,11 @@ class Vector extends MathematicalAggregate_1.MathematicalAggregate {
         }
         return true;
     }
+    /** Evaluates and returns a copied Vector. */
     evaluate(values) {
-        let retval;
-        const symbolicAccess = Expression_1.Expression.fromSymbolicAccess(this);
-        if (symbolicAccess && values) {
-            retval = symbolicAccess.evaluate(values);
-        }
-        else {
-            const copy = this.copy();
-            copy.each(e => (Expression_1.Expression.isExpression(e) ? e.evaluate(values) : e.evaluate()));
-            retval = copy;
-        }
-        return retval;
+        const copy = this.copy();
+        copy.each(e => (Expression_1.Expression.isExpression(e) ? e.evaluate(values) : e.evaluate()));
+        return copy;
     }
     /** Expands a copied Vector, leaving this one unchanged. */
     expand() {
@@ -436,8 +433,7 @@ class Vector extends MathematicalAggregate_1.MathematicalAggregate {
         return retval;
     }
     text() {
-        const text = `[${this.elements.map(e => e.text()).join(', ')}]`;
-        return this.formatSymbolicAccess(text);
+        return `[${this.elements.map(e => e.text()).join(', ')}]`;
     }
     /**
      * Multiplies corresponding Vector elements, broadcasts a scalar factor, or

package/output/core/classes/vector/dispatch.d.ts

@@ -0,0 +1 @@
+export declare function loadVectorFunctions(): void;

package/output/core/classes/vector/dispatch.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadVectorFunctions = loadVectorFunctions;
+const dispatch_1 = require("../../dispatch");
+const functions_1 = require("./functions");
+function loadVectorFunctions() {
+    Object.assign(dispatch_1.mathFunctionRegistry, {
+        dot: (0, dispatch_1.systemFunction)({ fn: functions_1.dot, minArgs: 2, maxArgs: 2, distElWise: false }),
+        cross: (0, dispatch_1.systemFunction)({ fn: functions_1.cross, minArgs: 2, maxArgs: 2, distElWise: false }),
+    });
+}

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MathematicalAggregate = void 0;
+const errors_1 = require("../../errors");
 const StructuredEntity_1 = require("./StructuredEntity");
 /**
  * MathematicalAggregate
@@ -18,7 +19,11 @@ class MathematicalAggregate extends StructuredEntity_1.StructuredEntity {
     __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}`);
+            throw new RangeError((0, errors_1.message)('indexOutOfBounds', {
+                index: String(index),
+                type: String(this.dataType),
+                length: String(this.elements.length),
+            }));
         }
         return this.elements[index];
     }
@@ -30,7 +35,11 @@ class MathematicalAggregate extends StructuredEntity_1.StructuredEntity {
     __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}`);
+            throw new RangeError((0, errors_1.message)('indexOutOfBounds', {
+                index: String(index),
+                type: String(this.dataType),
+                length: String(this.elements.length),
+            }));
         }
         this.elements[index] = value;
     }

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

@@ -1,4 +1,3 @@
-import type { Expression } from '../../classes/expression/Expression';
 import type { ParserEntity } from '../../types';
 import type { NerdamerInput } from '../../types';
 /**
@@ -14,17 +13,6 @@ export declare abstract class StructuredEntity<T extends StructuredEntity<T, TPr
     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;
@@ -47,9 +35,4 @@ export declare abstract class StructuredEntity<T extends StructuredEntity<T, TPr
     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

@@ -37,29 +37,9 @@ function getAggregateElement(agg, i, j) {
     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);
-        }
-    }
+    const target = lhs;
+    const operation = target[op];
+    return operation.call(target, rhs);
 }
 /**
  * Abstract base class for Vector, Matrix, and Collection classes.
@@ -70,32 +50,6 @@ function applyBinaryOp(op, lhs, rhs) {
  * 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) => {
@@ -132,20 +86,5 @@ class StructuredEntity {
     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

@@ -39,7 +39,6 @@ export interface OperatorDefinition {
     deferRHSResolution?: boolean;
     postfixVariant?: Operator;
 }
-/** Fully normalized operator metadata stored by the parser. */
 export interface Operator extends OperatorDefinition {
     isPrefix: boolean;
     isPostfix: boolean;