nerdamer 2.0.0-rc.1 → 2.0.0

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.formatMultiplierString = formatMultiplierString;
 exports.formatPowerString = formatPowerString;
+exports.toDefaultText = toDefaultText;
 exports.toText = toText;
 exports.formatExpressionString = formatExpressionString;
 exports.convertToTitle = convertToTitle;
@@ -21,14 +22,18 @@ function formatMultiplierString(x, options) {
     let retval = '';
     const m = x.getMultiplier();
     const mString = m.text(options);
-    if (mString !== '1' && mString !== '1.0') {
+    const isScientific = options?.scientific !== undefined;
+    const isUnit = isScientific ? m.isOne() : mString === '1' || mString === '1.0';
+    if (!isUnit) {
         retval = mString;
-        if (!m.isInteger() && !(m.asDecimal || options?.decimal)) {
+        if (!m.isInteger() && !(m.asDecimal || options?.decimal || options?.scientific)) {
             retval = `(${retval})`;
         }
-        // Don't show the minus one as -1* but just -
-        // When wrapPow is set, keep -1* to avoid unary minus before **
-        if (retval === '-1' && !options?.wrapPow) {
+        // Keep the established display behavior for approximate decimal values that render as -1.0.
+        const isMinusUnit = isScientific
+            ? m.isMinusOne()
+            : mString === '-1' || mString === '-1.0';
+        if (isMinusUnit && !options?.wrapPow) {
             retval = '-';
         }
         else {
@@ -49,7 +54,11 @@ function formatMultiplierString(x, options) {
 function formatPowerString(x, options, powerOperator) {
     let retval = '';
     const power = x.getPower();
-    const powerString = power.text(options);
+    const powerOptions = {
+        ...options,
+        exactScientific: true,
+    };
+    const powerString = power.text(powerOptions);
     if (powerString !== '1' && powerString !== '1.0') {
         retval = powerString;
         // Wrap fractions in brackets
@@ -81,6 +90,120 @@ function formatPowerString(x, options, powerOperator) {
     }
     return retval;
 }
+function formatDefaultPowerString(x, powerOperator, sortFunction) {
+    let retval = '';
+    const power = x.getPower();
+    const powerString = toDefaultText(power, powerOperator, sortFunction);
+    if (powerString !== '1' && powerString !== '1.0') {
+        retval = powerString;
+        if (power.dataType === constants_1.RATIONAL && !power.isInteger()) {
+            retval = `(${retval})`;
+        }
+        else {
+            let needsBrackets = false;
+            if (power.type === SUM || power.type === PRD) {
+                needsBrackets = true;
+            }
+            else if (x.type === EXP) {
+                if (power.isNUM() && !power.isInteger()) {
+                    needsBrackets = true;
+                }
+                else if (!power.isNUM() && !power.getMultiplier().isOne()) {
+                    needsBrackets = true;
+                }
+            }
+            if (needsBrackets || retval.includes('/')) {
+                retval = `(${retval})`;
+            }
+        }
+        retval = `${powerOperator}${retval}`;
+    }
+    return retval;
+}
+function formatDefaultExpressionString(x, powerOperator, sortFunction) {
+    const glue = x.type === PRD ? '*' : '+';
+    const elements = Object.values(x.getElements());
+    if (Settings_1.Settings.SORT_TERMS) {
+        elements.sort(sortFunction);
+    }
+    return elements
+        .map(element => {
+        let value = toDefaultText(element, powerOperator, sortFunction);
+        if (x.type === PRD && element.isSum()) {
+            value = `(${value})`;
+        }
+        return value;
+    })
+        .join(glue)
+        .replace('+-', '-');
+}
+/**
+ * Formats the ordinary no-options text form without creating formatting option objects
+ * while descending the expression tree.
+ *
+ * This routine follows the same default rendering rules as {@link toText}. Calls that
+ * request explicit formatting options continue through {@link toText}.
+ */
+function toDefaultText(x, powerOperator, sortFunction) {
+    let retval = '';
+    if (x.type === NUM) {
+        retval = x.getMultiplier().text();
+    }
+    else {
+        const multiplier = formatMultiplierString(x);
+        const power = formatDefaultPowerString(x, powerOperator, sortFunction);
+        let value;
+        switch (x.type) {
+            case VAR:
+            case INF:
+                retval = `${multiplier}${x.value}`;
+                break;
+            case FUN: {
+                if (x.name === constants_1.SYMBOLIC_ACCESSOR) {
+                    const args = x.getArguments();
+                    const target = args[0];
+                    const indices = args.slice(1);
+                    retval = `${multiplier}${toDefaultText(target, powerOperator, sortFunction)}[${indices
+                        .map(index => toDefaultText(index, powerOperator, sortFunction))
+                        .join(', ')}]`;
+                }
+                else {
+                    retval = `${multiplier}${x.name || ''}(${x
+                        .getArguments()
+                        .map(argument => toDefaultText(argument, powerOperator, sortFunction))
+                        .join(', ')})`;
+                }
+                break;
+            }
+            case GRP:
+            case SUM:
+                value = formatDefaultExpressionString(x, powerOperator, sortFunction);
+                value = multiplier || power ? `(${value})` : value;
+                retval = `${multiplier}${value}`;
+                break;
+            case PRD:
+                value = formatDefaultExpressionString(x, powerOperator, sortFunction);
+                value = power ? `(${value})` : value;
+                retval = `${multiplier}${value}`;
+                break;
+            case EXP: {
+                const arg = x.getBase();
+                const p = arg.getPower();
+                value = toDefaultText(arg, powerOperator, sortFunction);
+                if (arg.elements ||
+                    value.startsWith('-') ||
+                    value.includes('/') ||
+                    !(p.isOne() || p.isZero())) {
+                    value = `(${value})`;
+                }
+                retval = `${multiplier}${value}`;
+                break;
+            }
+        }
+        retval += power;
+    }
+    return retval.replace(/\+-/g, '-');
+}
 /**
  * Formats an expression using the current formatting policy supplied by Expression.
  *
@@ -92,7 +215,7 @@ function formatPowerString(x, options, powerOperator) {
  * @returns
  */
 function toText(x, options, asId, powerOperator, sortFunction) {
-    options = { ...{ precision: x.precision }, ...options };
+    options = { ...{ precision: x.precision, scientific: x.scientific }, ...options };
     let retval = '';
     if (x.type === NUM) {
         retval = x.getMultiplier().text(options);

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

@@ -23,6 +23,15 @@ export declare function product(...args: Expression[]): Expression;
 export declare function sum(...args: Expression[]): Expression;
 /** Removes the power from an Expression. The original object is unchanged. */
 export declare function stripPower(x: Expression): Expression;
+/**
+ * Deep-copies an Expression tree without routing every nested node back through the
+ * Expression constructor and factory.
+ *
+ * Expression.hook is still applied once for each copied node, matching the existing
+ * copy path. Mutable nested values are recreated so the returned tree remains
+ * independent from the source.
+ */
+export declare function cloneExpressionTree(source: Expression): Expression;
 /**
  * Copies over all the properties of the provided symbolic essentially cloning it to x.
  *

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

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.product = product;
 exports.sum = sum;
 exports.stripPower = stripPower;
+exports.cloneExpressionTree = cloneExpressionTree;
 exports.copyOver = copyOver;
 exports.toArrays = toArrays;
 exports.largestPower = largestPower;
@@ -10,7 +11,6 @@ exports.assertPlainVariableAndGetString = assertPlainVariableAndGetString;
 exports.getNumericOrAssumedValue = getNumericOrAssumedValue;
 const errors_1 = require("../../errors");
 const assume_1 = require("../assumption/assume");
-const Rational_1 = require("../rational/Rational");
 const Expression_1 = require("./Expression");
 const shortcuts_1 = require("./shortcuts");
 /** Multiplies a series of Expressions into one product. */
@@ -35,6 +35,51 @@ function stripPower(x) {
     delete retval.power;
     return retval;
 }
+/**
+ * Deep-copies an Expression tree without routing every nested node back through the
+ * Expression constructor and factory.
+ *
+ * Expression.hook is still applied once for each copied node, matching the existing
+ * copy path. Mutable nested values are recreated so the returned tree remains
+ * independent from the source.
+ */
+function cloneExpressionTree(source) {
+    const hooked = Expression_1.Expression.hook(source);
+    if (!Expression_1.Expression.isExpression(hooked)) {
+        return Expression_1.Expression.create(hooked);
+    }
+    const src = hooked;
+    const target = Object.create(Expression_1.Expression.prototype);
+    target.dataType = src.dataType;
+    target.deferred = src.deferred;
+    target.isEnumerable = src.isEnumerable;
+    target.type = src.type;
+    target.value = src.value;
+    target.precision = src.precision;
+    target.scientific = src.scientific;
+    if (src.multiplier) {
+        target.multiplier = src.multiplier.copy();
+    }
+    if (src.name !== undefined) {
+        target.name = src.name;
+    }
+    if (src.power) {
+        target.power = cloneExpressionTree(src.power);
+    }
+    if (src.args) {
+        target.args = src.args.map(cloneExpressionTree);
+    }
+    if (src.base) {
+        target.base = cloneExpressionTree(src.base);
+    }
+    if (src.elements) {
+        target.elements = {};
+        for (const key in src.elements) {
+            target.elements[key] = cloneExpressionTree(src.elements[key]);
+        }
+    }
+    return target;
+}
 /**
  * Copies over all the properties of the provided symbolic essentially cloning it to x.
  *
@@ -48,7 +93,7 @@ function copyOver(src, target, options) {
     };
     // Copy over the multiplier
     if (src.multiplier && !options.omitMultiplier) {
-        target.multiplier = Rational_1.Rational.makeCopy(src.multiplier);
+        target.multiplier = src.multiplier.copy();
     }
     // toFunctions have name so we need those copied
     if (src.name !== undefined) {
@@ -56,30 +101,31 @@ function copyOver(src, target, options) {
     }
     // Copy over the power
     if (src.power && !options.omitPower) {
-        target.power = Expression_1.Expression.create(src.power, undefined, true);
+        target.power = cloneExpressionTree(src.power);
     }
     // Copy over the args if any
     if (src.args) {
         target.args = [];
         for (const arg of src.args) {
-            target.args.push(Expression_1.Expression.create(arg, undefined, true));
+            target.args.push(cloneExpressionTree(arg));
         }
     }
     // Copy over the base if an
     if (src.base) {
-        target.base = src.base.copy();
+        target.base = cloneExpressionTree(src.base);
     }
     // Copy over the elements if any
     if (src.elements) {
         target.elements = {};
         for (const x in src.elements) {
-            target.elements[x] = Expression_1.Expression.create(src.elements[x], undefined, true);
+            target.elements[x] = cloneExpressionTree(src.elements[x]);
         }
     }
     // Last but not least
     target.type = src.type;
     target.value = src.value;
     target.precision = src.precision;
+    target.scientific = src.scientific;
     target.deferred = src.deferred;
     return target;
 }

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

@@ -116,12 +116,18 @@ class Matrix extends StructuredEntity_1.StructuredEntity {
     __get__(indices) {
         const row = indices[0];
         if (row < 0 || row >= this.elements.length) {
-            throw new errors_1.MathError(`Row index ${row} out of bounds for Matrix with ${this.elements.length} rows`);
+            throw new errors_1.MathError((0, errors_1.message)('matrixRowIndexOutOfBounds', {
+                index: String(row),
+                length: String(this.elements.length),
+            }));
         }
         if (indices.length > 1) {
             const col = indices[1];
             if (col < 0 || col >= this.elements[row].length) {
-                throw new errors_1.MathError(`Column index ${col} out of bounds for Matrix with ${this.elements[row].length} columns`);
+                throw new errors_1.MathError((0, errors_1.message)('matrixColumnIndexOutOfBounds', {
+                    index: String(col),
+                    length: String(this.elements[row].length),
+                }));
             }
             return this.elements[row][col];
         }
@@ -139,16 +145,22 @@ class Matrix extends StructuredEntity_1.StructuredEntity {
      */
     __set__(indices, value) {
         if (typeof indices === 'string') {
-            throw new errors_1.MathError('Matrix does not support string key access');
+            throw new errors_1.MathError((0, errors_1.message)('matrixStringKeyUnsupported'));
         }
         const row = indices[0];
         const col = indices.length > 1 ? indices[1] : undefined;
         if (row < 0 || row >= this.elements.length) {
-            throw new errors_1.MathError(`Row index ${row} out of bounds for Matrix with ${this.elements.length} rows`);
+            throw new errors_1.MathError((0, errors_1.message)('matrixRowIndexOutOfBounds', {
+                index: String(row),
+                length: String(this.elements.length),
+            }));
         }
         if (col !== undefined) {
             if (col < 0 || col >= this.elements[row].length) {
-                throw new errors_1.MathError(`Column index ${col} out of bounds for Matrix with ${this.elements[row].length} columns`);
+                throw new errors_1.MathError((0, errors_1.message)('matrixColumnIndexOutOfBounds', {
+                    index: String(col),
+                    length: String(this.elements[row].length),
+                }));
             }
             this.elements[row][col] = Expression_1.Expression.create(value);
         }
@@ -209,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.
@@ -295,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() {
@@ -425,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();
@@ -727,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;
@@ -844,14 +847,14 @@ class Matrix extends StructuredEntity_1.StructuredEntity {
      */
     trace() {
         if (!this.isSquare()) {
-            throw new errors_1.MathError('Unable to calculate trace for the matrix');
+            throw new errors_1.MathError((0, errors_1.message)('matrixTraceUnavailable'));
         }
         let tr = (0, shortcuts_1.zero)();
         const n = this.elements.length;
         for (let i = 0; i < n; i++) {
             const e = this.elements[i][i];
             if (!Expression_1.Expression.isExpression(e)) {
-                throw new errors_1.MathError('Unable to calculate trace for the matrix');
+                throw new errors_1.MathError((0, errors_1.message)('matrixTraceUnavailable'));
             }
             tr = tr.plus(e);
         }

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

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

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

@@ -0,0 +1,19 @@
+"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");
+function loadMatrixFunctions() {
+    Object.assign(dispatch_1.mathFunctionRegistry, {
+        matrix: (0, dispatch_1.systemFunction)({ fn: math_1.matrix, minArgs: 1, maxArgs: -1, distElWise: false }),
+        imatrix: (0, dispatch_1.systemFunction)({ fn: utils_1.imatrix, minArgs: 1, maxArgs: 1, distElWise: false }),
+        determinant: (0, dispatch_1.systemFunction)({ fn: functions_1.determinant, minArgs: 1, maxArgs: 1, distElWise: false }),
+        invert: (0, dispatch_1.systemFunction)({ fn: functions_1.invert, minArgs: 1, maxArgs: 1, distElWise: false }),
+        transpose: (0, dispatch_1.systemFunction)({ fn: (M) => M.transpose(), minArgs: 1, maxArgs: 1, distElWise: false }),
+        augment: (0, dispatch_1.systemFunction)({ fn: (M, N) => M.augment(N), minArgs: 2, maxArgs: 2, distElWise: false }),
+        rref: (0, dispatch_1.systemFunction)({ fn: (M, prime) => M.rref(prime), minArgs: 1, maxArgs: 2, distElWise: false }),
+        nullspace: (0, dispatch_1.systemFunction)({ fn: functions_1.nullspace, minArgs: 1, maxArgs: 2, distElWise: false }),
+    });
+}

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

@@ -7,6 +7,8 @@ import { Matrix } from './Matrix';
  * @throws {@link core!UnsupportedOperationError} If `M` is not square.
  */
 export declare function determinant(M: Matrix): Expression;
+/** Returns the inverse without modifying the supplied Matrix. */
+export declare function invert(M: Matrix): Matrix;
 /** Returns the nullspace basis as a Vector of basis vectors. */
 export declare function nullspace(M: Matrix, prime?: string | number | Expression): Vector;
 /**

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.determinant = determinant;
+exports.invert = invert;
 exports.nullspace = nullspace;
 exports.characteristicPolynomial = characteristicPolynomial;
 const errors_1 = require("../../errors");
@@ -15,6 +16,10 @@ const Matrix_1 = require("./Matrix");
 function determinant(M) {
     return M.copy().determinant();
 }
+/** Returns the inverse without modifying the supplied Matrix. */
+function invert(M) {
+    return M.inverse();
+}
 /** Returns the nullspace basis as a Vector of basis vectors. */
 function nullspace(M, prime) {
     return new Vector_1.Vector(M.nullspace(prime).map(vector => new Vector_1.Vector(vector)));

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;
     /**
@@ -134,7 +147,7 @@ declare class ExpressionParser {
      * const indexBase = Parser.get('INDEX_BASE');
      * ```
      */
-    get(setting: keyof typeof Settings): number | bigint | boolean | "eng" | "spa" | "fra" | "deu" | "por" | "ita" | "nld";
+    get(setting: keyof typeof Settings): number | bigint | boolean | import("../../errors").Language;
     /**
      * Returns the symbol currently reserved for the imaginary unit.
      *
@@ -165,6 +178,19 @@ declare class ExpressionParser {
      * @returns The configured number of significant digits.
      */
     getPrecision(): number;
+    /**
+     * Reports whether a name is reserved by Nerdamer's parser or solver conventions.
+     *
+     * @remarks
+     * The result reflects the current process-wide parser state. In particular, changing
+     * the imaginary-unit symbol through {@link setI} removes the previous symbol from the
+     * restricted-name list and reserves the replacement. Solver-specific names such as
+     * `_n` and `all` are also reserved.
+     *
+     * @param name - Variable or symbol name to test.
+     * @returns Whether Nerdamer currently reserves the name.
+     */
+    isReserved(name: string): boolean;
     /**
      * Parses supported expression input into a Nerdamer parser entity.
      *