regressio 0.0.1 → 1.0.1

package/README.md

@@ -297,27 +297,34 @@ console.log(C.trace());        // 5
 console.log(C.transpose().toArray());
 ```
 
-## WASM Engine (Optional)
+## WASM Acceleration
 
-For faster matrix operations on large datasets, build and load the Rust/WASM engine. When active, `Matrix.multiply()`, QR decomposition, Cholesky decomposition, and back-substitution are dispatched to compiled Rust code.
+regressio ships with a pre-compiled Rust/WASM engine that activates automatically — no configuration needed. When the WASM binary is available, heavy computations are dispatched to compiled Rust code for significantly faster execution.
 
-```bash
-cd rust && wasm-pack build --target bundler --out-dir ../pkg
-```
+**Accelerated operations:**
+- Matrix: multiply, transpose, add, subtract, scale, dot product, norm, determinant
+- Decompositions: QR, Cholesky, SVD, eigenvalues
+- Solvers: forward/back substitution
+- Models: Lasso/Elastic Net coordinate descent, softmax, KNN distance matrices
+
+If WASM is unavailable (e.g. unsupported runtime), all operations fall back silently to pure TypeScript.
 
 ```typescript
-import { useWasmEngine, useTypescriptEngine, isWasmActive, getEngine } from 'regressio';
+import { isWasmActive } from 'regressio';
 
-// Load WASM engine (async, loads the .wasm file)
-await useWasmEngine();
-console.log(isWasmActive()); // true
+console.log(isWasmActive()); // true if WASM loaded
 
-// All subsequent matrix operations use WASM
+// Everything just works — WASM is used transparently
 const model = new LinearRegression();
 model.fit(X, y); // QR decomposition runs in Rust
