nerdamer 2.0.0-rc.2 → 2.0.0

package/output/core/classes/assumption/assume.d.ts

@@ -74,6 +74,12 @@ export declare function forgetAssumptionFor(x: Expression | string): void;
  * @param x - Plain variable expression or variable name.
  * @returns The registered interval, or `undefined` when no assumption is available.
  */
+/**
+ * Returns a snapshot of all currently registered assumptions.
+ *
+ * Changing the returned Map does not change Nerdamer's active assumptions.
+ */
+export declare function getAssumptions(): Map<string, Assumption>;
 export declare function getAssumptionFor(x: Expression | string): Assumption | undefined;
 /**
  * Parser marker used by `assume(...)` so comparison operators register constraints

package/output/core/classes/assumption/assume.js

@@ -4,6 +4,7 @@ exports.hasAssumptions = hasAssumptions;
 exports.assume = assume;
 exports.clearAssumptions = clearAssumptions;
 exports.forgetAssumptionFor = forgetAssumptionFor;
+exports.getAssumptions = getAssumptions;
 exports.getAssumptionFor = getAssumptionFor;
 exports.assuming = assuming;
 exports.forget = forget;
@@ -110,6 +111,14 @@ function forgetAssumptionFor(x) {
  * @param x - Plain variable expression or variable name.
  * @returns The registered interval, or `undefined` when no assumption is available.
  */
