@danielsimonjr/mathts-matrix 0.1.6 → 0.1.7

package/dist/index.js

@@ -128,61 +128,69 @@ var init_Matrix = __esm({
 });
 
 // src/types/dense/arithmetic.ts
-function add(a, b) {
-  const result = new Float64Array(a.rows * a.cols);
-  for (let i = 0; i < a.rows; i++) {
-    for (let j = 0; j < a.cols; j++) {
-      result[i * a.cols + j] = a.get(i, j) + b.get(i, j);
-    }
+function flat(m) {
+  const maybe = m;
+  if (typeof maybe.toFloat64Array === "function") return maybe.toFloat64Array();
+  const out = new Float64Array(m.rows * m.cols);
+  for (let i = 0; i < m.rows; i++) {
+    for (let j = 0; j < m.cols; j++) out[i * m.cols + j] = m.get(i, j);
   }
+  return out;
+}
+function add(a, b) {
+  const ad = flat(a);
+  const bd = flat(b);
+  const result = new Float64Array(ad.length);
+  for (let i = 0; i < ad.length; i++) result[i] = ad[i] + bd[i];
   return result;
 }
 function subtract(a, b) {
-  const result = new Float64Array(a.rows * a.cols);
-  for (let i = 0; i < a.rows; i++) {
-    for (let j = 0; j < a.cols; j++) {
-      result[i * a.cols + j] = a.get(i, j) - b.get(i, j);
-    }
-  }
+  const ad = flat(a);
+  const bd = flat(b);
+  const result = new Float64Array(ad.length);
+  for (let i = 0; i < ad.length; i++) result[i] = ad[i] - bd[i];
   return result;
 }
 function multiplyElementwise(a, b) {
-  const result = new Float64Array(a.rows * a.cols);
-  for (let i = 0; i < a.rows; i++) {
-    for (let j = 0; j < a.cols; j++) {
-      result[i * a.cols + j] = a.get(i, j) * b.get(i, j);
-    }
-  }
+  const ad = flat(a);
+  const bd = flat(b);
+  const result = new Float64Array(ad.length);
+  for (let i = 0; i < ad.length; i++) result[i] = ad[i] * bd[i];
   return result;
 }
 function multiply(a, b) {
-  const result = new Float64Array(a.rows * b.cols);
-  for (let i = 0; i < a.rows; i++) {
-    for (let j = 0; j < b.cols; j++) {
-      let sum3 = 0;
-      for (let k = 0; k < a.cols; k++) {
-        sum3 += a.get(i, k) * b.get(k, j);
-      }
-      result[i * b.cols + j] = sum3;
+  const n = a.rows;
+  const p = a.cols;
+  const m = b.cols;
+  const ad = flat(a);
+  const bd = flat(b);
+  const result = new Float64Array(n * m);
+  for (let i = 0; i < n; i++) {
+    const ai = i * p;
+    const ri = i * m;
+    for (let k = 0; k < p; k++) {
+      const aik = ad[ai + k];
+      if (aik === 0) continue;
+      const bk = k * m;
+      for (let j = 0; j < m; j++) result[ri + j] += aik * bd[bk + j];
     }
   }
   return result;
 }
 function scale(a, scalar) {
-  const result = new Float64Array(a.rows * a.cols);
-  for (let i = 0; i < a.rows; i++) {
-    for (let j = 0; j < a.cols; j++) {
-      result[i * a.cols + j] = a.get(i, j) * scalar;
-    }
-  }
+  const ad = flat(a);
+  const result = new Float64Array(ad.length);
+  for (let i = 0; i < ad.length; i++) result[i] = ad[i] * scalar;
   return result;
 }
 function transpose(a) {
-  const result = new Float64Array(a.cols * a.rows);
-  for (let i = 0; i < a.rows; i++) {
-    for (let j = 0; j < a.cols; j++) {
-      result[j * a.rows + i] = a.get(i, j);
-    }
+  const ad = flat(a);
+  const rows = a.rows;
+  const cols = a.cols;
+  const result = new Float64Array(rows * cols);
+  for (let i = 0; i < rows; i++) {
+    const ai = i * cols;
+    for (let j = 0; j < cols; j++) result[j * rows + i] = ad[ai + j];
   }
   return result;
 }
@@ -1049,11 +1057,11 @@ var init_DenseMatrix = __esm({
                 }
               }
             } else {
-              const flat = data;
-              if (flat.length !== rows * cols) {
-                throw new Error(`Data length ${flat.length} does not match dimensions ${rows}\xD7${cols}`);
+              const flat2 = data;
+              if (flat2.length !== rows * cols) {
+                throw new Error(`Data length ${flat2.length} does not match dimensions ${rows}\xD7${cols}`);
               }
-              this.data = new Float64Array(flat);
+              this.data = new Float64Array(flat2);
             }
           }
         }
@@ -2485,13 +2493,15 @@ var WASMBackend = class {
    * platform-correct conversion.
    */
   async resolveAsWasmPath() {
-    const url = new URL(`../../../lib/wasm/mathts-as.wasm`, import.meta.url);
     const isNode = typeof process !== "undefined" && process.versions?.node !== void 0;
     if (isNode) {
+      const { resolvePackagedWasm } = await import("./resolve-JRHDDNVQ.js");
+      const found = await resolvePackagedWasm(import.meta.url, "mathts-as.wasm");
+      if (found) return found;
       const { fileURLToPath } = await import("url");
-      return fileURLToPath(url);
+      return fileURLToPath(new URL(`../../../lib/wasm/mathts-as.wasm`, import.meta.url));
     }
-    return url.href;
+    return new URL(`../../../lib/wasm/mathts-as.wasm`, import.meta.url).href;
   }
   /**
    * Compile + instantiate the AssemblyScript WASM artifact. Each
@@ -6270,12 +6280,14 @@ var WasmLoader = class _WasmLoader {
   async getDefaultWasmPath() {
     const useAS = typeof process !== "undefined" && process.env?.MATHTS_WASM_BACKEND === "assemblyscript";
     const wasmFile = useAS ? "mathts-as.wasm" : "mathts.wasm";
-    const resolvedUrl = new URL(`../../../lib/wasm/${wasmFile}`, import.meta.url);
     if (this.isNode) {
+      const { resolvePackagedWasm } = await import("./resolve-JRHDDNVQ.js");
+      const found = await resolvePackagedWasm(import.meta.url, wasmFile);
+      if (found) return found;
       const { fileURLToPath } = await import("url");
-      return fileURLToPath(resolvedUrl);
+      return fileURLToPath(new URL(`../../../lib/wasm/${wasmFile}`, import.meta.url));
     }
-    return resolvedUrl.href;
+    return new URL(`../../../lib/wasm/${wasmFile}`, import.meta.url).href;
   }
   async loadNodeWasm(path, totalStart) {
     const fs = await import("fs");
@@ -7058,13 +7070,13 @@ function isSymmetric(matrix2, tolerance = 1e-10) {
 }
 function flattenMatrix(matrix2) {
   const n = matrix2.length;
-  const flat = new Float64Array(n * n);
+  const flat2 = new Float64Array(n * n);
   for (let i = 0; i < n; i++) {
     for (let j = 0; j < n; j++) {
-      flat[i * n + j] = matrix2[i][j];
+      flat2[i * n + j] = matrix2[i][j];
     }
   }
-  return flat;
+  return flat2;
 }
 async function eigWasm(matrix2, options) {
   const n = matrix2.length;
@@ -7213,11 +7225,11 @@ async function svdWasm(matrix2, options) {
   }
   try {
     loader.resetAllocator();
-    const flat = new Float64Array(m * n);
+    const flat2 = new Float64Array(m * n);
     for (let i = 0; i < m; i++) {
-      for (let j = 0; j < n; j++) flat[i * n + j] = matrix2[i][j];
+      for (let j = 0; j < n; j++) flat2[i * n + j] = matrix2[i][j];
     }
-    const aPtr = loader.writeF64(flat);
+    const aPtr = loader.writeF64(flat2);
     const uPtr = loader.allocF64(m * k);
     const sPtr = loader.allocF64(k);
     const vPtr = loader.allocF64(n * k);
@@ -7382,8 +7394,8 @@ function lu(A) {
   if (A.cols !== n) {
     throw new Error(`lu: matrix must be square (got ${A.rows}\xD7${A.cols})`);
   }
-  const flat = A.toFloat64Array();
-  const W = new Float64Array(flat);
+  const flat2 = A.toFloat64Array();
+  const W = new Float64Array(flat2);
   const perm = new Array(n);
   for (let i = 0; i < n; i++) perm[i] = i;
   for (let k = 0; k < n; k++) {

package/dist/resolve-JRHDDNVQ.js

@@ -0,0 +1,24 @@
+import "./chunk-4VMDO6W2.js";
+
+// src/backends/wasm/resolve.ts
+async function resolvePackagedWasm(metaUrl, wasmFile) {
+  const isNode = typeof process !== "undefined" && process.versions?.node !== void 0;
+  if (!isNode) return null;
+  const { fileURLToPath } = await import("url");
+  const { dirname, join } = await import("path");
+  const { existsSync } = await import("fs");
+  let dir = dirname(fileURLToPath(metaUrl));
+  for (let depth = 0; depth < 8; depth++) {
+    const candidates = [join(dir, "wasm", wasmFile), join(dir, "dist", "wasm", wasmFile)];
+    for (const candidate of candidates) {
+      if (existsSync(candidate)) return candidate;
+    }
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+export {
+  resolvePackagedWasm
+};

package/dist/wasm/wasm-manifest.json

@@ -0,0 +1,3 @@
+{
+  "mathts-as.wasm": "sha384-q/fiU1qnpj7vLiYnprGBDdO7on0S/Gnd5Pyql20PZxGfl9Jx0jdWPUGQe0FM91wo"
+}

package/package.json

@@ -1,60 +1,61 @@
-{
-  "name": "@danielsimonjr/mathts-matrix",
-  "version": "0.1.6",
-  "description": "Matrix operations for MathTS with WASM/WebGPU backend support",
-  "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-parallel": "^0.2.2"
-  },
-  "devDependencies": {
-    "@types/node": "^25.5.2",
-    "@webgpu/types": "^0.1.67",
-    "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": "matrix"
-  },
-  "keywords": [
-    "math",
-    "matrix",
-    "linear-algebra",
-    "typescript",
-    "wasm",
-    "webgpu"
-  ]
-}
+{
+  "name": "@danielsimonjr/mathts-matrix",
+  "version": "0.1.7",
+  "description": "Matrix operations for MathTS with WASM/WebGPU backend support",
+  "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 && node scripts/copy-wasm.mjs",
+    "copy:wasm": "node scripts/copy-wasm.mjs",
+    "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 && node scripts/copy-wasm.mjs"
+  },
+  "dependencies": {
+    "@danielsimonjr/mathts-core": "^0.1.4",
+    "@danielsimonjr/mathts-parallel": "^0.2.2"
+  },
+  "devDependencies": {
+    "@types/node": "^25.5.2",
+    "@webgpu/types": "^0.1.67",
+    "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": "matrix"
+  },
+  "keywords": [
+    "math",
+    "matrix",
+    "linear-algebra",
+    "typescript",
+    "wasm",
+    "webgpu"
+  ]
+}