@danielsimonjr/mathts-tensor 0.1.2 → 0.2.0

package/dist/index.d.ts

@@ -289,17 +289,16 @@ interface TensorSvdResult {
     truncationError: number;
 }
 /**
- * Compute the (optionally truncated) SVD of tensor `t` by partitioning its
- * axes into "row" and "col" groups.
- *
- * @param t        - Input tensor of any rank ≥ 1.
- * @param rowAxes  - Axis indices (integers) whose dimensions form the row
- *                   dimension of the effective 2-D matrix. The remaining axes
- *                   form the column dimension. The order of `rowAxes` controls
- *                   the layout of the U output tensor.
- * @param opts     - Optional truncation / naming settings.
+ * Truncated tensor SVD using the pure-JS DenseMatrix SVD primitive (synchronous).
  */
 declare function tensorSvd(t: Tensor, rowAxes: ReadonlyArray<number>, opts?: TensorSvdOpts): TensorSvdResult;
+/**
+ * Truncated tensor SVD routed through the AssemblyScript WASM SVD kernel
+ * (`svdWasm`) — the same result as {@link tensorSvd} but accelerated for large
+ * matricisations. Async because WASM instantiation is async; falls back to JS
+ * inside `svdWasm` when no binary is available.
+ */
+declare function tensorSvdWasm(t: Tensor, rowAxes: ReadonlyArray<number>, opts?: TensorSvdOpts): Promise<TensorSvdResult>;
 
 /**
  * randomTensor — construct a Tensor filled with pseudo-random values.
@@ -637,15 +636,16 @@ interface TensorEigResult {
     eigenvaluesImaginary?: Tensor;
 }
 /**
- * Compute the eigendecomposition of tensor `t` by partitioning its axes
- * into "row" and "col" groups. The reshaped 2-D matrix must be square.
- *
- * @param t        - Input tensor of any rank ≥ 1.
- * @param rowAxes  - Axis indices forming the row dimension of the effective
- *                   2-D matrix. The remaining axes form the column dimension.
- * @param opts     - Optional symmetric hint + computeVectors flag.
+ * Tensor eigendecomposition using the pure-JS matrix eig primitive (synchronous).
  */
 declare function tensorEig(t: Tensor, rowAxes: ReadonlyArray<number>, opts?: TensorEigOpts): TensorEigResult;
+/**
+ * Tensor eigendecomposition routed through the AssemblyScript WASM eig kernel
+ * (`eigWasm`) — same result as {@link tensorEig}, accelerated for large
+ * matricisations. Async (WASM instantiation); `eigWasm` falls back to JS when no
+ * binary is available.
+ */
+declare function tensorEigWasm(t: Tensor, rowAxes: ReadonlyArray<number>, opts?: TensorEigOpts): Promise<TensorEigResult>;
 
 /**
  * tensorPinv — Moore-Penrose pseudoinverse for rank-N tensors.
@@ -1119,4 +1119,4 @@ declare function roll(t: Tensor, shifts: number | readonly number[], axes?: read
  */
 declare function flip(t: Tensor, axes: readonly number[]): Tensor;
 
-export { type ContractNetworkOpts, type ContractNetworkResult, type EinsumSpec, Index, type IndexOpts, type NestedArray, type PadOptions, type RandomTensorOpts, type ScatterOpts, type SliceRange, type StackOpts, Tensor, type TensorCholeskyOpts, type TensorCholeskyResult, type TensorEigOpts, type TensorEigResult, type TensorKronOpts, type TensorLUOpts, type TensorLUResult, type TensorPinvOpts, type TensorQrOpts, type TensorQrResult, type TensorSolveOpts, type TensorSolveResult, type TensorSvdOpts, type TensorSvdResult, concatenate, contractNetwork, flip, gather, idx, pad, randomTensor, roll, scatter, slice, stack, tensorCholesky, tensorEig, tensorKron, tensorLU, tensorPinv, tensorQr, tensorSolve, tensorSvd };
+export { type ContractNetworkOpts, type ContractNetworkResult, type EinsumSpec, Index, type IndexOpts, type NestedArray, type PadOptions, type RandomTensorOpts, type ScatterOpts, type SliceRange, type StackOpts, Tensor, type TensorCholeskyOpts, type TensorCholeskyResult, type TensorEigOpts, type TensorEigResult, type TensorKronOpts, type TensorLUOpts, type TensorLUResult, type TensorPinvOpts, type TensorQrOpts, type TensorQrResult, type TensorSolveOpts, type TensorSolveResult, type TensorSvdOpts, type TensorSvdResult, concatenate, contractNetwork, flip, gather, idx, pad, randomTensor, roll, scatter, slice, stack, tensorCholesky, tensorEig, tensorEigWasm, tensorKron, tensorLU, tensorPinv, tensorQr, tensorSolve, tensorSvd, tensorSvdWasm };

