@danielsimonjr/mathts-functions 0.64.1 → 0.64.3

package/dist/type/matrix/ImmutableDenseMatrix.d.ts

@@ -83,26 +83,21 @@ export declare const createImmutableDenseMatrixClass: import("../../utils/factor
          */
         subset(index: Index, _replacement?: DenseMatrixData | /*elided*/ any | MatrixValue, _defaultValue?: MatrixValue): /*elided*/ any | MatrixValue;
         /**
-         * Replace a single element in the matrix.
-         * @param {Number[]} index Zero-based index
-         * @param {MatrixValue} value
-         * @param {MatrixValue} [defaultValue] Default value, filled in on new entries when
-         *                           the matrix is resized. If not provided,
-         *                           new matrix elements will be left undefined.
-         * @return {ImmutableDenseMatrix} self
+         * Disallows replacing an element in favor of immutability.
+         * @param {Number[]} _index Zero-based index (not used)
+         * @param {MatrixValue} _value The new value (not used)
+         * @param {MatrixValue} [_defaultValue] Default value for new entries (not used)
+         * @throws {Error} Operation not allowed
          */
         set(_index: number[], _value: MatrixValue, _defaultValue?: MatrixValue): /*elided*/ any;
         /**
-         * Resize the matrix to the given size. Returns a copy of the matrix when
-         * `copy=true`, otherwise return the matrix itself (resize in place).
+         * Disallows resizing in favor of immutability.
          *
-         * @param {Number[]} size The new size the matrix should have.
-         * @param {MatrixValue} [defaultValue=0] Default value, filled in on new entries.
-         *                             If not provided, the matrix elements will
-         *                             be filled with zeros.
-         * @param {boolean} [copy] Return a resized copy of the matrix
+         * @param {Number[]} _size The new size (not used)
+         * @param {MatrixValue} [_defaultValue=0] Default value for new entries (not used)
+         * @param {boolean} [_copy] Return a resized copy (not used)
          *
-         * @return {ImmutableDenseMatrix} The resized matrix
+         * @throws {Error} Operation not allowed
          */
         resize(_size: number[], _defaultValue?: MatrixValue, _copy?: boolean): /*elided*/ any;
         /**
@@ -128,12 +123,12 @@ export declare const createImmutableDenseMatrixClass: import("../../utils/factor
          */
         toJSON(): ImmutableDenseMatrixJSON;
         /**
-         * Swap rows i and j in Matrix.
+         * Disallows swapping rows in favor of immutability.
          *
-         * @param {Number} i Matrix row index 1
-         * @param {Number} j Matrix row index 2
+         * @param {Number} _i Matrix row index 1 (not used)
+         * @param {Number} _j Matrix row index 2 (not used)
          *
-         * @return {Matrix} The matrix reference
+         * @throws {Error} Operation not allowed
          */
         swapRows(_i: number, _j: number): /*elided*/ any;
         /**
@@ -207,26 +202,21 @@ export declare const createImmutableDenseMatrixClass: import("../../utils/factor
          */
         subset(index: Index, _replacement?: DenseMatrixData | /*elided*/ any | MatrixValue, _defaultValue?: MatrixValue): /*elided*/ any | MatrixValue;
         /**
-         * Replace a single element in the matrix.
-         * @param {Number[]} index Zero-based index
-         * @param {MatrixValue} value
-         * @param {MatrixValue} [defaultValue] Default value, filled in on new entries when
-         *                           the matrix is resized. If not provided,
-         *                           new matrix elements will be left undefined.
-         * @return {ImmutableDenseMatrix} self
+         * Disallows replacing an element in favor of immutability.
+         * @param {Number[]} _index Zero-based index (not used)
+         * @param {MatrixValue} _value The new value (not used)
+         * @param {MatrixValue} [_defaultValue] Default value for new entries (not used)
+         * @throws {Error} Operation not allowed
          */
         set(_index: number[], _value: MatrixValue, _defaultValue?: MatrixValue): /*elided*/ any;
         /**
-         * Resize the matrix to the given size. Returns a copy of the matrix when
-         * `copy=true`, otherwise return the matrix itself (resize in place).
+         * Disallows resizing in favor of immutability.
          *
-         * @param {Number[]} size The new size the matrix should have.
-         * @param {MatrixValue} [defaultValue=0] Default value, filled in on new entries.
-         *                             If not provided, the matrix elements will
-         *                             be filled with zeros.
-         * @param {boolean} [copy] Return a resized copy of the matrix
+         * @param {Number[]} _size The new size (not used)
+         * @param {MatrixValue} [_defaultValue=0] Default value for new entries (not used)
+         * @param {boolean} [_copy] Return a resized copy (not used)
          *
-         * @return {ImmutableDenseMatrix} The resized matrix
+         * @throws {Error} Operation not allowed
          */
         resize(_size: number[], _defaultValue?: MatrixValue, _copy?: boolean): /*elided*/ any;
         /**
@@ -252,12 +242,12 @@ export declare const createImmutableDenseMatrixClass: import("../../utils/factor
          */
         toJSON(): ImmutableDenseMatrixJSON;
         /**
-         * Swap rows i and j in Matrix.
+         * Disallows swapping rows in favor of immutability.
          *
-         * @param {Number} i Matrix row index 1
-         * @param {Number} j Matrix row index 2
+         * @param {Number} _i Matrix row index 1 (not used)
+         * @param {Number} _j Matrix row index 2 (not used)
          *
-         * @return {Matrix} The matrix reference
+         * @throws {Error} Operation not allowed
          */
         swapRows(_i: number, _j: number): /*elided*/ any;
         /**

package/dist/type/matrix/ImmutableDenseMatrix.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ImmutableDenseMatrix.d.ts","sourceRoot":"","sources":["../../../src/type/matrix/ImmutableDenseMatrix.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"ImmutableDenseMatrix.d.ts","sourceRoot":"","sources":["../../../src/type/matrix/ImmutableDenseMatrix.ts"],"names":[],"mappings":"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"}

package/dist/type/matrix/MatrixIndex.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MatrixIndex.d.ts","sourceRoot":"","sources":["../../../src/type/matrix/MatrixIndex.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"MatrixIndex.d.ts","sourceRoot":"","sources":["../../../src/type/matrix/MatrixIndex.ts"],"names":[],"mappings":"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"}

package/dist/type/matrix/Spa.d.ts

@@ -27,7 +27,7 @@ export declare const createSpaClass: import("../../utils/factory.js").FactoryFun
          * Set the value for index i.
          *
          * @param {number} i                       The index
-         * @param {number | BigNumber | Complex}   The value at index i
+         * @param {number | BigNumber | Complex} v The value at index i
          */
         set(i: number, v: SpaValue): void;
         get(i: number): SpaValue;

package/dist/type/matrix/function/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/type/matrix/function/index.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAC;AAErE,UAAU,gBAAgB;IACxB,KAAK,GAAG,MAAM,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC;CACrC;AAED,UAAU,iBAAiB;IACzB,KAAK,EAAE,aAAa,CAAC;IACrB,KAAK,EAAE,gBAAgB,CAAC;CACzB;AAKD,eAAO,MAAM,WAAW,iFA8DvB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/type/matrix/function/index.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAC;AAErE,UAAU,gBAAgB;IACxB,KAAK,GAAG,MAAM,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC;CACrC;AAED,UAAU,iBAAiB;IACzB,KAAK,EAAE,aAAa,CAAC;IACrB,KAAK,EAAE,gBAAgB,CAAC;CACzB;AAKD,eAAO,MAAM,WAAW,iFAgEvB,CAAC"}

package/dist/type/matrix/utils/matAlgo09xS0Sf.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"matAlgo09xS0Sf.d.ts","sourceRoot":"","sources":["../../../../src/type/matrix/utils/matAlgo09xS0Sf.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,QAAQ,EACR,WAAW,EACX,WAAW,EACX,cAAc,EACd,mBAAmB,EACnB,aAAa,EACb,2BAA2B,EAC5B,MAAM,aAAa,CAAC;AAErB;;;GAGG;AACH,UAAU,YAAY;IACpB,OAAO,CAAC,EAAE,WAAW,EAAE,CAAC;IACxB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACxB,KAAK,CAAC,EAAE,WAAW,CAAC;IACpB,SAAS,CAAC,EAAE,QAAQ,CAAC;IACrB,WAAW,CAAC,IAAI,MAAM,CAAC;IACvB,kBAAkB,CAAC,IAAI,EAAE,2BAA2B,GAAG,YAAY,CAAC;CACrE;AAKD,eAAO,MAAM,oBAAoB;WAGG,aAAa;iBAAe,mBAAmB;OAoB1E,YAAY,KACZ,YAAY,YACL,cAAc,KACvB,YAAY,CAqHlB,CAAC"}
+{"version":3,"file":"matAlgo09xS0Sf.d.ts","sourceRoot":"","sources":["../../../../src/type/matrix/utils/matAlgo09xS0Sf.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,QAAQ,EACR,WAAW,EACX,WAAW,EACX,cAAc,EACd,mBAAmB,EACnB,aAAa,EACb,2BAA2B,EAC5B,MAAM,aAAa,CAAC;AAErB;;;GAGG;AACH,UAAU,YAAY;IACpB,OAAO,CAAC,EAAE,WAAW,EAAE,CAAC;IACxB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACxB,KAAK,CAAC,EAAE,WAAW,CAAC;IACpB,SAAS,CAAC,EAAE,QAAQ,CAAC;IACrB,WAAW,CAAC,IAAI,MAAM,CAAC;IACvB,kBAAkB,CAAC,IAAI,EAAE,2BAA2B,GAAG,YAAY,CAAC;CACrE;AAKD,eAAO,MAAM,oBAAoB;WAGG,aAAa;iBAAe,mBAAmB;OAoB1E,YAAY,KACZ,YAAY,YACL,cAAc,KACvB,YAAY,CAwHlB,CAAC"}

package/dist/type/matrix/utils/matAlgo11xS0s.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"matAlgo11xS0s.d.ts","sourceRoot":"","sources":["../../../../src/type/matrix/utils/matAlgo11xS0s.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,QAAQ,EACR,WAAW,EACX,cAAc,EACd,mBAAmB,EACnB,aAAa,EACb,2BAA2B,EAC5B,MAAM,aAAa,CAAC;AAErB;;;GAGG;AACH,UAAU,YAAY;IACpB,OAAO,CAAC,EAAE,WAAW,EAAE,CAAC;IACxB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACxB,SAAS,CAAC,EAAE,QAAQ,CAAC;IACrB,kBAAkB,CAAC,IAAI,EAAE,2BAA2B,GAAG,YAAY,CAAC;CACrE;AAKD,eAAO,MAAM,mBAAmB;WAGI,aAAa;iBAAe,mBAAmB;OA0B1E,YAAY,KACZ,WAAW,YACJ,cAAc,WACf,OAAO,KACf,YAAY,CAsFlB,CAAC"}
+{"version":3,"file":"matAlgo11xS0s.d.ts","sourceRoot":"","sources":["../../../../src/type/matrix/utils/matAlgo11xS0s.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,QAAQ,EACR,WAAW,EACX,cAAc,EACd,mBAAmB,EACnB,aAAa,EACb,2BAA2B,EAC5B,MAAM,aAAa,CAAC;AAErB;;;GAGG;AACH,UAAU,YAAY;IACpB,OAAO,CAAC,EAAE,WAAW,EAAE,CAAC;IACxB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACxB,SAAS,CAAC,EAAE,QAAQ,CAAC;IACrB,kBAAkB,CAAC,IAAI,EAAE,2BAA2B,GAAG,YAAY,CAAC;CACrE;AAKD,eAAO,MAAM,mBAAmB;WAGI,aAAa;iBAAe,mBAAmB;OA0B1E,YAAY,KACZ,WAAW,YACJ,cAAc,WACf,OAAO,KACf,YAAY,CA0FlB,CAAC"}

package/dist/type/matrix/utils/matrixAlgorithmSuite.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"matrixAlgorithmSuite.d.ts","sourceRoot":"","sources":["../../../../src/type/matrix/utils/matrixAlgorithmSuite.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EACV,aAAa,EACb,2BAA2B,EAC3B,gBAAgB,EAChB,eAAe,EACf,eAAe,EAChB,MAAM,aAAa,CAAC;AAErB;;GAEG;AACH,UAAU,MAAO,SAAQ,eAAe;IACtC,KAAK,CAAC,EAAE,eAAe,CAAC;IACxB,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;GAEG;AACH,KAAK,iBAAiB,GAAG,CAAC,IAAI,EAAE,eAAe,KAAK,MAAM,CAAC;AAK3D;;GAEG;AACH,UAAU,gCAAgC;IACxC,KAAK,EAAE,aAAa,CAAC;IACrB,MAAM,EAAE,iBAAiB,CAAC;CAC3B;AAED,eAAO,MAAM,0BAA0B,kGAgCW,2BAA2B,KAAG,gBAAgB,CAwL/F,CAAC"}
+{"version":3,"file":"matrixAlgorithmSuite.d.ts","sourceRoot":"","sources":["../../../../src/type/matrix/utils/matrixAlgorithmSuite.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EACV,aAAa,EACb,2BAA2B,EAC3B,gBAAgB,EAChB,eAAe,EACf,eAAe,EAChB,MAAM,aAAa,CAAC;AAErB;;GAEG;AACH,UAAU,MAAO,SAAQ,eAAe;IACtC,KAAK,CAAC,EAAE,eAAe,CAAC;IACxB,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;GAEG;AACH,KAAK,iBAAiB,GAAG,CAAC,IAAI,EAAE,eAAe,KAAK,MAAM,CAAC;AAK3D;;GAEG;AACH,UAAU,gCAAgC;IACxC,KAAK,EAAE,aAAa,CAAC;IACrB,MAAM,EAAE,iBAAiB,CAAC;CAC3B;AAED,eAAO,MAAM,0BAA0B,kGAgCW,2BAA2B,KAAG,gBAAgB,CAwM/F,CAAC"}

package/dist/type/unit/physicalConstants.d.ts

@@ -1,5 +1,5 @@
 import type { MathJsConfig } from '../../core/config.js';
-import type Decimal from 'decimal.js';
+import type { Decimal } from 'decimal.js';
 /**
  * Constructor for BigNumber instances
  */

package/dist/type/unit/physicalConstants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"physicalConstants.d.ts","sourceRoot":"","sources":["../../../src/type/unit/physicalConstants.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACzD,OAAO,KAAK,OAAO,MAAM,YAAY,CAAC;AAEtC;;GAEG;AACH,UAAU,oBAAoB;IAC5B,KAAK,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;CACvC;AAED;;GAEG;AACH,UAAU,SAAS;IACjB,KAAK,KAAK,EAAE,MAAM,GAAG,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,YAAY,CAAC;CAC3D;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,SAAS,EAAE,OAAO,CAAC;CACpB;AAED;;GAEG;AACH,UAAU,uBAAuB;IAC/B,MAAM,EAAE,YAAY,CAAC;IACrB,IAAI,EAAE,SAAS,CAAC;IAChB,SAAS,EAAE,oBAAoB,CAAC;CACjC;AAED;;GAEG;AACH,UAAU,yBAAyB;IACjC,MAAM,EAAE,YAAY,CAAC;IACrB,SAAS,EAAE,oBAAoB,CAAC;CACjC;AASD,eAAO,MAAM,kBAAkB,yFAI9B,CAAC;AACF,eAAO,MAAM,yBAAyB,yFAIrC,CAAC;AACF,eAAO,MAAM,oBAAoB,yFAIhC,CAAC;AACF,eAAO,MAAM,2BAA2B,yFAIvC,CAAC;AAGF,eAAO,MAAM,sBAAsB,yFAIlC,CAAC;AACF,eAAO,MAAM,sBAAsB,yFAIlC,CAAC;AACF,eAAO,MAAM,qBAAqB,yFAIjC,CAAC;AACF,eAAO,MAAM,aAAa,yFAIzB,CAAC;AACF,eAAO,MAAM,qBAAqB,yFAIjC,CAAC;AACF,eAAO,MAAM,sBAAsB,yFAIlC,CAAC;AACF,eAAO,MAAM,kBAAkB,yFAI9B,CAAC;AACF,eAAO,MAAM,wBAAwB,yFAIpC,CAAC;AACF,eAAO,MAAM,+BAA+B,yFAI3C,CAAC;AACF,eAAO,MAAM,yBAAyB,yFAIrC,CAAC;AACF,eAAO,MAAM,qBAAqB,yFAIjC,CAAC;AACF,eAAO,MAAM,cAAc,yFAAuE,CAAC;AACnG,eAAO,MAAM,eAAe,yFAI3B,CAAC;AAGF,eAAO,MAAM,gBAAgB,yFAAsE,CAAC;AACpG,eAAO,MAAM,6BAA6B,yFAIzC,CAAC;AACF,eAAO,MAAM,kBAAkB,yFAI9B,CAAC;AACF,eAAO,MAAM,mBAAmB,yFAI/B,CAAC;AACF,eAAO,MAAM,mBAAmB,wGAAkD,CAAC;AACnF,eAAO,MAAM,mBAAmB,yFAI/B,CAAC;AACF,eAAO,MAAM,gBAAgB,yFAI5B,CAAC;AACF,eAAO,MAAM,kBAAkB,yFAI9B,CAAC;AACF,eAAO,MAAM,iBAAiB,yFAI7B,CAAC;AACF,eAAO,MAAM,0BAA0B,yFAItC,CAAC;AACF,eAAO,MAAM,aAAa,yFAAoE,CAAC;AAC/F,eAAO,MAAM,yBAAyB,yFAIrC,CAAC;AACF,eAAO,MAAM,qBAAqB,wGAA4C,CAAC;AAC/E,eAAO,MAAM,kBAAkB,wGAAsC,CAAC;AAGtE,eAAO,MAAM,gBAAgB,yFAI5B,CAAC;AACF,eAAO,MAAM,cAAc,yFAAqE,CAAC;AACjG,eAAO,MAAM,eAAe,yFAAqE,CAAC;AAClG,eAAO,MAAM,aAAa,yFAIzB,CAAC;AACF,eAAO,MAAM,oBAAoB,yFAIhC,CAAC;AACF,eAAO,MAAM,sBAAsB,yFAIlC,CAAC;AACF,eAAO,MAAM,eAAe,yFAI3B,CAAC;AACF,eAAO,MAAM,iBAAiB,yFAI7B,CAAC;AACF,eAAO,MAAM,yBAAyB,yFAIrC,CAAC;AACF,eAAO,MAAM,iBAAiB,yFAI7B,CAAC;AACF,eAAO,MAAM,mBAAmB,wGAAiD,CAAC;AAClF,eAAO,MAAM,qBAAqB,yFAIjC,CAAC;AACF,eAAO,MAAM,qBAAqB,yFAIjC,CAAC;AACF,eAAO,MAAM,sBAAsB,yFAIlC,CAAC;AAGF,eAAO,MAAM,eAAe,yFAI3B,CAAC;AACF,eAAO,MAAM,kBAAkB,yFAI9B,CAAC;AACF,eAAO,MAAM,aAAa,yFAA8D,CAAC;AAIzF,eAAO,MAAM,kBAAkB,yFAAmE,CAAC;AACnG,eAAO,MAAM,gBAAgB,yFAAiE,CAAC;AAC/F,eAAO,MAAM,gBAAgB,yFAAiE,CAAC;AAC/F,eAAO,MAAM,kBAAkB,yFAI9B,CAAC;AACF,eAAO,MAAM,uBAAuB,yFAInC,CAAC"}
+{"version":3,"file":"physicalConstants.d.ts","sourceRoot":"","sources":["../../../src/type/unit/physicalConstants.ts"],"names":[],"mappings":"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"}

package/dist/typed/arithmetic.d.ts

@@ -28,161 +28,161 @@ type i32 = number;
  * await add(float64A, float64B);               // Parallel array add
  * ```
  */
-export declare const add: import("typed-function").TypedFunction;
+export declare const add: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Polymorphic subtraction function with parallel execution for arrays
  */
-export declare const subtract: import("typed-function").TypedFunction;
+export declare const subtract: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Polymorphic multiplication function with parallel execution for arrays
  */
-export declare const multiply: import("typed-function").TypedFunction;
+export declare const multiply: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Polymorphic division function with parallel execution for arrays
  */
-export declare const divide: import("typed-function").TypedFunction;
+export declare const divide: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Unary negation with parallel array support
  */
-export declare const unaryMinus: import("typed-function").TypedFunction;
+export declare const unaryMinus: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Unary plus (identity)
  */
-export declare const unaryPlus: import("typed-function").TypedFunction;
+export declare const unaryPlus: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Absolute value with parallel array support
  */
-export declare const abs: import("typed-function").TypedFunction;
+export declare const abs: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Sign function
  */
-export declare const sign: import("typed-function").TypedFunction;
+export declare const sign: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Power function
  */
-export declare const pow: import("typed-function").TypedFunction;
+export declare const pow: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Square root with parallel array support
  */
-export declare const sqrt: import("typed-function").TypedFunction;
+export declare const sqrt: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Square with parallel array support
  */
-export declare const square: import("typed-function").TypedFunction;
+export declare const square: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Cube
  */
-export declare const cube: import("typed-function").TypedFunction;
+export declare const cube: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Cube root
  */
-export declare const cbrt: import("typed-function").TypedFunction;
+export declare const cbrt: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * N-th root
  */
-export declare const nthRoot: import("typed-function").TypedFunction;
+export declare const nthRoot: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Exponential function (e^x) with parallel array support
  */
-export declare const exp: import("typed-function").TypedFunction;
+export declare const exp: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Natural logarithm (ln x) with parallel array support
  */
-export declare const log: import("typed-function").TypedFunction;
+export declare const log: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Base-10 logarithm
  */
-export declare const log10: import("typed-function").TypedFunction;
+export declare const log10: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Base-2 logarithm
  */
-export declare const log2: import("typed-function").TypedFunction;
+export declare const log2: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * log(1 + x) with higher precision for small x
  */
-export declare const log1p: import("typed-function").TypedFunction;
+export declare const log1p: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * exp(x) - 1 with higher precision for small x
  */
-export declare const expm1: import("typed-function").TypedFunction;
+export declare const expm1: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Round to nearest integer
  */
-export declare const round: import("typed-function").TypedFunction;
+export declare const round: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Floor (round down)
  */
-export declare const floor: import("typed-function").TypedFunction;
+export declare const floor: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Ceiling (round up)
  */
-export declare const ceil: import("typed-function").TypedFunction;
+export declare const ceil: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Truncate (round toward zero)
  */
-export declare const fix: import("typed-function").TypedFunction;
+export declare const fix: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Modulo operation
  */
-export declare const mod: import("typed-function").TypedFunction;
+export declare const mod: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Greatest common divisor
  */
-export declare const gcd: import("typed-function").TypedFunction;
+export declare const gcd: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Least common multiple
  */
-export declare const lcm: import("typed-function").TypedFunction;
+export declare const lcm: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Extended greatest common divisor
  * Returns [gcd, x, y] where gcd = a*x + b*y (Bezout coefficients)
  */
-export declare const xgcd: import("typed-function").TypedFunction;
-export declare const norm: import("typed-function").TypedFunction;
+export declare const xgcd: import("@danielsimonjr/mathts-core").TypedFunction;
+export declare const norm: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Hyperbolic sine
  */
-export declare const sinh: import("typed-function").TypedFunction;
+export declare const sinh: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Hyperbolic cosine
  */
-export declare const cosh: import("typed-function").TypedFunction;
+export declare const cosh: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Hyperbolic tangent
  */
-export declare const tanh: import("typed-function").TypedFunction;
+export declare const tanh: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Check if values are equal
  */
-export declare const equal: import("typed-function").TypedFunction;
+export declare const equal: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Check if a < b
  */
-export declare const smaller: import("typed-function").TypedFunction;
+export declare const smaller: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Check if a > b
  */
-export declare const larger: import("typed-function").TypedFunction;
+export declare const larger: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Check if a <= b
  */
-export declare const smallerEq: import("typed-function").TypedFunction;
+export declare const smallerEq: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Check if a >= b
  */
-export declare const largerEq: import("typed-function").TypedFunction;
+export declare const largerEq: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Compare two values: -1, 0, or 1
  */
-export declare const compare: import("typed-function").TypedFunction;
+export declare const compare: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Minimum of values with parallel array support
  */
-export declare const min: import("typed-function").TypedFunction;
+export declare const min: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Maximum of values with parallel array support
  */
-export declare const max: import("typed-function").TypedFunction;
+export declare const max: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Sum with parallel array support
  */
@@ -199,12 +199,12 @@ export declare const max: import("typed-function").TypedFunction;
  * ~2-4x slower than `sum`, so it is opt-in. Reach for it when the result is a small difference of
  * large terms: conservation checks, residuals, long-running accumulators.
  */
-export declare const fsum: import("typed-function").TypedFunction;
-export declare const sum: import("typed-function").TypedFunction;
+export declare const fsum: import("@danielsimonjr/mathts-core").TypedFunction;
+export declare const sum: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Mean with parallel array support
  */
-export declare const mean: import("typed-function").TypedFunction;
+export declare const mean: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Variance normalization, matching mathjs's `variance(array, normalization)`:
  *   - 'unbiased'    → sum2 / (n - 1)   (sample variance; mathjs DEFAULT)
@@ -219,16 +219,16 @@ export type VarNormalization = 'unbiased' | 'uncorrected' | 'biased';
  * `parallelStatVariance` variant. An optional normalization argument selects
  * 'unbiased' | 'uncorrected' (population) | 'biased'. See VarNormalization.
  */
-export declare const variance: import("typed-function").TypedFunction;
+export declare const variance: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Standard deviation with parallel array support — sqrt of {@link variance};
  * defaults to **unbiased** and accepts the same normalization argument.
  */
-export declare const std: import("typed-function").TypedFunction;
+export declare const std: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Dot product with parallel array support
  */
-export declare const dot: import("typed-function").TypedFunction;
+export declare const dot: import("@danielsimonjr/mathts-core").TypedFunction;
 /**
  * Parallel matrix multiplication
  * @param a First matrix as flat Float64Array (row-major)
@@ -267,51 +267,51 @@ export declare function shouldParallelize(elementCount: i32): boolean;
  */
 export declare function getComputePool(): ComputePool;
 export declare const typedArithmetic: {
-    add: import("typed-function").TypedFunction;
-    subtract: import("typed-function").TypedFunction;
-    multiply: import("typed-function").TypedFunction;
-    divide: import("typed-function").TypedFunction;
-    unaryMinus: import("typed-function").TypedFunction;
-    unaryPlus: import("typed-function").TypedFunction;
-    abs: import("typed-function").TypedFunction;
-    sign: import("typed-function").TypedFunction;
-    pow: import("typed-function").TypedFunction;
-    sqrt: import("typed-function").TypedFunction;
-    square: import("typed-function").TypedFunction;
-    cube: import("typed-function").TypedFunction;
-    cbrt: import("typed-function").TypedFunction;
-    nthRoot: import("typed-function").TypedFunction;
-    exp: import("typed-function").TypedFunction;
-    log: import("typed-function").TypedFunction;
-    log10: import("typed-function").TypedFunction;
-    log2: import("typed-function").TypedFunction;
-    log1p: import("typed-function").TypedFunction;
-    expm1: import("typed-function").TypedFunction;
-    round: import("typed-function").TypedFunction;
-    floor: import("typed-function").TypedFunction;
-    ceil: import("typed-function").TypedFunction;
-    fix: import("typed-function").TypedFunction;
-    mod: import("typed-function").TypedFunction;
-    gcd: import("typed-function").TypedFunction;
-    lcm: import("typed-function").TypedFunction;
-    xgcd: import("typed-function").TypedFunction;
-    norm: import("typed-function").TypedFunction;
-    sinh: import("typed-function").TypedFunction;
-    cosh: import("typed-function").TypedFunction;
-    tanh: import("typed-function").TypedFunction;
-    equal: import("typed-function").TypedFunction;
-    smaller: import("typed-function").TypedFunction;
-    larger: import("typed-function").TypedFunction;
-    smallerEq: import("typed-function").TypedFunction;
-    largerEq: import("typed-function").TypedFunction;
-    compare: import("typed-function").TypedFunction;
-    min: import("typed-function").TypedFunction;
-    max: import("typed-function").TypedFunction;
-    sum: import("typed-function").TypedFunction;
-    mean: import("typed-function").TypedFunction;
-    variance: import("typed-function").TypedFunction;
-    std: import("typed-function").TypedFunction;
-    dot: import("typed-function").TypedFunction;
+    add: import("@danielsimonjr/mathts-core").TypedFunction;
+    subtract: import("@danielsimonjr/mathts-core").TypedFunction;
+    multiply: import("@danielsimonjr/mathts-core").TypedFunction;
+    divide: import("@danielsimonjr/mathts-core").TypedFunction;
+    unaryMinus: import("@danielsimonjr/mathts-core").TypedFunction;
+    unaryPlus: import("@danielsimonjr/mathts-core").TypedFunction;
+    abs: import("@danielsimonjr/mathts-core").TypedFunction;
+    sign: import("@danielsimonjr/mathts-core").TypedFunction;
+    pow: import("@danielsimonjr/mathts-core").TypedFunction;
+    sqrt: import("@danielsimonjr/mathts-core").TypedFunction;
+    square: import("@danielsimonjr/mathts-core").TypedFunction;
+    cube: import("@danielsimonjr/mathts-core").TypedFunction;
+    cbrt: import("@danielsimonjr/mathts-core").TypedFunction;
+    nthRoot: import("@danielsimonjr/mathts-core").TypedFunction;
+    exp: import("@danielsimonjr/mathts-core").TypedFunction;
+    log: import("@danielsimonjr/mathts-core").TypedFunction;
+    log10: import("@danielsimonjr/mathts-core").TypedFunction;
+    log2: import("@danielsimonjr/mathts-core").TypedFunction;
+    log1p: import("@danielsimonjr/mathts-core").TypedFunction;
+    expm1: import("@danielsimonjr/mathts-core").TypedFunction;
+    round: import("@danielsimonjr/mathts-core").TypedFunction;
+    floor: import("@danielsimonjr/mathts-core").TypedFunction;
+    ceil: import("@danielsimonjr/mathts-core").TypedFunction;
+    fix: import("@danielsimonjr/mathts-core").TypedFunction;
+    mod: import("@danielsimonjr/mathts-core").TypedFunction;
+    gcd: import("@danielsimonjr/mathts-core").TypedFunction;
+    lcm: import("@danielsimonjr/mathts-core").TypedFunction;
+    xgcd: import("@danielsimonjr/mathts-core").TypedFunction;
+    norm: import("@danielsimonjr/mathts-core").TypedFunction;
+    sinh: import("@danielsimonjr/mathts-core").TypedFunction;
+    cosh: import("@danielsimonjr/mathts-core").TypedFunction;
+    tanh: import("@danielsimonjr/mathts-core").TypedFunction;
+    equal: import("@danielsimonjr/mathts-core").TypedFunction;
+    smaller: import("@danielsimonjr/mathts-core").TypedFunction;
+    larger: import("@danielsimonjr/mathts-core").TypedFunction;
+    smallerEq: import("@danielsimonjr/mathts-core").TypedFunction;
+    largerEq: import("@danielsimonjr/mathts-core").TypedFunction;
+    compare: import("@danielsimonjr/mathts-core").TypedFunction;
+    min: import("@danielsimonjr/mathts-core").TypedFunction;
+    max: import("@danielsimonjr/mathts-core").TypedFunction;
+    sum: import("@danielsimonjr/mathts-core").TypedFunction;
+    mean: import("@danielsimonjr/mathts-core").TypedFunction;
+    variance: import("@danielsimonjr/mathts-core").TypedFunction;
+    std: import("@danielsimonjr/mathts-core").TypedFunction;
+    dot: import("@danielsimonjr/mathts-core").TypedFunction;
     matmul: typeof matmul;
     transpose: typeof transpose;
     matvec: typeof matvec;

package/dist/typed/arithmetic.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"arithmetic.d.ts","sourceRoot":"","sources":["../../src/typed/arithmetic.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"arithmetic.d.ts","sourceRoot":"","sources":["../../src/typed/arithmetic.ts"],"names":[],"mappings":"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"}

package/dist/typed/bitwise.d.ts

@@ -29,20 +29,20 @@
  * await bitAnd(int32A, int32B);             // Parallel Int32Array AND
  * ```
  */
-export declare const bitAnd: import("typed-function").TypedFunction;
-export declare const bitOr: import("typed-function").TypedFunction;
-export declare const bitXor: import("typed-function").TypedFunction;
-export declare const bitNot: import("typed-function").TypedFunction;
-export declare const leftShift: import("typed-function").TypedFunction;
-export declare const rightArithShift: import("typed-function").TypedFunction;
-export declare const rightLogShift: import("typed-function").TypedFunction;
+export declare const bitAnd: import("@danielsimonjr/mathts-core").TypedFunction;
+export declare const bitOr: import("@danielsimonjr/mathts-core").TypedFunction;
+export declare const bitXor: import("@danielsimonjr/mathts-core").TypedFunction;
+export declare const bitNot: import("@danielsimonjr/mathts-core").TypedFunction;
+export declare const leftShift: import("@danielsimonjr/mathts-core").TypedFunction;
+export declare const rightArithShift: import("@danielsimonjr/mathts-core").TypedFunction;
+export declare const rightLogShift: import("@danielsimonjr/mathts-core").TypedFunction;
 export declare const typedBitwise: {
-    bitAnd: import("typed-function").TypedFunction;
-    bitOr: import("typed-function").TypedFunction;
-    bitXor: import("typed-function").TypedFunction;
-    bitNot: import("typed-function").TypedFunction;
-    leftShift: import("typed-function").TypedFunction;
-    rightArithShift: import("typed-function").TypedFunction;
-    rightLogShift: import("typed-function").TypedFunction;
+    bitAnd: import("@danielsimonjr/mathts-core").TypedFunction;
+    bitOr: import("@danielsimonjr/mathts-core").TypedFunction;
+    bitXor: import("@danielsimonjr/mathts-core").TypedFunction;
+    bitNot: import("@danielsimonjr/mathts-core").TypedFunction;
+    leftShift: import("@danielsimonjr/mathts-core").TypedFunction;
+    rightArithShift: import("@danielsimonjr/mathts-core").TypedFunction;
+    rightLogShift: import("@danielsimonjr/mathts-core").TypedFunction;
 };
 //# sourceMappingURL=bitwise.d.ts.map

package/dist/typed/bitwise.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bitwise.d.ts","sourceRoot":"","sources":["../../src/typed/bitwise.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AA2FH;;;;;;;;;GASG;AACH,eAAO,MAAM,MAAM,wCAmCjB,CAAC;AAMH,eAAO,MAAM,KAAK,wCAgChB,CAAC;AAMH,eAAO,MAAM,MAAM,wCAgCjB,CAAC;AAMH,eAAO,MAAM,MAAM,wCAuBjB,CAAC;AAMH,eAAO,MAAM,SAAS,wCAwCpB,CAAC;AAMH,eAAO,MAAM,eAAe,wCAwC1B,CAAC;AAMH,eAAO,MAAM,aAAa,wCAwCxB,CAAC;AAMH,eAAO,MAAM,YAAY;;;;;;;;CAQxB,CAAC"}
+{"version":3,"file":"bitwise.d.ts","sourceRoot":"","sources":["../../src/typed/bitwise.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AA2FH;;;;;;;;;GASG;AACH,eAAO,MAAM,MAAM,oDAmCjB,CAAC;AAMH,eAAO,MAAM,KAAK,oDAgChB,CAAC;AAMH,eAAO,MAAM,MAAM,oDAgCjB,CAAC;AAMH,eAAO,MAAM,MAAM,oDAuBjB,CAAC;AAMH,eAAO,MAAM,SAAS,oDAwCpB,CAAC;AAMH,eAAO,MAAM,eAAe,oDAwC1B,CAAC;AAMH,eAAO,MAAM,aAAa,oDAwCxB,CAAC;AAMH,eAAO,MAAM,YAAY;;;;;;;;CAQxB,CAAC"}