+/**
+ * Returns a snapshot of all currently registered assumptions.
+ *
+ * Changing the returned Map does not change Nerdamer's active assumptions.
+ */
+function getAssumptions() {
+    return new Map(ASSUMPTIONS);
+}
 function getAssumptionFor(x) {
     let symbol;
     if (Expression_1.Expression.isExpression(x) && x.isPlainVariable()) {

package/output/core/classes/expression/CoeffObject.d.ts

@@ -1,6 +1,6 @@
 import { Polynomial } from '../polynomial/Polynomial';
 import { Vector } from '../vector/Vector';
-import { Expression } from './Expression';
+import type { Expression } from './Expression';
 /**
  * Stores coefficients indexed by the power or multidegree collected from an expression.
  *

package/output/core/classes/expression/Expression.d.ts

@@ -122,6 +122,13 @@ export declare class Expression implements Base<Expression> {
         VEC: number;
         MAT: number;
     };
+    /**
+     * Cached ordinary lookup key for SUM and PRD nodes.
+     *
+     * Copies intentionally start without this cache. Aggregate reconstruction clears it
+     * through updateValue() before the node is used again.
+     */
+    private _keyValueCache?;
     /**
      * Arguments stored by a function node.
      *
@@ -149,13 +156,6 @@ export declare class Expression implements Base<Expression> {
      * responsible for preserving a valid expression representation and regenerating derived values.
      */
     elements?: Record<string, Expression>;
-    /**
-     * Cached ordinary lookup key for SUM and PRD nodes.
-     *
-     * Copies intentionally start without this cache. Aggregate reconstruction clears it
-     * through updateValue() before the node is used again.
-     */
-    private _keyValueCache?;
     /**
      * Let's the parser know not to treat it as a set of values
      */
@@ -274,14 +274,6 @@ export declare class Expression implements Base<Expression> {
      * ```
      */
     static fromRational(x: Rational): Expression;
-    /**
-     * Converts a structured entity carrying symbolic bracket access into the scalar
-     * Expression form used by ordinary algebra and function nodes.
-     *
-     * Structured entities without symbolic access are left unchanged by returning
-     * `undefined`; callers can then apply their normal conversion rules.
-     */
-    static fromSymbolicAccess(x: NerdamerInput): Expression | undefined;
     /**
      * Creates a symbolic function node with the given name.
      *
@@ -1498,7 +1490,7 @@ export declare class Expression implements Base<Expression> {
      */
     sptext(options?: TextOptions, asId?: boolean): string;
     /**
-     * Squares this Expression. Shorthand for `this.pow('2')`.
+     * Squares this Expression.
      *
      * @returns A new Expression representing `this²`.
      *

package/output/core/classes/expression/Expression.js

@@ -163,6 +163,13 @@ class Expression {
     };
     /** Internal expression-type constants used by parser and algebra code. */
     static TYPES = constants_1.EXPRESSION_TYPES;
+    /**
+     * Cached ordinary lookup key for SUM and PRD nodes.
+     *
+     * Copies intentionally start without this cache. Aggregate reconstruction clears it
+     * through updateValue() before the node is used again.
+     */
+    _keyValueCache;
     /**
      * Arguments stored by a function node.
      *
@@ -190,13 +197,6 @@ class Expression {
      * responsible for preserving a valid expression representation and regenerating derived values.
      */
     elements = undefined;
-    /**
-     * Cached ordinary lookup key for SUM and PRD nodes.
-     *
-     * Copies intentionally start without this cache. Aggregate reconstruction clears it
-     * through updateValue() before the node is used again.
-     */
-    _keyValueCache;
     /**
      * Let's the parser know not to treat it as a set of values
      */
@@ -354,28 +354,6 @@ class Expression {
         retval.getMultiplier().asDecimal = x.asDecimal;
         return retval;
     }
-    /**
-     * Converts a structured entity carrying symbolic bracket access into the scalar
-     * Expression form used by ordinary algebra and function nodes.
-     *
-     * Structured entities without symbolic access are left unchanged by returning
-     * `undefined`; callers can then apply their normal conversion rules.
-     */
-    static fromSymbolicAccess(x) {
-        let retval;
-        if (typeof x === 'object' && x !== null) {
-            const structured = x;
-            const target = structured.symbolicTarget;
-            const indices = structured.symbolicAccessor;
-            if (Expression.isExpression(target) &&
-                indices &&
-                indices.length > 0 &&
-                indices.every(index => Expression.isExpression(index))) {
-                retval = Expression.toAccessor(target, indices);
-            }
-        }
-        return retval;
-    }
     /**
      * Creates a symbolic function node with the given name.
      *
@@ -649,7 +627,7 @@ class Expression {
             .filter((x) => {
             return x !== undefined;
         })
-            .map(x => Expression.fromSymbolicAccess(x) ?? Expression.create(x));
+            .map(x => Expression.create(x));
         // Set the name
         f.name = name;
         // TODO: This needs to be generated the same way as in text.
@@ -975,7 +953,7 @@ class Expression {
                 : this.text();
         }
         const evaluated = Parser_1.Parser.evaluate(source, values);
-        const retval = Expression.fromSymbolicAccess(evaluated) ?? Expression.create(evaluated);
+        const retval = Expression.create(evaluated);
         if (this.scientific !== undefined) {
             retval.scientific = this.scientific;
         }
@@ -2085,7 +2063,7 @@ class Expression {
         return txt;
     }
     /**
-     * Squares this Expression. Shorthand for `this.pow('2')`.
+     * Squares this Expression.
      *
      * @returns A new Expression representing `this²`.
      *
@@ -2096,7 +2074,7 @@ class Expression {
      * ```
      */
     sq() {
-        return this.pow('2');
+        return this.pow((0, shortcuts_1.two)());
     }
     /**
      * Tests Nerdamer equality while also requiring the same top-level internal type.

package/output/core/classes/matrix/Matrix.d.ts

@@ -115,9 +115,8 @@ export declare class Matrix extends StructuredEntity<Matrix, Vector> {
      */
     each(fn: (e: Expression, i?: string | number, j?: string | number) => Expression | void): Matrix;
     eq(M: ParserEntity): boolean;
-    /** Evaluates a copied matrix, resolving symbolic cell access when values are supplied. */
-    evaluate(): Matrix;
-    evaluate(values: ParserValuesObject): ParserEntity;
+    /** Evaluates and returns a copied matrix. */
+    evaluate(values?: ParserValuesObject): Matrix;
     /** Expands a copied matrix, leaving this one unchanged. */
     expand(): Matrix;
     /** Visits every cell without changing the matrix. */

package/output/core/classes/matrix/Matrix.js

@@ -221,8 +221,7 @@ class Matrix extends StructuredEntity_1.StructuredEntity {
     }
     /** Copies the matrix and every Expression element. */
     copy() {
-        const copy = this.map(e => e.copy());
-        return this.copySymbolicAccessTo(copy);
+        return this.map(e => e.copy());
     }
     /**
      * Computes the determinant by triangular elimination.
@@ -307,18 +306,11 @@ class Matrix extends StructuredEntity_1.StructuredEntity {
         }
         return true;
     }
+    /** Evaluates and returns a copied matrix. */
     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 => e.evaluate(values));
-            retval = copy;
-        }
-        return retval;
+        const copy = this.copy();
+        copy.each(e => e.evaluate(values));
+        return copy;
     }
     /** Expands a copied matrix, leaving this one unchanged. */
     expand() {
@@ -437,7 +429,7 @@ class Matrix extends StructuredEntity_1.StructuredEntity {
         return new Matrix(...inverseElements);
     }
     isSingular() {
-        return this.isSquare() && this.determinant().eq('0');
+        return this.isSquare() && this.determinant().eq((0, shortcuts_1.zero)());
     }
     isSquare() {
         return this.rows() === this.cols();
@@ -739,8 +731,7 @@ class Matrix extends StructuredEntity_1.StructuredEntity {
             }
             textArray.push(`[${rowTextArray.join(', ')}]`);
         }
-        const text = `matrix(${textArray.join(', ')})`;
-        return this.formatSymbolicAccess(text);
+        return `matrix(${textArray.join(', ')})`;
     }
     times(M) {
         let retval;

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

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.loadMatrixFunctions = loadMatrixFunctions;
+const math_1 = require("../../../math/math");
 const dispatch_1 = require("../../dispatch");
 const functions_1 = require("./functions");
 const utils_1 = require("./utils");
-const math_1 = require("../../../math/math");
 function loadMatrixFunctions() {
     Object.assign(dispatch_1.mathFunctionRegistry, {
         matrix: (0, dispatch_1.systemFunction)({ fn: math_1.matrix, minArgs: 1, maxArgs: -1, distElWise: false }),

package/output/core/classes/parser/Parser.d.ts

@@ -62,6 +62,19 @@ declare class ExpressionParser {
      * result, so ordinary substitution does not hand out the stored object itself.
      */
     KNOWN_VALUES: Record<string, ParserEntity>;
+    /**
+     * Resolves a Dictionary index through the active parser scope.
+     *
+     * A plain variable index is resolved directly instead of reparsing its square
+     * scope. This matters for deferred scripting bodies, where LET installs the
+     * current binding in KNOWN_VALUES while excluding that name from inherited
+     * call-scoped substitutions.
+     *
+     * An unresolved symbolic index remains its own textual key, so d[x] still
+     * addresses the literal key "x". Computed indices continue through the normal
+     * parser path.
+     */
+    private extractDictionaryKey;
     /**
      * Converts an index scope to the zero-based indices used internally.
      *
@@ -72,11 +85,11 @@ declare class ExpressionParser {
      */
     private extractIndices;
     /**
-     * Extracts string keys from an index scope for Dictionary access.
-     * For d[x], the scope contains a single variable token "x" → returns ["x"].
-     * For d[myKey], returns ["myKey"].
+     * Resolves or preserves symbolic bracket access after the target and indices have
+     * been parsed. Vector and Matrix arity is checked here so direct bracket parsing
+     * and reevaluation of a preserved accessor follow the same rules.
      */
-    private extractStringKeys;
+    private resolveSymbolicAccess;
     /** Creates another spelling for an existing operator without changing its action. */
     aliasOperator(symbol: string, alias: string): this;
     /**