+```
 
-// Switch back to pure TypeScript
-useTypescriptEngine();
+### Rebuilding WASM
+
+The pre-built WASM binary is included in the package. To rebuild from Rust source (requires [Rust](https://rustup.rs/) with `wasm32-unknown-unknown` target):
+
+```bash
+bun run build:wasm
 ```
 
 ## License

package/dist/index.cjs

@@ -38,6 +38,220 @@ var __export = (target, all) => {
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 
+// pkg/regressio_wasm_bg.wasm
+var exports_regressio_wasm_bg = {};
+__export(exports_regressio_wasm_bg, {
+  default: () => regressio_wasm_bg_default
+});
+var regressio_wasm_bg_default = "./regressio_wasm_bg-vab4kvnm.wasm";
+var init_regressio_wasm_bg = () => {};
+
+// pkg/regressio_wasm_bg.js
+function cholesky(data, n) {
+  const ptr0 = passArrayF64ToWasm0(data, wasm.__wbindgen_malloc);
+  const len0 = WASM_VECTOR_LEN;
+  const ret = wasm.cholesky(ptr0, len0, n);
+  var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+  wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+  return v2;
+}
+function coordinate_descent(x, y, alpha, l1_ratio, max_iter, tolerance, n, p, fit_intercept) {
+  const ptr0 = passArrayF64ToWasm0(x, wasm.__wbindgen_malloc);
+  const len0 = WASM_VECTOR_LEN;
+  const ptr1 = passArrayF64ToWasm0(y, wasm.__wbindgen_malloc);
+  const len1 = WASM_VECTOR_LEN;
+  const ret = wasm.coordinate_descent(ptr0, len0, ptr1, len1, alpha, l1_ratio, max_iter, tolerance, n, p, fit_intercept);
+  var v3 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+  wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+  return v3;
+}
+function determinant(data, n) {
+  const ptr0 = passArrayF64ToWasm0(data, wasm.__wbindgen_malloc);
+  const len0 = WASM_VECTOR_LEN;
+  const ret = wasm.determinant(ptr0, len0, n);
+  return ret;
+}
+function eigenvalues(data, n) {
+  const ptr0 = passArrayF64ToWasm0(data, wasm.__wbindgen_malloc);
+  const len0 = WASM_VECTOR_LEN;
+  const ret = wasm.eigenvalues(ptr0, len0, n);
+  var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+  wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+  return v2;
+}
+function euclidean_distances(train, test, n_train, n_test, dim) {
+  const ptr0 = passArrayF64ToWasm0(train, wasm.__wbindgen_malloc);
+  const len0 = WASM_VECTOR_LEN;
+  const ptr1 = passArrayF64ToWasm0(test, wasm.__wbindgen_malloc);
+  const len1 = WASM_VECTOR_LEN;
+  const ret = wasm.euclidean_distances(ptr0, len0, ptr1, len1, n_train, n_test, dim);
+  var v3 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+  wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+  return v3;
+}
+function forward_substitution(l, b, n) {
+  const ptr0 = passArrayF64ToWasm0(l, wasm.__wbindgen_malloc);
+  const len0 = WASM_VECTOR_LEN;
+  const ptr1 = passArrayF64ToWasm0(b, wasm.__wbindgen_malloc);
+  const len1 = WASM_VECTOR_LEN;
+  const ret = wasm.forward_substitution(ptr0, len0, ptr1, len1, n);
+  var v3 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+  wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+  return v3;
+}
+function frobenius_norm(a) {
+  const ptr0 = passArrayF64ToWasm0(a, wasm.__wbindgen_malloc);
+  const len0 = WASM_VECTOR_LEN;
+  const ret = wasm.frobenius_norm(ptr0, len0);
+  return ret;
+}
+function manhattan_distances(train, test, n_train, n_test, dim) {
+  const ptr0 = passArrayF64ToWasm0(train, wasm.__wbindgen_malloc);
+  const len0 = WASM_VECTOR_LEN;
+  const ptr1 = passArrayF64ToWasm0(test, wasm.__wbindgen_malloc);
+  const len1 = WASM_VECTOR_LEN;
+  const ret = wasm.manhattan_distances(ptr0, len0, ptr1, len1, n_train, n_test, dim);
+  var v3 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+  wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+  return v3;
+}
+function matrix_add(a, b) {
+  const ptr0 = passArrayF64ToWasm0(a, wasm.__wbindgen_malloc);
+  const len0 = WASM_VECTOR_LEN;
+  const ptr1 = passArrayF64ToWasm0(b, wasm.__wbindgen_malloc);
+  const len1 = WASM_VECTOR_LEN;
+  const ret = wasm.matrix_add(ptr0, len0, ptr1, len1);
+  var v3 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+  wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+  return v3;
+}
+function matrix_multiply(a, a_rows, a_cols, b, b_rows, b_cols) {
+  const ptr0 = passArrayF64ToWasm0(a, wasm.__wbindgen_malloc);
+  const len0 = WASM_VECTOR_LEN;
+  const ptr1 = passArrayF64ToWasm0(b, wasm.__wbindgen_malloc);
+  const len1 = WASM_VECTOR_LEN;
+  const ret = wasm.matrix_multiply(ptr0, len0, a_rows, a_cols, ptr1, len1, b_rows, b_cols);
+  var v3 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+  wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+  return v3;
+}
+function matrix_scale(a, scalar) {
+  const ptr0 = passArrayF64ToWasm0(a, wasm.__wbindgen_malloc);
+  const len0 = WASM_VECTOR_LEN;
+  const ret = wasm.matrix_scale(ptr0, len0, scalar);
+  var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+  wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+  return v2;
+}
+function matrix_subtract(a, b) {
+  const ptr0 = passArrayF64ToWasm0(a, wasm.__wbindgen_malloc);
+  const len0 = WASM_VECTOR_LEN;
+  const ptr1 = passArrayF64ToWasm0(b, wasm.__wbindgen_malloc);
+  const len1 = WASM_VECTOR_LEN;
+  const ret = wasm.matrix_subtract(ptr0, len0, ptr1, len1);
+  var v3 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+  wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+  return v3;
+}
+function matrix_transpose(data, rows, cols) {
+  const ptr0 = passArrayF64ToWasm0(data, wasm.__wbindgen_malloc);
+  const len0 = WASM_VECTOR_LEN;
+  const ret = wasm.matrix_transpose(ptr0, len0, rows, cols);
+  var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+  wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+  return v2;
+}
+function qr_decompose(data, rows, cols) {
+  const ptr0 = passArrayF64ToWasm0(data, wasm.__wbindgen_malloc);
+  const len0 = WASM_VECTOR_LEN;
+  const ret = wasm.qr_decompose(ptr0, len0, rows, cols);
+  var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+  wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+  return v2;
+}
+function softmax_rows(data, rows, cols) {
+  const ptr0 = passArrayF64ToWasm0(data, wasm.__wbindgen_malloc);
+  const len0 = WASM_VECTOR_LEN;
+  const ret = wasm.softmax_rows(ptr0, len0, rows, cols);
+  var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+  wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+  return v2;
+}
+function solve_triangular(r, b, n) {
+  const ptr0 = passArrayF64ToWasm0(r, wasm.__wbindgen_malloc);
+  const len0 = WASM_VECTOR_LEN;
+  const ptr1 = passArrayF64ToWasm0(b, wasm.__wbindgen_malloc);
+  const len1 = WASM_VECTOR_LEN;
+  const ret = wasm.solve_triangular(ptr0, len0, ptr1, len1, n);
+  var v3 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+  wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+  return v3;
+}
+function svd(data, rows, cols) {
+  const ptr0 = passArrayF64ToWasm0(data, wasm.__wbindgen_malloc);
+  const len0 = WASM_VECTOR_LEN;
+  const ret = wasm.svd(ptr0, len0, rows, cols);
+  var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+  wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+  return v2;
+}
+function vector_dot(a, b) {
+  const ptr0 = passArrayF64ToWasm0(a, wasm.__wbindgen_malloc);
+  const len0 = WASM_VECTOR_LEN;
+  const ptr1 = passArrayF64ToWasm0(b, wasm.__wbindgen_malloc);
+  const len1 = WASM_VECTOR_LEN;
+  const ret = wasm.vector_dot(ptr0, len0, ptr1, len1);
+  return ret;
+}
+function getArrayF64FromWasm0(ptr, len) {
+  ptr = ptr >>> 0;
+  return getFloat64ArrayMemory0().subarray(ptr / 8, ptr / 8 + len);
+}
+function getFloat64ArrayMemory0() {
+  if (cachedFloat64ArrayMemory0 === null || cachedFloat64ArrayMemory0.byteLength === 0) {
+    cachedFloat64ArrayMemory0 = new Float64Array(wasm.memory.buffer);
+  }
+  return cachedFloat64ArrayMemory0;
+}
+function passArrayF64ToWasm0(arg, malloc) {
+  const ptr = malloc(arg.length * 8, 8) >>> 0;
+  getFloat64ArrayMemory0().set(arg, ptr / 8);
+  WASM_VECTOR_LEN = arg.length;
+  return ptr;
+}
+function __wbg_set_wasm(val) {
+  wasm = val;
+}
+var cachedFloat64ArrayMemory0 = null, WASM_VECTOR_LEN = 0, wasm;
+
+// pkg/regressio_wasm.js
+var exports_regressio_wasm = {};
+__export(exports_regressio_wasm, {
+  vector_dot: () => vector_dot,
+  svd: () => svd,
+  solve_triangular: () => solve_triangular,
+  softmax_rows: () => softmax_rows,
+  qr_decompose: () => qr_decompose,
+  matrix_transpose: () => matrix_transpose,
+  matrix_subtract: () => matrix_subtract,
+  matrix_scale: () => matrix_scale,
+  matrix_multiply: () => matrix_multiply,
+  matrix_add: () => matrix_add,
+  manhattan_distances: () => manhattan_distances,
+  frobenius_norm: () => frobenius_norm,
+  forward_substitution: () => forward_substitution,
+  euclidean_distances: () => euclidean_distances,
+  eigenvalues: () => eigenvalues,
+  determinant: () => determinant,
+  coordinate_descent: () => coordinate_descent,
+  cholesky: () => cholesky
+});
+var init_regressio_wasm = __esm(() => {
+  init_regressio_wasm_bg();
+  __wbg_set_wasm(exports_regressio_wasm_bg);
+  undefined();
+});
+
 // src/core/distributions.ts
 var exports_distributions = {};
 __export(exports_distributions, {
@@ -330,9 +544,6 @@ var init_distributions = __esm(() => {
 var exports_src = {};
 __export(exports_src, {
   vif: () => vif,
-  useWasmModule: () => useWasmModule,
-  useWasmEngine: () => useWasmEngine,
-  useTypescriptEngine: () => useTypescriptEngine,
   unstandardize: () => unstandardize,
   unnormalize: () => unnormalize,
   studentizedResiduals: () => studentizedResiduals,
@@ -348,7 +559,6 @@ __export(exports_src, {
   interactionFeatures: () => interactionFeatures,
   imputeMedian: () => imputeMedian,
   imputeMean: () => imputeMean,
-  getEngine: () => getEngine,
   durbinWatson: () => durbinWatson,
   dropMissing: () => dropMissing,
   correlationMatrix: () => correlationMatrix,
@@ -374,26 +584,14 @@ module.exports = __toCommonJS(exports_src);
 
 // src/core/engine.ts
 var currentEngine = { name: "typescript" };
-function getEngine() {
-  return currentEngine;
-}
+Promise.resolve().then(() => (init_regressio_wasm(), exports_regressio_wasm)).then((wasm2) => {
+  if (currentEngine.name === "typescript") {
+    currentEngine = { name: "wasm", wasm: wasm2 };
+  }
+}).catch(() => {});
 function isWasmActive() {
   return currentEngine.name === "wasm" && currentEngine.wasm != null;
 }
-async function useWasmEngine() {
-  try {
-    const wasm = await import("../../pkg");
-    currentEngine = { name: "wasm", wasm };
-  } catch {
-    throw new Error("WASM engine not available. Build it with: cd rust && wasm-pack build --target bundler --out-dir ../pkg");
-  }
-}
-function useWasmModule(wasmModule) {
-  currentEngine = { name: "wasm", wasm: wasmModule };
-}
-function useTypescriptEngine() {
-  currentEngine = { name: "typescript" };
-}
 function engineMatrixMultiply(a, aRows, aCols, b, bRows, bCols) {
   if (currentEngine.wasm) {
     return currentEngine.wasm.matrix_multiply(a, aRows, aCols, b, bRows, bCols);
@@ -409,28 +607,98 @@ function engineMatrixMultiply(a, aRows, aCols, b, bRows, bCols) {
   }
   return result;
 }
+function engineTranspose(data, rows, cols) {
+  if (currentEngine.wasm)
+    return currentEngine.wasm.matrix_transpose(data, rows, cols);
+  return null;
+}
+function engineAdd(a, b) {
+  if (currentEngine.wasm)
+    return currentEngine.wasm.matrix_add(a, b);
+  return null;
+}
+function engineSubtract(a, b) {
+  if (currentEngine.wasm)
+    return currentEngine.wasm.matrix_subtract(a, b);
+  return null;
+}
+function engineScale(a, scalar) {
+  if (currentEngine.wasm)
+    return currentEngine.wasm.matrix_scale(a, scalar);
+  return null;
+}
+function engineDot(a, b) {
+  if (currentEngine.wasm)
+    return currentEngine.wasm.vector_dot(a, b);
+  return null;
+}
+function engineNorm(a) {
+  if (currentEngine.wasm)
+    return currentEngine.wasm.frobenius_norm(a);
+  return null;
+}
+function engineDeterminant(data, n) {
+  if (currentEngine.wasm)
+    return currentEngine.wasm.determinant(data, n);
+  return null;
+}
 function engineQR(data, rows, cols) {
   if (currentEngine.wasm) {
     const result = currentEngine.wasm.qr_decompose(data, rows, cols);
     const qSize = rows * rows;
-    const Q = result.slice(0, qSize);
-    const R = result.slice(qSize);
-    return { Q, R };
+    return { Q: result.slice(0, qSize), R: result.slice(qSize) };
   }
   return null;
 }
 function engineCholesky(data, n) {
-  if (currentEngine.wasm) {
+  if (currentEngine.wasm)
     return currentEngine.wasm.cholesky(data, n);
-  }
   return null;
 }
 function engineSolveTriangular(r, b, n) {
-  if (currentEngine.wasm) {
+  if (currentEngine.wasm)
     return currentEngine.wasm.solve_triangular(r, b, n);
+  return null;
+}
+function engineForwardSubstitution(l, b, n) {
+  if (currentEngine.wasm)
+    return currentEngine.wasm.forward_substitution(l, b, n);
+  return null;
+}
+function engineSVD(data, rows, cols) {
+  if (currentEngine.wasm) {
+    const k = Math.min(rows, cols);
+    const result = currentEngine.wasm.svd(data, rows, cols);
+    const uSize = rows * k;
+    return {
+      U: result.slice(0, uSize),
+      S: result.slice(uSize, uSize + k),
+      V: result.slice(uSize + k)
+    };
+  }
+  return null;
+}
+function engineCoordinateDescent(x, y, alpha, l1Ratio, maxIter, tolerance, n, p, fitIntercept) {
+  if (currentEngine.wasm) {
+    return currentEngine.wasm.coordinate_descent(x, y, alpha, l1Ratio, maxIter, tolerance, n, p, fitIntercept);
   }
   return null;
 }
+function engineSoftmaxRows(data, rows, cols) {
+  if (currentEngine.wasm)
+    return currentEngine.wasm.softmax_rows(data, rows, cols);
+  return null;
+}
+function engineEuclideanDistances(train, test, nTrain, nTest, dim) {
+  if (currentEngine.wasm)
+    return currentEngine.wasm.euclidean_distances(train, test, nTrain, nTest, dim);
+  return null;
+}
+function engineManhattanDistances(train, test, nTrain, nTest, dim) {
+  if (currentEngine.wasm)
+    return currentEngine.wasm.manhattan_distances(train, test, nTrain, nTest, dim);
+  return null;
+}
 // src/core/matrix.ts
 class Matrix {
   rows;
@@ -513,6 +781,10 @@ class Matrix {
     }
   }
   transpose() {
+    const wasmResult = engineTranspose(this.data, this.rows, this.cols);
+    if (wasmResult) {
+      return new Matrix(this.cols, this.rows, wasmResult);
+    }
     const result = new Matrix(this.cols, this.rows);
     for (let i = 0;i < this.rows; i++) {
       for (let j = 0;j < this.cols; j++) {
@@ -530,6 +802,9 @@ class Matrix {
   }
   add(other) {
     this.assertSameDimensions(other, "add");
+    const w = engineAdd(this.data, other.data);
+    if (w)
+      return new Matrix(this.rows, this.cols, w);
     const result = new Matrix(this.rows, this.cols);
     for (let i = 0;i < this.data.length; i++) {
       result.data[i] = this.data[i] + other.data[i];
@@ -538,6 +813,9 @@ class Matrix {
   }
   subtract(other) {
     this.assertSameDimensions(other, "subtract");
+    const w = engineSubtract(this.data, other.data);
+    if (w)
+      return new Matrix(this.rows, this.cols, w);
     const result = new Matrix(this.rows, this.cols);
     for (let i = 0;i < this.data.length; i++) {
       result.data[i] = this.data[i] - other.data[i];
@@ -545,6 +823,9 @@ class Matrix {
     return result;
   }
   scale(scalar) {
+    const w = engineScale(this.data, scalar);
+    if (w)
+      return new Matrix(this.rows, this.cols, w);
     const result = new Matrix(this.rows, this.cols);
     for (let i = 0;i < this.data.length; i++) {
       result.data[i] = this.data[i] * scalar;
@@ -569,6 +850,9 @@ class Matrix {
     }
   }
   norm() {
+    const w = engineNorm(this.data);
+    if (w !== null)
+      return w;
     let sum = 0;
     for (let i = 0;i < this.data.length; i++) {
       sum += this.data[i] * this.data[i];
@@ -596,6 +880,9 @@ class Matrix {
       return this.data[0];
     if (n === 2)
       return this.data[0] * this.data[3] - this.data[1] * this.data[2];
+    const wasmResult = engineDeterminant(this.data, n);
+    if (wasmResult !== null)
+      return wasmResult;
     const a = new Float64Array(this.data);
     let det = 1;
     for (let col = 0;col < n; col++) {
@@ -658,6 +945,9 @@ class Matrix {
     return Array.from(this.data);
   }
   dot(other) {
+    const w = engineDot(this.data, other.data);
+    if (w !== null)
+      return w;
     let sum = 0;
     for (let i = 0;i < this.data.length; i++) {
       sum += this.data[i] * other.data[i];
@@ -798,6 +1088,15 @@ function choleskyDecomposition(A) {
 }
 function forwardSubstitution(L, b) {
   const n = L.rows;
+  if (isWasmActive()) {
+    const bFlat = new Float64Array(n);
+    for (let i = 0;i < n; i++)
+      bFlat[i] = b.get(i, 0);
+    const wasmResult = engineForwardSubstitution(L.data, bFlat, n);
+    if (wasmResult) {
+      return Matrix.columnVector(Array.from(wasmResult));
+    }
+  }
   const y = new Float64Array(n);
   for (let i = 0;i < n; i++) {
     let sum = b.get(i, 0);
@@ -812,10 +1111,20 @@ function solveCholesky(L, b) {
   const y = forwardSubstitution(L, b);
   return backSubstitution(L.transpose(), y);
 }
-function svd(A) {
+function svd2(A) {
   const m = A.rows;
   const n = A.cols;
   const k = Math.min(m, n);
+  if (isWasmActive()) {
+    const wasmResult = engineSVD(A.data, m, n);
+    if (wasmResult) {
+      return {
+        U: new Matrix(m, k, wasmResult.U),
+        S: Array.from(wasmResult.S),
+        V: new Matrix(n, k, wasmResult.V)
+      };
+    }
+  }
   const W = A.clone();
   const V = Matrix.identity(n);
   const maxIter = 100;
@@ -1143,7 +1452,7 @@ function correlationMatrix(X) {
 }
 function conditionNumber(X) {
   const A = Matrix.fromArray(X);
-  const { S } = svd(A);
+  const { S } = svd2(A);
   const sMax = S[0] ?? 1;
   const sMin = S[S.length - 1] ?? 0;
   return sMin > 0.000000000000001 ? sMax / sMin : Infinity;
@@ -1290,6 +1599,18 @@ class LassoRegression extends BaseRegression {
     this._y = y;
     const n = Xmat.length;
     const p = Xmat[0].length;
+    const xFlat = new Float64Array(n * p);
+    for (let i = 0;i < n; i++)
+      for (let j = 0;j < p; j++)
+        xFlat[i * p + j] = Xmat[i][j];
+    const wasmResult = engineCoordinateDescent(xFlat, new Float64Array(y), this._alpha, this.getL1Ratio(), this._maxIterations, this._tolerance, n, p, this._fitIntercept);
+    if (wasmResult) {
+      this._intercept = wasmResult[0];
+      this._coefficients = Array.from(wasmResult.slice(1));
+      this._yHat = this.predict(Xmat);
+      this._fitted = true;
+      return this;
+    }
     const { Xstd, xMeans, xStds, yMean } = this.standardize(Xmat, y);
     const yCentered = y.map((yi) => yi - yMean);
     const beta = new Float64Array(p);
@@ -1331,6 +1652,9 @@ class LassoRegression extends BaseRegression {
     this._fitted = true;
     return this;
   }
+  getL1Ratio() {
+    return 1;
+  }
   predict(X) {
     const Xmat = this.normalizeInput(X);
     return Xmat.map((row) => {
@@ -1394,6 +1718,9 @@ class ElasticNet extends LassoRegression {
     });
     this._l1Ratio = options.l1Ratio ?? 0.5;
   }
+  getL1Ratio() {
+    return this._l1Ratio;
+  }
   coordinateUpdate(rho, colNormSq, n, _j) {
     const l1Penalty = n * this._alpha * this._l1Ratio;
     const l2Penalty = n * this._alpha * (1 - this._l1Ratio);
@@ -1430,6 +1757,24 @@ class KNearestNeighbors {
     if (!this._fitted)
       throw new Error("Model has not been fitted. Call fit() first.");
     const Xmat = this.normalizeInput(X);
+    const dim = this._X[0].length;
+    const nTrain = this._X.length;
+    const nTest = Xmat.length;
+    const trainFlat = new Float64Array(nTrain * dim);
+    for (let i = 0;i < nTrain; i++)
+      for (let j = 0;j < dim; j++)
+        trainFlat[i * dim + j] = this._X[i][j];
+    const testFlat = new Float64Array(nTest * dim);
+    for (let i = 0;i < nTest; i++)
+      for (let j = 0;j < dim; j++)
+        testFlat[i * dim + j] = Xmat[i][j];
+    const distMatrix = this._distance === "manhattan" ? engineManhattanDistances(trainFlat, testFlat, nTrain, nTest, dim) : engineEuclideanDistances(trainFlat, testFlat, nTrain, nTest, dim);
+    if (distMatrix) {
+      return Array.from({ length: nTest }, (_, i) => {
+        const indices = Array.from({ length: nTrain }, (_2, j) => j).sort((a, b) => distMatrix[i * nTrain + a] - distMatrix[i * nTrain + b]).slice(0, this._k);
+        return this.voteOrMean(indices);
+      });
+    }
     return Xmat.map((row) => this.predictOne(row));
   }
   neighbors(point) {
@@ -1437,17 +1782,16 @@ class KNearestNeighbors {
       throw new Error("Model has not been fitted. Call fit() first.");
     return this.findNeighbors(point).map((n) => n.index);
   }
-  predictOne(point) {
-    const nearest = this.findNeighbors(point);
+  voteOrMean(indices) {
     if (this._mode === "regression") {
       let sum = 0;
-      for (const n of nearest)
-        sum += this._y[n.index];
-      return sum / nearest.length;
+      for (const idx of indices)
+        sum += this._y[idx];
+      return sum / indices.length;
     }
     const votes = new Map;
-    for (const n of nearest) {
-      const label = this._y[n.index];
+    for (const idx of indices) {
+      const label = this._y[idx];
       votes.set(label, (votes.get(label) ?? 0) + 1);
     }
     let bestLabel = 0;
@@ -1460,6 +1804,10 @@ class KNearestNeighbors {
     }
     return bestLabel;
   }
+  predictOne(point) {
+    const nearest = this.findNeighbors(point);
+    return this.voteOrMean(nearest.map((n) => n.index));
+  }
   findNeighbors(point) {
     const distances = [];
     for (let i = 0;i < this._X.length; i++) {
@@ -1727,14 +2075,20 @@ class MulticlassLogisticRegression {
     const XMat = Matrix.fromArray(Xdesign);
     for (let iter = 0;iter < this._maxIterations; iter++) {
       const scores = XMat.multiply(this._weights);
-      const P = Matrix.zeros(n, K);
-      for (let i = 0;i < n; i++) {
-        const logits = [];
-        for (let c = 0;c < K; c++)
-          logits.push(scores.get(i, c));
-        const probs = this.softmax(logits);
-        for (let c = 0;c < K; c++)
-          P.set(i, c, probs[c]);
+      const wasmP = engineSoftmaxRows(scores.data, n, K);
+      let P;
+      if (wasmP) {
+        P = new Matrix(n, K, wasmP);
+      } else {
+        P = Matrix.zeros(n, K);
+        for (let i = 0;i < n; i++) {
+          const logits = [];
+          for (let c = 0;c < K; c++)
+            logits.push(scores.get(i, c));
+          const probs = this.softmax(logits);
+          for (let c = 0;c < K; c++)
+            P.set(i, c, probs[c]);
+        }
       }
       const diff = P.subtract(Y);
       const grad = XMat.transpose().multiply(diff).scale(1 / n);