nerdamer 2.0.0-rc.2 → 2.0.0

package/output/core/classes/parser/wrappers/IndexedReference.d.ts

@@ -18,14 +18,15 @@ export declare class IndexedReference {
     isEnumerable: boolean;
     constructor(target: ParserEntity, indices: number[] | string, targetName?: string | undefined);
     static isIndexedReference(obj: unknown): obj is IndexedReference;
-    copy(): import("../../expression/Expression").Expression | import("../../vector/Vector").Vector | import("../../valuesSet/ValuesSet").ValuesSet | import("../../collection/Collection").Collection | import("../../matrix/Matrix").Matrix | Dictionary | import("../../equation/Equation").Equation;
+    copy(): import("../../collection/Collection").Collection | import("../../expression/Expression").Expression | import("../../vector/Vector").Vector | import("../../valuesSet/ValuesSet").ValuesSet | import("../../matrix/Matrix").Matrix | import("../../equation/Equation").Equation | Dictionary;
     eq(other: ParserEntity): boolean;
-    evaluate(): import("../../expression/Expression").Expression | import("../../vector/Vector").Vector | import("../../valuesSet/ValuesSet").ValuesSet | import("../../collection/Collection").Collection | import("../../matrix/Matrix").Matrix | Dictionary | import("../../equation/Equation").Equation;
-    expand(): import("../../expression/Expression").Expression | import("../../vector/Vector").Vector | import("../../valuesSet/ValuesSet").ValuesSet | import("../../collection/Collection").Collection | import("../../matrix/Matrix").Matrix | Dictionary | import("../../equation/Equation").Equation;
+    evaluate(): import("../../collection/Collection").Collection | import("../../expression/Expression").Expression | import("../../vector/Vector").Vector | import("../../valuesSet/ValuesSet").ValuesSet | import("../../matrix/Matrix").Matrix | import("../../equation/Equation").Equation | Dictionary;
+    expand(): import("../../collection/Collection").Collection | import("../../expression/Expression").Expression | import("../../vector/Vector").Vector | import("../../valuesSet/ValuesSet").ValuesSet | import("../../matrix/Matrix").Matrix | import("../../equation/Equation").Equation | Dictionary;
     gt(other: ParserEntity): boolean;
     gte(other: ParserEntity): boolean;
     lt(other: ParserEntity): boolean;
     lte(other: ParserEntity): boolean;
     resolve(): ParserEntity;
+    set(value: ParserEntity): void;
     text(): string;
 }

package/output/core/classes/parser/wrappers/IndexedReference.js

@@ -61,6 +61,14 @@ class IndexedReference {
         }
         return this._resolved;
     }
+    set(value) {
+        if (typeof this.indices === 'string') {
+            this.target.__set__(this.indices, value);
+        }
+        else {
+            this.target.__set__(this.indices, value);
+        }
+    }
     text() {
         return this.resolve().text();
     }

package/output/core/classes/parser/wrappers/KeyValuePair.d.ts