package/dist/index.js

@@ -813,8 +813,8 @@ function idx(dim, name, opts) {
 }
 
 // src/operations/svd.ts
-import { svd } from "@danielsimonjr/mathts-matrix";
-function tensorSvd(t, rowAxes, opts) {
+import { svd, svdWasm } from "@danielsimonjr/mathts-matrix";
+function prepareSvdMatrix(t, rowAxes) {
   const rank = t.shape.length;
   for (const ax of rowAxes) {
     if (!Number.isInteger(ax) || ax < 0 || ax >= rank) {
@@ -844,7 +844,10 @@ function tensorSvd(t, rowAxes, opts) {
     { length: numRows },
     (_, i) => Array.from({ length: numCols }, (_2, j) => permuted.data[i * numCols + j])
   );
-  const result = svd(matrix, { tolerance: 1e-12 });
+  return { matrix, rowDims, colDims, numRows, numCols };
+}
+function finishSvd(result, prep, opts) {
+  const { rowDims, colDims, numRows, numCols } = prep;
   const { U: fullU, S: allS, V: fullV } = result;
   const cutoff = opts?.cutoff ?? 0;
   const maxdim = opts?.maxdim;
@@ -885,6 +888,14 @@ function tensorSvd(t, rowAxes, opts) {
     truncationError
   };
 }
+function tensorSvd(t, rowAxes, opts) {
+  const prep = prepareSvdMatrix(t, rowAxes);
+  return finishSvd(svd(prep.matrix, { tolerance: 1e-12 }), prep, opts);
+}
+async function tensorSvdWasm(t, rowAxes, opts) {
+  const prep = prepareSvdMatrix(t, rowAxes);
+  return finishSvd(await svdWasm(prep.matrix, { tolerance: 1e-12 }), prep, opts);
+}
 
 // src/operations/random.ts
 import { DenseMatrix as DenseMatrix2, qr as matrixQr } from "@danielsimonjr/mathts-matrix";
@@ -1644,11 +1655,9 @@ function tensorCholesky(t, rowAxes, opts) {
 }
 
 // src/operations/eig.ts
-import { eig as matrixEig } from "@danielsimonjr/mathts-matrix";
-function tensorEig(t, rowAxes, opts) {
+import { eig as matrixEig, eigWasm } from "@danielsimonjr/mathts-matrix";
+function prepareEigMatrix(t, rowAxes, symmetricHint) {
   const rank = t.shape.length;
-  const computeVectors = opts?.computeVectors ?? true;
-  const symmetricHint = opts?.symmetric ?? false;
   for (const ax of rowAxes) {
     if (!Number.isInteger(ax) || ax < 0 || ax >= rank) {
       throw new RangeError(
@@ -1693,7 +1702,10 @@ function tensorEig(t, rowAxes, opts) {
       }
     }
   }
-  const { values, vectors } = matrixEig(matrix2D, { computeVectors });
+  return { matrix2D, n };
+}
+function finishEig(eigResult, n, computeVectors, symmetricHint) {
+  const { values, vectors } = eigResult;
   const reData = new Float64Array(n);
   const imData = new Float64Array(n);
   let anyImaginary = false;
@@ -1719,6 +1731,18 @@ function tensorEig(t, rowAxes, opts) {
   }
   return result;
 }
+function tensorEig(t, rowAxes, opts) {
+  const computeVectors = opts?.computeVectors ?? true;
+  const symmetricHint = opts?.symmetric ?? false;
+  const { matrix2D, n } = prepareEigMatrix(t, rowAxes, symmetricHint);
+  return finishEig(matrixEig(matrix2D, { computeVectors }), n, computeVectors, symmetricHint);
+}
+async function tensorEigWasm(t, rowAxes, opts) {
+  const computeVectors = opts?.computeVectors ?? true;
+  const symmetricHint = opts?.symmetric ?? false;
+  const { matrix2D, n } = prepareEigMatrix(t, rowAxes, symmetricHint);
+  return finishEig(await eigWasm(matrix2D, { computeVectors }), n, computeVectors, symmetricHint);
+}
 
 // src/operations/pinv.ts
 import { svd as svd2 } from "@danielsimonjr/mathts-matrix";
@@ -1992,11 +2016,11 @@ function tensorKron(a, b, opts) {
   }
   const outShape = aShape.map((d, k) => d * bShape[k]);
   const outSize = outShape.reduce((acc, d) => acc * d, 1);
-  const outStrides = rowMajorStrides(outShape);
+  const outStrides = Tensor.rowMajorStrides(outShape);
   const aData = a.data;
   const bData = b.data;
-  const aOrigStrides = rowMajorStrides(aShape.slice(outRank - rankA));
-  const bOrigStrides = rowMajorStrides(bShape.slice(outRank - rankB));
+  const aOrigStrides = Tensor.rowMajorStrides(aShape.slice(outRank - rankA));
+  const bOrigStrides = Tensor.rowMajorStrides(bShape.slice(outRank - rankB));
   const result = new Float64Array(outSize);
   const outIdx = new Array(outRank).fill(0);
   for (let flatOut = 0; flatOut < outSize; flatOut++) {
@@ -2035,16 +2059,6 @@ function tensorKron(a, b, opts) {
   }
   return new Tensor(outShape, result, outLabels);
 }
-function rowMajorStrides(shape) {
-  const rank = shape.length;
-  const strides = new Array(rank);
-  let acc = 1;
-  for (let k = rank - 1; k >= 0; k--) {
-    strides[k] = acc;
-    acc *= shape[k];
-  }
-  return strides;
-}
 
 // src/operations/slice.ts
 function slice(t, ranges) {
@@ -2542,10 +2556,12 @@ export {
   stack,
   tensorCholesky,
   tensorEig,
+  tensorEigWasm,
   tensorKron,
   tensorLU,
   tensorPinv,
   tensorQr,
   tensorSolve,
-  tensorSvd
+  tensorSvd,
+  tensorSvdWasm
 };

package/package.json

@@ -1,57 +1,57 @@
-{
-  "name": "@danielsimonjr/mathts-tensor",
-  "version": "0.1.2",
-  "description": "Rank-N dense Tensor type for MathTS with Float64Array-backed storage",
-  "author": "Daniel Simon Jr.",
-  "license": "MIT",
-  "type": "module",
-  "main": "./dist/index.js",
-  "module": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "exports": {
-    ".": {
-      "import": "./dist/index.js",
-      "types": "./dist/index.d.ts"
-    }
-  },
-  "files": [
-    "dist",
-    "README.md"
-  ],
-  "scripts": {
-    "build": "tsup src/index.ts --format esm --dts --clean",
-    "dev": "tsup src/index.ts --format esm --dts --watch",
-    "test": "vitest run",
-    "test:watch": "vitest",
-    "test:coverage": "vitest run --coverage",
-    "typecheck": "tsc --noEmit",
-    "lint": "eslint src --ext .ts",
-    "lint:fix": "eslint src --ext .ts --fix",
-    "clean": "rm -rf dist",
-    "build:prod": "tsup src/index.ts --format esm --dts --clean --minify --treeshake"
-  },
-  "dependencies": {
-    "@danielsimonjr/mathts-core": "0.1.4",
-    "@danielsimonjr/mathts-matrix": "0.1.5"
-  },
-  "devDependencies": {
-    "@types/node": "^25.5.2",
-    "tsup": "^8.0.0",
-    "typescript": "^5.3.0",
-    "vitest": "^4.1.5"
-  },
-  "publishConfig": {
-    "access": "public"
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/danielsimonjr/mathts",
-    "directory": "tensor"
-  },
-  "keywords": [
-    "math",
-    "tensor",
-    "linear-algebra",
-    "typescript"
-  ]
-}
+{
+  "name": "@danielsimonjr/mathts-tensor",
+  "version": "0.2.0",
+  "description": "Rank-N dense Tensor type for MathTS with Float64Array-backed storage",
+  "author": "Daniel Simon Jr.",
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean",
+    "dev": "tsup src/index.ts --format esm --dts --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src --ext .ts",
+    "lint:fix": "eslint src --ext .ts --fix",
+    "clean": "rm -rf dist",
+    "build:prod": "tsup src/index.ts --format esm --dts --clean --minify --treeshake"
+  },
+  "dependencies": {
+    "@danielsimonjr/mathts-core": "^0.1.4",
+    "@danielsimonjr/mathts-matrix": "^0.1.10"
+  },
+  "devDependencies": {
+    "@types/node": "^25.5.2",
+    "tsup": "^8.0.0",
+    "typescript": "^5.3.0",
+    "vitest": "^4.1.5"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/danielsimonjr/mathts",
+    "directory": "tensor"
+  },
+  "keywords": [
+    "math",
+    "tensor",
+    "linear-algebra",
+    "typescript"
+  ]
+}