regressio 1.1.0 → 1.1.2

package/dist/index.cjs

@@ -36,7 +36,17 @@ var __export = (target, all) => {
       set: __exportSetter.bind(all, name)
     });
 };
-var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __esm = (fn, res, err) => () => {
+  if (fn)
+    try {
+      res = fn(fn = 0);
+    } catch (e) {
+      err = [e];
+    }
+  if (err)
+    throw err[0];
+  return res;
+};
 
 // pkg/regressio_wasm_bg.js
 function bootstrap_ols(x, y, n, p, fit_intercept, n_bootstrap, seed) {
@@ -262,35 +272,35 @@ function __wbg_set_wasm(val) {
 var cachedFloat64ArrayMemory0 = null, WASM_VECTOR_LEN = 0, wasm;
 
 // pkg/regressio_wasm_bg.wasm
-var regressio_wasm_bg_default = "./regressio_wasm_bg-zc1d7yka.wasm";
+var regressio_wasm_bg_default = "./regressio_wasm_bg-5tapzraw.wasm";
 var init_regressio_wasm_bg = () => {};
 
 // src/wasm-init.ts
 var exports_wasm_init = {};
 __export(exports_wasm_init, {
-  vif: () => vif,
-  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,
-  irls_logistic: () => irls_logistic,
-  initWasm: () => initWasm,
-  frobenius_norm: () => frobenius_norm,
-  forward_substitution: () => forward_substitution,
-  euclidean_distances: () => euclidean_distances,
-  eigenvalues: () => eigenvalues,
-  determinant: () => determinant,
-  correlation_matrix: () => correlation_matrix,
-  coordinate_descent: () => coordinate_descent,
+  bootstrap_ols: () => bootstrap_ols,
   cholesky: () => cholesky,
-  bootstrap_ols: () => bootstrap_ols
+  coordinate_descent: () => coordinate_descent,
+  correlation_matrix: () => correlation_matrix,
+  determinant: () => determinant,
+  eigenvalues: () => eigenvalues,
+  euclidean_distances: () => euclidean_distances,
+  forward_substitution: () => forward_substitution,
+  frobenius_norm: () => frobenius_norm,
+  initWasm: () => initWasm,
+  irls_logistic: () => irls_logistic,
+  manhattan_distances: () => manhattan_distances,
+  matrix_add: () => matrix_add,
+  matrix_multiply: () => matrix_multiply,
+  matrix_scale: () => matrix_scale,
+  matrix_subtract: () => matrix_subtract,
+  matrix_transpose: () => matrix_transpose,
+  qr_decompose: () => qr_decompose,
+  softmax_rows: () => softmax_rows,
+  solve_triangular: () => solve_triangular,
+  svd: () => svd,
+  vector_dot: () => vector_dot,
+  vif: () => vif
 });
 async function loadWasmBytes() {
   const resolved = typeof regressio_wasm_bg_default === "string" ? regressio_wasm_bg_default : null;
@@ -321,42 +331,42 @@ var init_wasm_init = __esm(() => {
 // src/index.ts
 var exports_src = {};
 __export(exports_src, {
-  vif: () => vif2,
-  unstandardize: () => unstandardize,
-  unnormalize: () => unnormalize,
-  studentizedResiduals: () => studentizedResiduals,
-  standardize: () => standardize,
-  shapiroWilk: () => shapiroWilk,
-  residualDiagnostics: () => residualDiagnostics,
-  predictionInterval: () => predictionInterval,
-  polynomialFeatures: () => polynomialFeatures,
-  oneHotEncode: () => oneHotEncode,
-  normalize: () => normalize,
-  leverage: () => leverage,
-  isWasmActive: () => isWasmActive,
-  interactionFeatures: () => interactionFeatures,
-  imputeMedian: () => imputeMedian,
-  imputeMean: () => imputeMean,
-  durbinWatson: () => durbinWatson,
-  dropMissing: () => dropMissing,
-  correlationMatrix: () => correlationMatrix,
-  cooksDistance: () => cooksDistance,
-  confidenceInterval: () => confidenceInterval,
-  conditionNumber: () => conditionNumber,
-  breuschPagan: () => breuschPagan,
-  bootstrapCoefficients: () => bootstrapCoefficients,
-  WeightedRegression: () => WeightedRegression,
-  RobustRegression: () => RobustRegression,
-  RidgeRegression: () => RidgeRegression,
-  PolynomialRegression: () => PolynomialRegression,
-  NeuralNetwork: () => NeuralNetwork,
-  MulticlassLogisticRegression: () => MulticlassLogisticRegression,
-  Matrix: () => Matrix,
-  LogisticRegression: () => LogisticRegression,
-  LinearRegression: () => LinearRegression,
-  LassoRegression: () => LassoRegression,
+  ElasticNet: () => ElasticNet,
   KNearestNeighbors: () => KNearestNeighbors,
-  ElasticNet: () => ElasticNet
+  LassoRegression: () => LassoRegression,
+  LinearRegression: () => LinearRegression,
+  LogisticRegression: () => LogisticRegression,
+  Matrix: () => Matrix,
+  MulticlassLogisticRegression: () => MulticlassLogisticRegression,
+  NeuralNetwork: () => NeuralNetwork,
+  PolynomialRegression: () => PolynomialRegression,
+  RidgeRegression: () => RidgeRegression,
+  RobustRegression: () => RobustRegression,
+  WeightedRegression: () => WeightedRegression,
+  bootstrapCoefficients: () => bootstrapCoefficients,
+  breuschPagan: () => breuschPagan,
+  conditionNumber: () => conditionNumber,
+  confidenceInterval: () => confidenceInterval,
+  cooksDistance: () => cooksDistance,
+  correlationMatrix: () => correlationMatrix,
+  dropMissing: () => dropMissing,
+  durbinWatson: () => durbinWatson,
+  imputeMean: () => imputeMean,
+  imputeMedian: () => imputeMedian,
+  interactionFeatures: () => interactionFeatures,
+  isWasmActive: () => isWasmActive,
+  leverage: () => leverage,
+  normalize: () => normalize,
+  oneHotEncode: () => oneHotEncode,
+  polynomialFeatures: () => polynomialFeatures,
+  predictionInterval: () => predictionInterval,
+  residualDiagnostics: () => residualDiagnostics,
+  shapiroWilk: () => shapiroWilk,
+  standardize: () => standardize,
+  studentizedResiduals: () => studentizedResiduals,
+  unnormalize: () => unnormalize,
+  unstandardize: () => unstandardize,
+  vif: () => vif2
 });
 module.exports = __toCommonJS(exports_src);
 
@@ -1196,12 +1206,55 @@ function chi2TestPValue(stat, df) {
   return 1 - chi2CDFExact(stat, df);
 }
 
+// src/models/input-validation.ts
+function normalizeModelInput(X) {
+  if (X.length === 0)
+    throw new Error("Input data cannot be empty");
+  const matrix = typeof X[0] === "number" ? X.map((value) => [value]) : X;
+  const columns = matrix[0]?.length ?? 0;
+  if (columns === 0)
+    throw new Error("Input data must contain at least one feature");
+  for (let i = 0;i < matrix.length; i++) {
+    const row = matrix[i];
+    if (row.length !== columns) {
+      throw new Error(`Row ${i} has ${row.length} columns, expected ${columns}`);
+    }
+    if (!row.every(Number.isFinite)) {
+      throw new Error("Model inputs must contain only finite numbers");
+    }
+  }
+  return matrix;
+}
+function validateTargets(y, expectedRows) {
+  if (y.length !== expectedRows) {
+    throw new Error(`X has ${expectedRows} rows but y has ${y.length} elements`);
+  }
+  if (!y.every(Number.isFinite)) {
+    throw new Error("Model targets must contain only finite numbers");
+  }
+}
+function validateFeatureCount(X, expectedFeatures) {
+  const actualFeatures = X[0].length;
+  if (actualFeatures !== expectedFeatures) {
+    throw new Error(`Prediction data has ${actualFeatures} features, expected ${expectedFeatures}`);
+  }
+}
+function validateFeatureVector(point, expectedFeatures) {
+  if (point.length !== expectedFeatures) {
+    throw new Error(`Prediction point has ${point.length} features, expected ${expectedFeatures}`);
+  }
+  if (!point.every(Number.isFinite)) {
+    throw new Error("Prediction point must contain only finite numbers");
+  }
+}
+
 // src/models/base.ts
 class BaseRegression {
   _coefficients = [];
   _intercept = 0;
   _fitted = false;
   _fitIntercept;
+  _nFeatures = 0;
   _X = [];
   _y = [];
   _yHat = [];
@@ -1316,22 +1369,34 @@ class BaseRegression {
 `);
   }
   normalizeInput(X) {
-    if (X.length === 0)
-      throw new Error("Input data cannot be empty");
-    if (typeof X[0] === "number") {
-      return X.map((v) => [v]);
-    }
-    return X;
+    return normalizeModelInput(X);
   }
   addInterceptColumn(X) {
     return X.map((row) => [1, ...row]);
   }
   validateFitInput(X, y) {
-    if (X.length !== y.length) {
-      throw new Error(`X has ${X.length} rows but y has ${y.length} elements`);
-    }
-    if (X.length === 0)
-      throw new Error("Input data cannot be empty");
+    validateTargets(y, X.length);
+    this._nFeatures = X[0].length;
+  }
+  validatePredictInput(X) {
+    this.assertFitted();
+    const Xmat = this.normalizeInput(X);
+    validateFeatureCount(Xmat, this._nFeatures);
+    return Xmat;
+  }
+  predictLinearRows(X) {
+    return X.map((row) => {
+      let sum = this._intercept;
+      for (let j = 0;j < this._coefficients.length; j++) {
+        sum += row[j] * this._coefficients[j];
+      }
+      return sum;
+    });
+  }
+  completeFit(X, statisticsX = X) {
+    this._fitted = true;
+    this._yHat = this.predict(X);
+    this._X = statisticsX;
   }
   assertFitted() {
     if (!this._fitted) {
@@ -1377,19 +1442,11 @@ class LinearRegression extends BaseRegression {
       this._intercept = 0;
       this._coefficients = betaArray;
     }
-    this._yHat = this.predict(Xmat);
-    this._fitted = true;
+    this.completeFit(Xmat);
     return this;
   }
   predict(X) {
-    const Xmat = this.normalizeInput(X);
-    return Xmat.map((row) => {
-      let sum = this._intercept;
-      for (let j = 0;j < this._coefficients.length; j++) {
-        sum += row[j] * this._coefficients[j];
-      }
-      return sum;
-    });
+    return this.predictLinearRows(this.validatePredictInput(X));
   }
 }
 
@@ -1427,15 +1484,15 @@ function correlationMatrix(X) {
       xFlat[i * p + j] = X[i][j];
   const wasmResult = engineCorrelationMatrix(xFlat, n, p);
   if (wasmResult) {
-    const corr2 = [];
+    const corr = [];
     for (let j1 = 0;j1 < p; j1++) {
       const row = [];
       for (let j2 = 0;j2 < p; j2++) {
         row.push(wasmResult[j1 * p + j2]);
       }
-      corr2.push(row);
+      corr.push(row);
     }
-    return corr2;
+    return corr;
   }
   const means = [];
   for (let j = 0;j < p; j++) {
@@ -1566,7 +1623,7 @@ function shapiroWilk(data) {
   const n = data.length;
   if (n < 3)
     throw new Error("Shapiro-Wilk requires at least 3 observations");
-  const sorted = [...data].sort((a2, b) => a2 - b);
+  const sorted = [...data].sort((a, b) => a - b);
   let mean = 0;
   for (const x of sorted)
     mean += x;
@@ -1625,8 +1682,7 @@ class LassoRegression extends BaseRegression {
     if (wasmResult) {
       this._intercept = wasmResult[0];
       this._coefficients = Array.from(wasmResult.slice(1));
-      this._yHat = this.predict(Xmat);
-      this._fitted = true;
+      this.completeFit(Xmat);
       return this;
     }
     const { Xstd, xMeans, xStds, yMean } = this.standardize(Xmat, y);
@@ -1666,22 +1722,14 @@ class LassoRegression extends BaseRegression {
       return std > 0.000000000000001 ? bj / std : 0;
     });
     this._intercept = this._fitIntercept ? yMean - this._coefficients.reduce((sum, bj, j) => sum + bj * xMeans[j], 0) : 0;
-    this._yHat = this.predict(Xmat);
-    this._fitted = true;
+    this.completeFit(Xmat);
     return this;
   }
   getL1Ratio() {
     return 1;
   }
   predict(X) {
-    const Xmat = this.normalizeInput(X);
-    return Xmat.map((row) => {
-      let sum = this._intercept;
-      for (let j = 0;j < this._coefficients.length; j++) {
-        sum += row[j] * this._coefficients[j];
-      }
-      return sum;
-    });
+    return this.predictLinearRows(this.validatePredictInput(X));
   }
   coordinateUpdate(rho, colNormSq, n, _j) {
     return this.softThreshold(rho, n * this._alpha) / colNormSq;
@@ -1753,28 +1801,29 @@ class KNearestNeighbors {
   _fitted = false;
   _X = [];
   _y = [];
+  _nFeatures = 0;
   constructor(options = {}) {
     this._k = options.k ?? 5;
     this._distance = options.distance ?? "euclidean";
     this._mode = options.mode ?? "classification";
   }
   fit(X, y) {
-    const Xmat = this.normalizeInput(X);
-    if (Xmat.length !== y.length) {
-      throw new Error(`X has ${Xmat.length} rows but y has ${y.length} elements`);
-    }
+    const Xmat = normalizeModelInput(X);
+    validateTargets(y, Xmat.length);
     if (Xmat.length < this._k) {
       throw new Error(`Need at least k=${this._k} samples, got ${Xmat.length}`);
     }
     this._X = Xmat;
     this._y = y;
+    this._nFeatures = Xmat[0].length;
     this._fitted = true;
     return this;
   }
   predict(X) {
     if (!this._fitted)
       throw new Error("Model has not been fitted. Call fit() first.");
-    const Xmat = this.normalizeInput(X);
+    const Xmat = normalizeModelInput(X);
+    validateFeatureCount(Xmat, this._nFeatures);
     const dim = this._X[0].length;
     const nTrain = this._X.length;
     const nTest = Xmat.length;
@@ -1789,7 +1838,7 @@ class KNearestNeighbors {
     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);
+        const indices = Array.from({ length: nTrain }, (_, j) => j).sort((a, b) => distMatrix[i * nTrain + a] - distMatrix[i * nTrain + b]).slice(0, this._k);
         return this.voteOrMean(indices);
       });
     }
@@ -1798,6 +1847,7 @@ class KNearestNeighbors {
   neighbors(point) {
     if (!this._fitted)
       throw new Error("Model has not been fitted. Call fit() first.");
+    validateFeatureVector(point, this._nFeatures);
     return this.findNeighbors(point).map((n) => n.index);
   }
   voteOrMean(indices) {
@@ -1847,14 +1897,6 @@ class KNearestNeighbors {
     }
     return this._distance === "manhattan" ? sum : Math.sqrt(sum);
   }
-  normalizeInput(X) {
-    if (X.length === 0)
-      throw new Error("Input data cannot be empty");
-    if (typeof X[0] === "number") {
-      return X.map((v) => [v]);
-    }
-    return X;
-  }
 }
 // src/models/logistic-regression.ts
 class LogisticRegression {
@@ -1866,6 +1908,7 @@ class LogisticRegression {
   _tolerance;
   _y = [];
   _probabilities = [];
+  _nFeatures = 0;
   constructor(options = {}) {
     this._fitIntercept = options.fitIntercept ?? true;
     this._maxIterations = options.maxIterations ?? 100;
@@ -1888,10 +1931,9 @@ class LogisticRegression {
     return expZ / (1 + expZ);
   }
   fit(X, y) {
-    const Xmat = this.normalizeInput(X);
-    if (Xmat.length !== y.length) {
-      throw new Error(`X has ${Xmat.length} rows but y has ${y.length} elements`);
-    }
+    const Xmat = normalizeModelInput(X);
+    validateTargets(y, Xmat.length);
+    this._nFeatures = Xmat[0].length;
     for (const yi of y) {
       if (yi !== 0 && yi !== 1) {
         throw new Error("Logistic regression requires binary y (0 or 1)");
@@ -1907,16 +1949,16 @@ class LogisticRegression {
         xFlat[i * k + j] = Xdesign[i][j];
     const wasmBeta = engineIRLSLogistic(xFlat, new Float64Array(y), n, k, this._maxIterations, this._tolerance);
     if (wasmBeta) {
-      const betaArray2 = Array.from(wasmBeta);
+      const betaArray = Array.from(wasmBeta);
       if (this._fitIntercept) {
-        this._intercept = betaArray2[0];
-        this._coefficients = betaArray2.slice(1);
+        this._intercept = betaArray[0];
+        this._coefficients = betaArray.slice(1);
       } else {
         this._intercept = 0;
-        this._coefficients = betaArray2;
+        this._coefficients = betaArray;
       }
-      this._probabilities = this.predictProbability(Xmat);
       this._fitted = true;
+      this._probabilities = this.predictProbability(Xmat);
       return this;
     }
     const beta = new Float64Array(k);
@@ -1965,15 +2007,18 @@ class LogisticRegression {
       this._intercept = 0;
       this._coefficients = betaArray;
     }
-    this._probabilities = this.predictProbability(Xmat);
     this._fitted = true;
+    this._probabilities = this.predictProbability(Xmat);
     return this;
   }
   predict(X) {
     return this.predictProbability(X).map((p) => p >= 0.5 ? 1 : 0);
   }
   predictProbability(X) {
-    const Xmat = this.normalizeInput(X);
+    if (!this._fitted)
+      throw new Error("Model has not been fitted. Call fit() first.");
+    const Xmat = normalizeModelInput(X);
+    validateFeatureCount(Xmat, this._nFeatures);
     return Xmat.map((row) => {
       let sum = this._intercept;
       for (let j = 0;j < this._coefficients.length; j++) {
@@ -2037,14 +2082,6 @@ class LogisticRegression {
       bic
     };
   }
-  normalizeInput(X) {
-    if (X.length === 0)
-      throw new Error("Input data cannot be empty");
-    if (typeof X[0] === "number") {
-      return X.map((v) => [v]);
-    }
-    return X;
-  }
   addInterceptColumn(X) {
     return X.map((row) => [1, ...row]);
   }
@@ -2061,6 +2098,7 @@ class MulticlassLogisticRegression {
   _classes = [];
   _X = [];
   _y = [];
+  _nFeatures = 0;
   constructor(options = {}) {
     this._fitIntercept = options.fitIntercept ?? true;
     this._maxIterations = options.maxIterations ?? 200;
@@ -2084,10 +2122,9 @@ class MulticlassLogisticRegression {
     return exps.map((e) => e / sum);
   }
   fit(X, y) {
-    const Xmat = this.normalizeInput(X);
-    if (Xmat.length !== y.length) {
-      throw new Error(`X has ${Xmat.length} rows but y has ${y.length} elements`);
-    }
+    const Xmat = normalizeModelInput(X);
+    validateTargets(y, Xmat.length);
+    this._nFeatures = Xmat[0].length;
     this._X = Xmat;
     this._y = y;
     this._classes = [...new Set(y)].sort((a, b) => a - b);
@@ -2156,7 +2193,8 @@ class MulticlassLogisticRegression {
   predictProbability(X) {
     if (!this._fitted)
       throw new Error("Model has not been fitted. Call fit() first.");
-    const Xmat = this.normalizeInput(X);
+    const Xmat = normalizeModelInput(X);
+    validateFeatureCount(Xmat, this._nFeatures);
     const Xdesign = this._fitIntercept ? Xmat.map((row) => [1, ...row]) : Xmat;
     const XMat = Matrix.fromArray(Xdesign);
     const scores = XMat.multiply(this._weights);
@@ -2213,14 +2251,6 @@ class MulticlassLogisticRegression {
       logLikelihood: logLik
     };
   }
-  normalizeInput(X) {
-    if (X.length === 0)
-      throw new Error("Input data cannot be empty");
-    if (typeof X[0] === "number") {
-      return X.map((v) => [v]);
-    }
-    return X;
-  }
 }
 // src/models/neural-network.ts
 class NeuralNetwork {
@@ -2231,6 +2261,7 @@ class NeuralNetwork {
   _fitted = false;
   _outputSize = 0;
   _classes = [];
+  _nFeatures = 0;
   constructor(options) {
     this._learningRate = options.learningRate ?? 0.01;
     this._epochs = options.epochs ?? 100;
@@ -2263,11 +2294,10 @@ class NeuralNetwork {
     };
   }
   fit(X, y) {
-    const Xmat = this.normalizeInput(X);
-    if (Xmat.length !== y.length) {
-      throw new Error(`X has ${Xmat.length} rows but y has ${y.length} elements`);
-    }
+    const Xmat = normalizeModelInput(X);
+    validateTargets(y, Xmat.length);
     const inputSize = Xmat[0].length;
+    this._nFeatures = inputSize;
     const n = Xmat.length;
     if (this._task === "classification") {
       this._classes = [...new Set(y)].sort((a, b) => a - b);
@@ -2295,7 +2325,8 @@ class NeuralNetwork {
   predict(X) {
     if (!this._fitted)
       throw new Error("Model has not been fitted. Call fit() first.");
-    const Xmat = this.normalizeInput(X);
+    const Xmat = normalizeModelInput(X);
+    validateFeatureCount(Xmat, this._nFeatures);
     return Xmat.map((row) => {
       const activations = this.forward(row);
       const output = activations[activations.length - 1];
@@ -2316,7 +2347,8 @@ class NeuralNetwork {
   predictRaw(X) {
     if (!this._fitted)
       throw new Error("Model has not been fitted. Call fit() first.");
-    const Xmat = this.normalizeInput(X);
+    const Xmat = normalizeModelInput(X);
+    validateFeatureCount(Xmat, this._nFeatures);
     return Xmat.map((row) => {
       const activations = this.forward(row);
       return Array.from(activations[activations.length - 1]);
@@ -2432,14 +2464,6 @@ class NeuralNetwork {
       encoded[idx] = 1;
     return encoded;
   }
-  normalizeInput(X) {
-    if (X.length === 0)
-      throw new Error("Input data cannot be empty");
-    if (typeof X[0] === "number") {
-      return X.map((v) => [v]);
-    }
-    return X;
-  }
 }
 // src/models/polynomial-regression.ts
 class PolynomialRegression extends BaseRegression {
@@ -2472,12 +2496,11 @@ class PolynomialRegression extends BaseRegression {
     this._inner.fit(Xexpanded, y);
     this._coefficients = this._inner.coefficients;
     this._intercept = this._inner.intercept;
-    this._yHat = this.predict(Xmat);
-    this._fitted = true;
+    this.completeFit(Xmat, Xexpanded);
     return this;
   }
   predict(X) {
-    const Xmat = this.normalizeInput(X);
+    const Xmat = this.validatePredictInput(X);
     const Xexpanded = this.expandFeatures(Xmat);
     return this._inner.predict(Xexpanded);
   }
@@ -2514,19 +2537,11 @@ class RidgeRegression extends BaseRegression {
       this._intercept = 0;
       this._coefficients = betaArray;
     }
-    this._yHat = this.predict(Xmat);
-    this._fitted = true;
+    this.completeFit(Xmat);
     return this;
   }
   predict(X) {
-    const Xmat = this.normalizeInput(X);
-    return Xmat.map((row) => {
-      let sum = this._intercept;
-      for (let j = 0;j < this._coefficients.length; j++) {
-        sum += row[j] * this._coefficients[j];
-      }
-      return sum;
-    });
+    return this.predictLinearRows(this.validatePredictInput(X));
   }
 }
 // src/models/weighted-regression.ts
@@ -2563,19 +2578,11 @@ class WeightedRegression extends BaseRegression {
       this._intercept = 0;
       this._coefficients = betaArray;
     }
-    this._yHat = this.predict(Xmat);
-    this._fitted = true;
+    this.completeFit(Xmat);
     return this;
   }
   predict(X) {
-    const Xmat = this.normalizeInput(X);
-    return Xmat.map((row) => {
-      let sum = this._intercept;
-      for (let j = 0;j < this._coefficients.length; j++) {
-        sum += row[j] * this._coefficients[j];
-      }
-      return sum;
-    });
+    return this.predictLinearRows(this.validatePredictInput(X));
   }
 }
 
@@ -2604,7 +2611,7 @@ class RobustRegression extends BaseRegression {
     for (let iter = 0;iter < this._maxIterations; iter++) {
       const prevCoeffs = [...this._coefficients];
       const prevIntercept = this._intercept;
-      const yHat = this.predict(Xmat);
+      const yHat = this.predictLinearRows(Xmat);
       const residuals = y.map((yi, i) => yi - yHat[i]);
       const sortedResiduals = [...residuals].sort((a, b) => a - b);
       const residualMedian = median(sortedResiduals);
@@ -2626,19 +2633,11 @@ class RobustRegression extends BaseRegression {
       if (maxChange < this._tolerance)
         break;
     }
-    this._yHat = this.predict(Xmat);
-    this._fitted = true;
+    this.completeFit(Xmat);
     return this;
   }
   predict(X) {
-    const Xmat = this.normalizeInput(X);
-    return Xmat.map((row) => {
-      let sum = this._intercept;
-      for (let j = 0;j < this._coefficients.length; j++) {
-        sum += row[j] * this._coefficients[j];
-      }
-      return sum;
-    });
+    return this.predictLinearRows(this.validatePredictInput(X));
   }
 }
 function huberWeight(u, k) {