@@ -14,8 +14,8 @@ export declare class KeyValuePair {
     static isKeyValuePair(obj: unknown): obj is KeyValuePair;
     copy(): KeyValuePair;
     eq(): boolean;
-    evaluate(): import("../../expression/Expression").Expression | import("../../vector/Vector").Vector | import("../../valuesSet/ValuesSet").ValuesSet | import("../../collection/Collection").Collection | import("../../matrix/Matrix").Matrix | import("../../dictionary/Dictionary").Dictionary | import("../../equation/Equation").Equation;
-    expand(): import("../../expression/Expression").Expression | import("../../vector/Vector").Vector | import("../../valuesSet/ValuesSet").ValuesSet | import("../../collection/Collection").Collection | import("../../matrix/Matrix").Matrix | import("../../dictionary/Dictionary").Dictionary | import("../../equation/Equation").Equation;
+    evaluate(): import("../../collection/Collection").Collection | import("../../expression/Expression").Expression | import("../../vector/Vector").Vector | import("../../valuesSet/ValuesSet").ValuesSet | import("../../matrix/Matrix").Matrix | import("../../equation/Equation").Equation | import("../../dictionary/Dictionary").Dictionary;
+    expand(): import("../../collection/Collection").Collection | import("../../expression/Expression").Expression | import("../../vector/Vector").Vector | import("../../valuesSet/ValuesSet").ValuesSet | import("../../matrix/Matrix").Matrix | import("../../equation/Equation").Equation | import("../../dictionary/Dictionary").Dictionary;
     gt(): boolean;
     gte(): boolean;
     lt(): boolean;

package/output/core/classes/polynomial/Polynomial.js

@@ -103,7 +103,7 @@ class Polynomial {
             // Expand the expression but only if needed. This will be needed if the value has a bracket
             // or if the expression has a power greater than one.
             let expandedForCoefficients = false;
-            if (x.value.includes('(') || (x.isSum() && x.getPower().gt('1'))) {
+            if (x.value.includes('(') || (x.isSum() && x.getPower().gt((0, shortcuts_1.one)()))) {
                 x = (0, expand_1.expand)(x);
                 expandedForCoefficients = true;
             }

package/output/core/classes/polynomial/SparsePolynomial.d.ts

@@ -161,13 +161,6 @@ export declare class SparsePolynomial {
     mapCoefficients(mapper: (coefficient: bigint) => bigint): SparsePolynomial;
     /** Returns the largest absolute coefficient, or zero for the zero polynomial. */
     maxAbsoluteCoefficient(): bigint;
-    /**
-     * Multiplies by another polynomial in the same ring.
-     *
-     * Monomial exponents are added as bigints. The constructor combines products
-     * that land on the same monomial and removes coefficients that cancel to zero.
-     */
-    multiply(other: SparsePolynomial): SparsePolynomial;
     /**
      * Computes the difference of two monomial-scaled polynomials in one sparse
      * traversal. This avoids constructing the monomial factors and multiplication
@@ -175,11 +168,12 @@ export declare class SparsePolynomial {
      */
     monomialScaleSubtract(leftScalar: bigint, leftMonomialExponents: readonly bigint[], other: SparsePolynomial, rightScalar: bigint, rightMonomialExponents: readonly bigint[]): SparsePolynomial;
     /**
-     * Computes a scaled subtraction where the right polynomial is also multiplied
-     * by one monomial. This avoids constructing the two scaled intermediate
-     * polynomials used by fraction-free reduction.
+     * Multiplies by another polynomial in the same ring.
+     *
+     * Monomial exponents are added as bigints. The constructor combines products
+     * that land on the same monomial and removes coefficients that cancel to zero.
      */
-    scaleSubtractMonomial(leftScalar: bigint, other: SparsePolynomial, rightScalar: bigint, monomialExponents: readonly bigint[]): SparsePolynomial;
+    multiply(other: SparsePolynomial): SparsePolynomial;
     /**
      * Returns the additive inverse of this polynomial.
      */
@@ -198,6 +192,12 @@ export declare class SparsePolynomial {
      * Multiplies every coefficient by an exact integer scalar.
      */
     scale(scalar: bigint): SparsePolynomial;
+    /**
+     * Computes a scaled subtraction where the right polynomial is also multiplied
+     * by one monomial. This avoids constructing the two scaled intermediate
+     * polynomials used by fraction-free reduction.
+     */
+    scaleSubtractMonomial(leftScalar: bigint, other: SparsePolynomial, rightScalar: bigint, monomialExponents: readonly bigint[]): SparsePolynomial;
     /**
      * Subtracts another polynomial in the same ring.
      */

package/output/core/classes/polynomial/SparsePolynomial.js

@@ -573,35 +573,6 @@ class SparsePolynomial {
         }
         return maximum;
     }
-    /**
-     * Multiplies by another polynomial in the same ring.
-     *
-     * Monomial exponents are added as bigints. The constructor combines products
-     * that land on the same monomial and removes coefficients that cancel to zero.
-     */
-    multiply(other) {
-        if (this.variableCount !== other.variableCount) {
-            throw new RangeError((0, errors_1.message)('sparseMultiplicationRingMismatch'));
-        }
-        if (this.isZero() || other.isZero()) {
-            return SparsePolynomial.zero(this.variableCount);
-        }
-        const terms = [];
-        for (const left of this.termsByKey.values()) {
-            for (const right of other.termsByKey.values()) {
-                const exponents = new Array(this.variableCount);
-                for (let variableIndex = 0; variableIndex < this.variableCount; variableIndex++) {
-                    exponents[variableIndex] =
-                        left.exponents[variableIndex] + right.exponents[variableIndex];
-                }
-                terms.push({
-                    coefficient: left.coefficient * right.coefficient,
-                    exponents,
-                });
-            }
-        }
-        return new SparsePolynomial(this.variableCount, terms);
-    }
     /**
      * Computes the difference of two monomial-scaled polynomials in one sparse
      * traversal. This avoids constructing the monomial factors and multiplication
@@ -641,48 +612,33 @@ class SparsePolynomial {
         return result;
     }
     /**
-     * Computes a scaled subtraction where the right polynomial is also multiplied
-     * by one monomial. This avoids constructing the two scaled intermediate
-     * polynomials used by fraction-free reduction.
+     * Multiplies by another polynomial in the same ring.
+     *
+     * Monomial exponents are added as bigints. The constructor combines products
+     * that land on the same monomial and removes coefficients that cancel to zero.
      */
-    scaleSubtractMonomial(leftScalar, other, rightScalar, monomialExponents) {
+    multiply(other) {
         if (this.variableCount !== other.variableCount) {
-            throw new RangeError((0, errors_1.message)('sparseSubtractionRingMismatch'));
-        }
-        SparsePolynomial.assertExponents(this.variableCount, monomialExponents);
-        const result = SparsePolynomial.zero(this.variableCount);
-        if (leftScalar !== 0n) {
-            for (const [key, term] of this.termsByKey) {
-                const coefficient = term.coefficient * leftScalar;
-                if (coefficient !== 0n) {
-                    result.termsByKey.set(key, Object.freeze({ coefficient, exponents: term.exponents }));
-                }
-            }
+            throw new RangeError((0, errors_1.message)('sparseMultiplicationRingMismatch'));
         }
-        if (rightScalar === 0n) {
-            return result;
+        if (this.isZero() || other.isZero()) {
+            return SparsePolynomial.zero(this.variableCount);
         }
-        for (const term of other.termsByKey.values()) {
-            const exponents = new Array(this.variableCount);
-            for (let variableIndex = 0; variableIndex < this.variableCount; variableIndex++) {
-                exponents[variableIndex] =
-                    term.exponents[variableIndex] + monomialExponents[variableIndex];
-            }
-            const frozenExponents = Object.freeze(exponents);
-            const key = SparsePolynomial.keyOf(frozenExponents);
-            const existing = result.termsByKey.get(key);
-            const coefficient = (existing?.coefficient ?? 0n) - term.coefficient * rightScalar;
-            if (coefficient === 0n) {
-                result.termsByKey.delete(key);
-            }
-            else {
-                result.termsByKey.set(key, Object.freeze({
-                    coefficient,
-                    exponents: existing?.exponents ?? frozenExponents,
-                }));
+        const terms = [];
+        for (const left of this.termsByKey.values()) {
+            for (const right of other.termsByKey.values()) {
+                const exponents = new Array(this.variableCount);
+                for (let variableIndex = 0; variableIndex < this.variableCount; variableIndex++) {
+                    exponents[variableIndex] =
+                        left.exponents[variableIndex] + right.exponents[variableIndex];
+                }
+                terms.push({
+                    coefficient: left.coefficient * right.coefficient,
+                    exponents,
+                });
             }
         }
-        return result;
+        return new SparsePolynomial(this.variableCount, terms);
     }
     /**
      * Returns the additive inverse of this polynomial.
@@ -749,6 +705,50 @@ class SparsePolynomial {
         }
         return result;
     }
+    /**
+     * Computes a scaled subtraction where the right polynomial is also multiplied
+     * by one monomial. This avoids constructing the two scaled intermediate
+     * polynomials used by fraction-free reduction.
+     */
+    scaleSubtractMonomial(leftScalar, other, rightScalar, monomialExponents) {
+        if (this.variableCount !== other.variableCount) {
+            throw new RangeError((0, errors_1.message)('sparseSubtractionRingMismatch'));
+        }
+        SparsePolynomial.assertExponents(this.variableCount, monomialExponents);
+        const result = SparsePolynomial.zero(this.variableCount);
+        if (leftScalar !== 0n) {
+            for (const [key, term] of this.termsByKey) {
+                const coefficient = term.coefficient * leftScalar;
+                if (coefficient !== 0n) {
+                    result.termsByKey.set(key, Object.freeze({ coefficient, exponents: term.exponents }));
+                }
+            }
+        }
+        if (rightScalar === 0n) {
+            return result;
+        }
+        for (const term of other.termsByKey.values()) {
+            const exponents = new Array(this.variableCount);
+            for (let variableIndex = 0; variableIndex < this.variableCount; variableIndex++) {
+                exponents[variableIndex] =
+                    term.exponents[variableIndex] + monomialExponents[variableIndex];
+            }
+            const frozenExponents = Object.freeze(exponents);
+            const key = SparsePolynomial.keyOf(frozenExponents);
+            const existing = result.termsByKey.get(key);
+            const coefficient = (existing?.coefficient ?? 0n) - term.coefficient * rightScalar;
+            if (coefficient === 0n) {
+                result.termsByKey.delete(key);
+            }
+            else {
+                result.termsByKey.set(key, Object.freeze({
+                    coefficient,
+                    exponents: existing?.exponents ?? frozenExponents,
+                }));
+            }
+        }
+        return result;
+    }
     /**
      * Subtracts another polynomial in the same ring.
      */

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

@@ -125,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.
@@ -222,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() {
@@ -440,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/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/converters/BaseConverter.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseConverter = void 0;
 const Expression_1 = require("../classes/expression/Expression");
+const shortcuts_1 = require("../classes/expression/shortcuts");
 const constants_1 = require("../classes/parser/constants");
 const errors_1 = require("../errors");
 const modes = {
@@ -247,7 +248,7 @@ class BaseConverter {
         // Preserve them verbatim instead of trying to move them into the denominator.
         const isComplexPower = pExpr.isComplex();
         const power = isComplexPower ? pExpr : pExpr.signFree();
-        const isInverted = !isComplexPower && (pExpr.lt(0) || pExpr.sign() === -1);
+        const isInverted = !isComplexPower && (pExpr.lt((0, shortcuts_1.zero)()) || pExpr.sign() === -1);
         const isNegative = input.getMultiplier().isNegative();
         const m = input.getMultiplier().abs();
         const multiplierArray = ['', ''];

package/output/core/fullFunctions.js

@@ -3,14 +3,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.registerNerdamerFunctions = registerNerdamerFunctions;
 const dispatch_1 = require("../algebra/dispatch");
 const dispatch_2 = require("../calculus/dispatch");
-const dispatch_3 = require("./classes/assumption/dispatch");
-const dispatch_4 = require("./classes/matrix/dispatch");
-const dispatch_5 = require("./classes/polynomial/dispatch");
-const dispatch_6 = require("./classes/parser/scripting/dispatch");
-const dispatch_7 = require("./classes/vector/dispatch");
+const dispatch_3 = require("../math/dispatch");
+const dispatch_4 = require("../solve/dispatch");
+const dispatch_5 = require("./classes/assumption/dispatch");
+const dispatch_6 = require("./classes/matrix/dispatch");
+const dispatch_7 = require("./classes/parser/scripting/dispatch");
+const dispatch_8 = require("./classes/polynomial/dispatch");
+const dispatch_9 = require("./classes/vector/dispatch");
 const complex_dispatch_1 = require("./functions/complex.dispatch");
-const dispatch_8 = require("../math/dispatch");
-const dispatch_9 = require("../solve/dispatch");
 /**
  * Registers the complete Nerdamer parser function surface.
  *
@@ -18,14 +18,14 @@ const dispatch_9 = require("../solve/dispatch");
  * and consumers that require the complete Nerdamer notation surface call this registration function.
  */
 function registerNerdamerFunctions() {
-    (0, dispatch_6.loadScriptingFunctions)();
-    (0, dispatch_3.loadAssumptionFunctions)();
-    (0, dispatch_4.loadMatrixFunctions)();
-    (0, dispatch_7.loadVectorFunctions)();
+    (0, dispatch_7.loadScriptingFunctions)();
+    (0, dispatch_5.loadAssumptionFunctions)();
+    (0, dispatch_6.loadMatrixFunctions)();
+    (0, dispatch_9.loadVectorFunctions)();
     (0, complex_dispatch_1.loadComplexFunctions)();
-    (0, dispatch_5.loadPolynomialFunctions)();
-    (0, dispatch_8.loadMathFunctions)();
+    (0, dispatch_8.loadPolynomialFunctions)();
+    (0, dispatch_3.loadMathFunctions)();
     (0, dispatch_1.loadAlgebraFunctions)();
     (0, dispatch_2.loadCalculusFunctions)();
-    (0, dispatch_9.loadSolveFunctions)();
+    (0, dispatch_4.loadSolveFunctions)();
 }

package/output/core/functions/bigint/bigint.d.ts

@@ -45,7 +45,7 @@ export declare function convert(numStr: string): [bigint, bigint];
  * @param n
  * @returns -1 if negative and 1 for positive and 0 for zero
  */
-export declare function sign(n: bigint): 0 | 1 | -1;
+export declare function sign(n: bigint): 1 | 0 | -1;
 /**
  * Checks if a bigint is an even number
  *

package/output/core/functions/numeric.d.ts

@@ -65,7 +65,7 @@ export declare function LCM(...args: number[]): number;
 /** Computes the modular multiplicative inverse for integer JavaScript numbers. */
 export declare function modInv(a: number, p: number): number;
 /** Returns `1` for a prime safe integer and `0` otherwise. */
-export declare function isPrime(x: number): 0 | 1;
+export declare function isPrime(x: number): 1 | 0;
 /** Numeric half-maximum convention for the Heaviside step function. */
 export declare function heaviside(x: number): number;
 /**

package/output/core/parserFunctions.js

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.loadParserFunctions = loadParserFunctions;
-const dispatch_1 = require("./classes/assumption/dispatch");
-const dispatch_2 = require("./classes/matrix/dispatch");
-const dispatch_3 = require("./classes/polynomial/dispatch");
+const dispatch_1 = require("../math/dispatch");
+const dispatch_2 = require("./classes/assumption/dispatch");
+const dispatch_3 = require("./classes/matrix/dispatch");
 const dispatch_4 = require("./classes/parser/scripting/dispatch");
-const dispatch_5 = require("./classes/vector/dispatch");
+const dispatch_5 = require("./classes/polynomial/dispatch");
+const dispatch_6 = require("./classes/vector/dispatch");
 const complex_dispatch_1 = require("./functions/complex.dispatch");
-const dispatch_6 = require("../math/dispatch");
 /**
  * Registers the function surface supplied by the parser package.
  *
@@ -16,10 +16,10 @@ const dispatch_6 = require("../math/dispatch");
  */
 function loadParserFunctions() {
     (0, dispatch_4.loadScriptingFunctions)();
-    (0, dispatch_1.loadAssumptionFunctions)();
-    (0, dispatch_2.loadMatrixFunctions)();
-    (0, dispatch_5.loadVectorFunctions)();
-    (0, dispatch_3.loadPolynomialFunctions)();
+    (0, dispatch_2.loadAssumptionFunctions)();
+    (0, dispatch_3.loadMatrixFunctions)();
+    (0, dispatch_6.loadVectorFunctions)();
+    (0, dispatch_5.loadPolynomialFunctions)();
     (0, complex_dispatch_1.loadComplexFunctions)();
-    (0, dispatch_6.loadMathFunctions)();
+    (0, dispatch_1.loadMathFunctions)();
 }