deepbox 0.1.0

package/dist/chunk-FJYLIGJX.js

@@ -0,0 +1,1940 @@
+import { tensor } from './chunk-BCR7G3A6.js';
+import { __export, InvalidParameterError, DataValidationError, ShapeError, getNumericElement, DTypeError, getStringElement, getBigIntElement, isTypedArray, isNumericTypedArray } from './chunk-4S73VUBD.js';
+
+// src/metrics/index.ts
+var metrics_exports = {};
+__export(metrics_exports, {
+  accuracy: () => accuracy,
+  adjustedMutualInfoScore: () => adjustedMutualInfoScore,
+  adjustedR2Score: () => adjustedR2Score,
+  adjustedRandScore: () => adjustedRandScore,
+  averagePrecisionScore: () => averagePrecisionScore,
+  balancedAccuracyScore: () => balancedAccuracyScore,
+  calinskiHarabaszScore: () => calinskiHarabaszScore,
+  classificationReport: () => classificationReport,
+  cohenKappaScore: () => cohenKappaScore,
+  completenessScore: () => completenessScore,
+  confusionMatrix: () => confusionMatrix,
+  daviesBouldinScore: () => daviesBouldinScore,
+  explainedVarianceScore: () => explainedVarianceScore,
+  f1Score: () => f1Score,
+  fbetaScore: () => fbetaScore,
+  fowlkesMallowsScore: () => fowlkesMallowsScore,
+  hammingLoss: () => hammingLoss,
+  homogeneityScore: () => homogeneityScore,
+  jaccardScore: () => jaccardScore,
+  logLoss: () => logLoss,
+  mae: () => mae,
+  mape: () => mape,
+  matthewsCorrcoef: () => matthewsCorrcoef,
+  maxError: () => maxError,
+  medianAbsoluteError: () => medianAbsoluteError,
+  mse: () => mse,
+  normalizedMutualInfoScore: () => normalizedMutualInfoScore,
+  precision: () => precision,
+  precisionRecallCurve: () => precisionRecallCurve,
+  r2Score: () => r2Score,
+  recall: () => recall,
+  rmse: () => rmse,
+  rocAucScore: () => rocAucScore,
+  rocCurve: () => rocCurve,
+  silhouetteSamples: () => silhouetteSamples,
+  silhouetteScore: () => silhouetteScore,
+  vMeasureScore: () => vMeasureScore
+});
+
+// src/metrics/_internal.ts
+function computeLogicalStrides(shape) {
+  const strides = new Array(shape.length);
+  let stride = 1;
+  for (let i = shape.length - 1; i >= 0; i--) {
+    const dim = shape[i];
+    if (dim === void 0) {
+      throw new ShapeError("Tensor shape must be fully defined");
+    }
+    strides[i] = stride;
+    stride *= dim;
+  }
+  return strides;
+}
+function createFlatOffsetter(t) {
+  const base = t.offset;
+  if (t.ndim <= 1) {
+    const stride0 = t.strides[0] ?? 1;
+    return (flatIndex) => base + flatIndex * stride0;
+  }
+  const logicalStrides = computeLogicalStrides(t.shape);
+  const strides = t.strides;
+  return (flatIndex) => {
+    let rem = flatIndex;
+    let offset = base;
+    for (let axis = 0; axis < logicalStrides.length; axis++) {
+      const axisLogicalStride = logicalStrides[axis] ?? 1;
+      const coord = Math.floor(rem / axisLogicalStride);
+      rem -= coord * axisLogicalStride;
+      offset += coord * (strides[axis] ?? 0);
+    }
+    return offset;
+  };
+}
+function assertFiniteNumber(value, name, detail) {
+  if (!Number.isFinite(value)) {
+    throw new DataValidationError(
+      `${name} must contain only finite numbers; found ${String(value)} at ${detail}`
+    );
+  }
+}
+function assertVectorLike(t, name) {
+  if (t.ndim <= 1) return;
+  if (t.ndim === 2 && (t.shape[1] ?? 0) === 1) return;
+  throw new ShapeError(`${name} must be 1D or a column vector`);
+}
+function assertSameSizeVectors(a, b, nameA, nameB) {
+  if (a.size !== b.size) {
+    throw new ShapeError(
+      `${nameA} (size ${a.size}) and ${nameB} (size ${b.size}) must have same size`
+    );
+  }
+  assertVectorLike(a, nameA);
+  assertVectorLike(b, nameB);
+}
+function assertSameSize(a, b, nameA, nameB) {
+  if (a.size !== b.size) {
+    throw new ShapeError(
+      `${nameA} (size ${a.size}) and ${nameB} (size ${b.size}) must have same size`
+    );
+  }
+}
+
+// src/metrics/classification.ts
+function getNumericLabelData(t) {
+  if (t.dtype === "string") {
+    throw new DTypeError("metrics do not support string labels");
+  }
+  if (t.dtype === "int64") {
+    throw new DTypeError("metrics do not support int64 tensors");
+  }
+  const data = t.data;
+  if (!isTypedArray(data) || !isNumericTypedArray(data)) {
+    throw new DTypeError("metrics require numeric tensors");
+  }
+  return data;
+}
+function readNumericLabel(data, offsetter, index, name) {
+  const value = getNumericElement(data, offsetter(index));
+  assertFiniteNumber(value, name, `index ${index}`);
+  return value;
+}
+function ensureBinaryValue(value, name, index) {
+  if (value !== 0 && value !== 1) {
+    throw new InvalidParameterError(
+      `${name} must contain only binary values (0 or 1); found ${String(value)} at index ${index}`,
+      name,
+      value
+    );
+  }
+}
+function assertBinaryLabels(yTrue, yPred) {
+  if (yTrue.dtype === "string" || yPred.dtype === "string") {
+    throw new InvalidParameterError(
+      "classificationReport requires binary numeric labels (0 or 1)",
+      "yTrue"
+    );
+  }
+  const yTrueData = getNumericLabelData(yTrue);
+  const yPredData = getNumericLabelData(yPred);
+  const trueOffset = createFlatOffsetter(yTrue);
+  const predOffset = createFlatOffsetter(yPred);
+  for (let i = 0; i < yTrue.size; i++) {
+    const trueVal = readNumericLabel(yTrueData, trueOffset, i, "yTrue");
+    const predVal = readNumericLabel(yPredData, predOffset, i, "yPred");
+    ensureBinaryValue(trueVal, "yTrue", i);
+    ensureBinaryValue(predVal, "yPred", i);
+  }
+}
+function assertComparableLabelTypes(yTrue, yPred) {
+  const trueKind = yTrue.dtype === "string" ? "string" : yTrue.dtype === "int64" ? "int64" : "numeric";
+  const predKind = yPred.dtype === "string" ? "string" : yPred.dtype === "int64" ? "int64" : "numeric";
+  if (trueKind !== predKind) {
+    throw new DTypeError("yTrue and yPred must use compatible label types");
+  }
+  return trueKind;
+}
+function readComparableLabel(t, offsetter, index, name) {
+  const offset = offsetter(index);
+  const data = t.data;
+  if (Array.isArray(data)) {
+    return getStringElement(data, offset);
+  }
+  if (data instanceof BigInt64Array) {
+    return getBigIntElement(data, offset);
+  }
+  if (!isTypedArray(data) || !isNumericTypedArray(data)) {
+    throw new DTypeError(`${name} must be numeric or string labels`);
+  }
+  const value = getNumericElement(data, offset);
+  assertFiniteNumber(value, name, `index ${index}`);
+  return value;
+}
+function buildClassStats(yTrue, yPred) {
+  assertComparableLabelTypes(yTrue, yPred);
+  const trueOffset = createFlatOffsetter(yTrue);
+  const predOffset = createFlatOffsetter(yPred);
+  const stats = /* @__PURE__ */ new Map();
+  let totalTp = 0;
+  let totalFp = 0;
+  let totalFn = 0;
+  for (let i = 0; i < yTrue.size; i++) {
+    const trueVal = readComparableLabel(yTrue, trueOffset, i, "yTrue");
+    const predVal = readComparableLabel(yPred, predOffset, i, "yPred");
+    let trueStats = stats.get(trueVal);
+    if (!trueStats) {
+      trueStats = { tp: 0, fp: 0, fn: 0, support: 0 };
+      stats.set(trueVal, trueStats);
+    }
+    let predStats = stats.get(predVal);
+    if (!predStats) {
+      predStats = { tp: 0, fp: 0, fn: 0, support: 0 };
+      stats.set(predVal, predStats);
+    }
+    trueStats.support += 1;
+    if (trueVal === predVal) {
+      trueStats.tp += 1;
+      totalTp += 1;
+    } else {
+      predStats.fp += 1;
+      trueStats.fn += 1;
+      totalFp += 1;
+      totalFn += 1;
+    }
+  }
+  const classes = Array.from(stats.keys()).sort((a, b) => {
+    if (typeof a === "number" && typeof b === "number") return a - b;
+    if (typeof a === "string" && typeof b === "string") return a.localeCompare(b);
+    if (typeof a === "bigint" && typeof b === "bigint") return a === b ? 0 : a < b ? -1 : 1;
+    return String(a).localeCompare(String(b));
+  });
+  return { classes, stats, totalTp, totalFp, totalFn };
+}
+function accuracy(yTrue, yPred) {
+  assertSameSizeVectors(yTrue, yPred, "yTrue", "yPred");
+  if (yTrue.size === 0) return 0;
+  assertComparableLabelTypes(yTrue, yPred);
+  const trueOffset = createFlatOffsetter(yTrue);
+  const predOffset = createFlatOffsetter(yPred);
+  let correct = 0;
+  for (let i = 0; i < yTrue.size; i++) {
+    const trueVal = readComparableLabel(yTrue, trueOffset, i, "yTrue");
+    const predVal = readComparableLabel(yPred, predOffset, i, "yPred");
+    if (trueVal === predVal) {
+      correct++;
+    }
+  }
+  return correct / yTrue.size;
+}
+function precision(yTrue, yPred, average = "binary") {
+  assertSameSizeVectors(yTrue, yPred, "yTrue", "yPred");
+  if (yTrue.size === 0) return average === null ? [] : 0;
+  if (average === "binary") {
+    if (yTrue.dtype === "string" || yPred.dtype === "string") {
+      throw new InvalidParameterError(
+        "Binary average requires numeric labels (0/1). Use 'macro', 'micro', or 'weighted' for string labels."
+      );
+    }
+    const yTrueData = getNumericLabelData(yTrue);
+    const yPredData = getNumericLabelData(yPred);
+    const trueOffset = createFlatOffsetter(yTrue);
+    const predOffset = createFlatOffsetter(yPred);
+    let tp = 0;
+    let fp = 0;
+    for (let i = 0; i < yTrue.size; i++) {
+      const trueVal = readNumericLabel(yTrueData, trueOffset, i, "yTrue");
+      const predVal = readNumericLabel(yPredData, predOffset, i, "yPred");
+      ensureBinaryValue(trueVal, "yTrue", i);
+      ensureBinaryValue(predVal, "yPred", i);
+      if (predVal === 1) {
+        if (trueVal === 1) {
+          tp++;
+        } else {
+          fp++;
+        }
+      }
+    }
+    return tp + fp === 0 ? 0 : tp / (tp + fp);
+  }
+  const { classes, stats, totalTp, totalFp } = buildClassStats(yTrue, yPred);
+  const precisions = [];
+  const supports = [];
+  for (const cls of classes) {
+    const classStats = stats.get(cls);
+    const tp = classStats?.tp ?? 0;
+    const fp = classStats?.fp ?? 0;
+    const support = classStats?.support ?? 0;
+    precisions.push(tp + fp === 0 ? 0 : tp / (tp + fp));
+    supports.push(support);
+  }
+  if (average === null) {
+    return precisions;
+  }
+  if (average === "micro") {
+    return totalTp + totalFp === 0 ? 0 : totalTp / (totalTp + totalFp);
+  }
+  if (average === "macro") {
+    const sum = precisions.reduce((acc, val) => acc + val, 0);
+    return precisions.length === 0 ? 0 : sum / precisions.length;
+  }
+  if (average === "weighted") {
+    let weightedSum = 0;
+    let totalSupport = 0;
+    for (let i = 0; i < precisions.length; i++) {
+      weightedSum += (precisions[i] ?? 0) * (supports[i] ?? 0);
+      totalSupport += supports[i] ?? 0;
+    }
+    return totalSupport === 0 ? 0 : weightedSum / totalSupport;
+  }
+  throw new InvalidParameterError(
+    `Invalid average parameter: ${average}. Must be one of: 'binary', 'micro', 'macro', 'weighted', or null`,
+    "average",
+    average
+  );
+}
+function recall(yTrue, yPred, average = "binary") {
+  assertSameSizeVectors(yTrue, yPred, "yTrue", "yPred");
+  if (yTrue.size === 0) return average === null ? [] : 0;
+  if (average === "binary") {
+    if (yTrue.dtype === "string" || yPred.dtype === "string") {
+      throw new InvalidParameterError(
+        "Binary average requires numeric labels (0/1). Use 'macro', 'micro', or 'weighted' for string labels."
+      );
+    }
+    const yTrueData = getNumericLabelData(yTrue);
+    const yPredData = getNumericLabelData(yPred);
+    const trueOffset = createFlatOffsetter(yTrue);
+    const predOffset = createFlatOffsetter(yPred);
+    let tp = 0;
+    let fn = 0;
+    for (let i = 0; i < yTrue.size; i++) {
+      const trueVal = readNumericLabel(yTrueData, trueOffset, i, "yTrue");
+      const predVal = readNumericLabel(yPredData, predOffset, i, "yPred");
+      ensureBinaryValue(trueVal, "yTrue", i);
+      ensureBinaryValue(predVal, "yPred", i);
+      if (trueVal === 1) {
+        if (predVal === 1) {
+          tp++;
+        } else {
+          fn++;
+        }
+      }
+    }
+    return tp + fn === 0 ? 0 : tp / (tp + fn);
+  }
+  const { classes, stats, totalTp, totalFn } = buildClassStats(yTrue, yPred);
+  const recalls = [];
+  const supports = [];
+  for (const cls of classes) {
+    const classStats = stats.get(cls);
+    const tp = classStats?.tp ?? 0;
+    const fn = classStats?.fn ?? 0;
+    const support = classStats?.support ?? 0;
+    recalls.push(tp + fn === 0 ? 0 : tp / (tp + fn));
+    supports.push(support);
+  }
+  if (average === null) {
+    return recalls;
+  }
+  if (average === "micro") {
+    return totalTp + totalFn === 0 ? 0 : totalTp / (totalTp + totalFn);
+  }
+  if (average === "macro") {
+    const sum = recalls.reduce((acc, val) => acc + val, 0);
+    return recalls.length === 0 ? 0 : sum / recalls.length;
+  }
+  if (average === "weighted") {
+    let weightedSum = 0;
+    let totalSupport = 0;
+    for (let i = 0; i < recalls.length; i++) {
+      weightedSum += (recalls[i] ?? 0) * (supports[i] ?? 0);
+      totalSupport += supports[i] ?? 0;
+    }
+    return totalSupport === 0 ? 0 : weightedSum / totalSupport;
+  }
+  throw new InvalidParameterError(
+    `Invalid average parameter: ${average}. Must be one of: 'binary', 'micro', 'macro', 'weighted', or null`,
+    "average",
+    average
+  );
+}
+function f1Score(yTrue, yPred, average = "binary") {
+  if (average === "binary" || average === "micro") {
+    const p = precision(yTrue, yPred, average);
+    const r = recall(yTrue, yPred, average);
+    return p + r === 0 ? 0 : 2 * p * r / (p + r);
+  }
+  const prec = precision(yTrue, yPred, null);
+  const rec = recall(yTrue, yPred, null);
+  const f1Scores = [];
+  for (let i = 0; i < prec.length; i++) {
+    const p = prec[i] ?? 0;
+    const r = rec[i] ?? 0;
+    f1Scores.push(p + r === 0 ? 0 : 2 * p * r / (p + r));
+  }
+  if (average === null) {
+    return f1Scores;
+  }
+  if (f1Scores.length === 0) return 0;
+  if (average === "macro") {
+    const sum = f1Scores.reduce((acc, val) => acc + val, 0);
+    return sum / f1Scores.length;
+  }
+  if (average === "weighted") {
+    const { classes, stats } = buildClassStats(yTrue, yPred);
+    let weightedSum = 0;
+    let totalSupport = 0;
+    for (let i = 0; i < f1Scores.length; i++) {
+      const cls = classes[i];
+      const support = cls !== void 0 ? stats.get(cls)?.support ?? 0 : 0;
+      weightedSum += (f1Scores[i] ?? 0) * support;
+      totalSupport += support;
+    }
+    return totalSupport === 0 ? 0 : weightedSum / totalSupport;
+  }
+  throw new InvalidParameterError(
+    `Invalid average parameter: ${average}. Must be one of: 'binary', 'micro', 'macro', 'weighted', or null`,
+    "average",
+    average
+  );
+}
+function fbetaScore(yTrue, yPred, beta, average = "binary") {
+  if (!Number.isFinite(beta) || beta <= 0) {
+    throw new InvalidParameterError("beta must be a positive finite number", "beta", beta);
+  }
+  const betaSq = beta * beta;
+  if (average === "binary" || average === "micro") {
+    const p = precision(yTrue, yPred, average);
+    const r = recall(yTrue, yPred, average);
+    return p + r === 0 ? 0 : (1 + betaSq) * p * r / (betaSq * p + r);
+  }
+  const prec = precision(yTrue, yPred, null);
+  const rec = recall(yTrue, yPred, null);
+  const fbetaScores = [];
+  for (let i = 0; i < prec.length; i++) {
+    const p = prec[i] ?? 0;
+    const r = rec[i] ?? 0;
+    fbetaScores.push(p + r === 0 ? 0 : (1 + betaSq) * p * r / (betaSq * p + r));
+  }
+  if (average === null) {
+    return fbetaScores;
+  }
+  if (fbetaScores.length === 0) return 0;
+  if (average === "macro") {
+    const sum = fbetaScores.reduce((acc, val) => acc + val, 0);
+    return sum / fbetaScores.length;
+  }
+  if (average === "weighted") {
+    const { classes, stats } = buildClassStats(yTrue, yPred);
+    let weightedSum = 0;
+    let totalSupport = 0;
+    for (let i = 0; i < fbetaScores.length; i++) {
+      const cls = classes[i];
+      const support = cls !== void 0 ? stats.get(cls)?.support ?? 0 : 0;
+      weightedSum += (fbetaScores[i] ?? 0) * support;
+      totalSupport += support;
+    }
+    return totalSupport === 0 ? 0 : weightedSum / totalSupport;
+  }
+  throw new InvalidParameterError(
+    `Invalid average parameter: ${average}. Must be one of: 'binary', 'micro', 'macro', 'weighted', or null`,
+    "average",
+    average
+  );
+}
+function confusionMatrix(yTrue, yPred) {
+  assertSameSizeVectors(yTrue, yPred, "yTrue", "yPred");
+  assertComparableLabelTypes(yTrue, yPred);
+  if (yTrue.size === 0) {
+    return tensor([]).reshape([0, 0]);
+  }
+  const trueOffset = createFlatOffsetter(yTrue);
+  const predOffset = createFlatOffsetter(yPred);
+  const labelSet = /* @__PURE__ */ new Set();
+  for (let i = 0; i < yTrue.size; i++) {
+    labelSet.add(readComparableLabel(yTrue, trueOffset, i, "yTrue"));
+    labelSet.add(readComparableLabel(yPred, predOffset, i, "yPred"));
+  }
+  const labels = Array.from(labelSet).sort((a, b) => {
+    if (typeof a === "number" && typeof b === "number") return a - b;
+    if (typeof a === "string" && typeof b === "string") return a.localeCompare(b);
+    if (typeof a === "bigint" && typeof b === "bigint") return a === b ? 0 : a < b ? -1 : 1;
+    return String(a).localeCompare(String(b));
+  });
+  const labelToIndex = /* @__PURE__ */ new Map();
+  for (let i = 0; i < labels.length; i++) {
+    const label = labels[i];
+    if (label === void 0) continue;
+    labelToIndex.set(label, i);
+  }
+  const nClasses = labels.length;
+  const matrix = Array.from({ length: nClasses }, () => new Array(nClasses).fill(0));
+  for (let i = 0; i < yTrue.size; i++) {
+    const trueLabel = readComparableLabel(yTrue, trueOffset, i, "yTrue");
+    const predLabel = readComparableLabel(yPred, predOffset, i, "yPred");
+    const r = labelToIndex.get(trueLabel);
+    const c = labelToIndex.get(predLabel);
+    if (r === void 0 || c === void 0) continue;
+    const row = matrix[r];
+    if (row) row[c] = (row[c] ?? 0) + 1;
+  }
+  return tensor(matrix);
+}
+function classificationReport(yTrue, yPred) {
+  assertSameSizeVectors(yTrue, yPred, "yTrue", "yPred");
+  if (yTrue.size === 0) return "Classification Report:\n  (empty)";
+  assertBinaryLabels(yTrue, yPred);
+  const { classes, stats } = buildClassStats(yTrue, yPred);
+  const precs = precision(yTrue, yPred, null);
+  const recs = recall(yTrue, yPred, null);
+  const f1s = f1Score(yTrue, yPred, null);
+  const acc = accuracy(yTrue, yPred);
+  const maxClassLen = Math.max(...classes.map((c) => String(c).length), "Class".length);
+  const colWidth = Math.max(12, maxClassLen + 2);
+  let report = "Classification Report:\n";
+  report += "Class".padEnd(colWidth) + "Precision".padEnd(12) + "Recall".padEnd(12) + "F1-Score".padEnd(12) + "Support\n";
+  report += `${"-".repeat(colWidth + 36 + 7)}
+`;
+  let totalSupport = 0;
+  let weightedPrec = 0;
+  let weightedRec = 0;
+  let weightedF1 = 0;
+  let macroPrec = 0;
+  let macroRec = 0;
+  let macroF1 = 0;
+  for (const [i, cls] of classes.entries()) {
+    const p = precs[i] ?? 0;
+    const r = recs[i] ?? 0;
+    const f1 = f1s[i] ?? 0;
+    const s = stats.get(cls)?.support ?? 0;
+    totalSupport += s;
+    weightedPrec += p * s;
+    weightedRec += r * s;
+    weightedF1 += f1 * s;
+    macroPrec += p;
+    macroRec += r;
+    macroF1 += f1;
+    report += String(cls).padEnd(colWidth) + p.toFixed(4).padEnd(12) + r.toFixed(4).padEnd(12) + f1.toFixed(4).padEnd(12) + String(s) + "\n";
+  }
+  report += "\n";
+  const nClasses = classes.length;
+  if (nClasses > 0) {
+    macroPrec /= nClasses;
+    macroRec /= nClasses;
+    macroF1 /= nClasses;
+  } else {
+    macroPrec = 0;
+    macroRec = 0;
+    macroF1 = 0;
+  }
+  weightedPrec = totalSupport === 0 ? 0 : weightedPrec / totalSupport;
+  weightedRec = totalSupport === 0 ? 0 : weightedRec / totalSupport;
+  weightedF1 = totalSupport === 0 ? 0 : weightedF1 / totalSupport;
+  report += "Accuracy".padEnd(colWidth) + "".padEnd(12) + "".padEnd(12) + acc.toFixed(4).padEnd(12) + String(totalSupport) + "\n";
+  report += "Macro Avg".padEnd(colWidth) + macroPrec.toFixed(4).padEnd(12) + macroRec.toFixed(4).padEnd(12) + macroF1.toFixed(4).padEnd(12) + String(totalSupport) + "\n";
+  report += "Weighted Avg".padEnd(colWidth) + weightedPrec.toFixed(4).padEnd(12) + weightedRec.toFixed(4).padEnd(12) + weightedF1.toFixed(4).padEnd(12) + String(totalSupport);
+  return report;
+}
+function rocCurve(yTrue, yScore) {
+  assertSameSizeVectors(yTrue, yScore, "yTrue", "yScore");
+  const n = yTrue.size;
+  if (n === 0) return [tensor([]), tensor([]), tensor([])];
+  const yTrueData = getNumericLabelData(yTrue);
+  const yScoreData = getNumericLabelData(yScore);
+  const trueOffset = createFlatOffsetter(yTrue);
+  const scoreOffset = createFlatOffsetter(yScore);
+  const pairs = [];
+  let nPos = 0;
+  let nNeg = 0;
+  for (let i = 0; i < n; i++) {
+    const label = readNumericLabel(yTrueData, trueOffset, i, "yTrue");
+    ensureBinaryValue(label, "yTrue", i);
+    const score = readNumericLabel(yScoreData, scoreOffset, i, "yScore");
+    pairs.push({ score, label });
+    if (label === 1) nPos++;
+    else nNeg++;
+  }
+  pairs.sort((a, b) => b.score - a.score);
+  if (nPos === 0 || nNeg === 0) return [tensor([]), tensor([]), tensor([])];
+  const fpr = [0];
+  const tpr = [0];
+  const thresholds = [Infinity];
+  let tp = 0;
+  let fp = 0;
+  let idx = 0;
+  while (idx < pairs.length) {
+    const threshold = pairs[idx]?.score ?? 0;
+    while (idx < pairs.length && (pairs[idx]?.score ?? 0) === threshold) {
+      const label = pairs[idx]?.label ?? 0;
+      if (label === 1) tp++;
+      else fp++;
+      idx++;
+    }
+    fpr.push(fp / nNeg);
+    tpr.push(tp / nPos);
+    thresholds.push(threshold);
+  }
+  return [tensor(fpr), tensor(tpr), tensor(thresholds)];
+}
+function rocAucScore(yTrue, yScore) {
+  const curves = rocCurve(yTrue, yScore);
+  const fprT = curves[0];
+  const tprT = curves[1];
+  if (!fprT || !tprT || fprT.size === 0 || tprT.size === 0) return 0.5;
+  const fprData = getNumericLabelData(fprT);
+  const tprData = getNumericLabelData(tprT);
+  const fprOffset = createFlatOffsetter(fprT);
+  const tprOffset = createFlatOffsetter(tprT);
+  let auc = 0;
+  let prevX = 0;
+  let prevY = 0;
+  for (let i = 1; i < fprT.size; i++) {
+    const x = readNumericLabel(fprData, fprOffset, i, "fpr");
+    const y = readNumericLabel(tprData, tprOffset, i, "tpr");
+    auc += (x - prevX) * ((y + prevY) / 2);
+    prevX = x;
+    prevY = y;
+  }
+  return auc;
+}
+function precisionRecallCurve(yTrue, yScore) {
+  assertSameSizeVectors(yTrue, yScore, "yTrue", "yScore");
+  const n = yTrue.size;
+  if (n === 0) return [tensor([]), tensor([]), tensor([])];
+  const yTrueData = getNumericLabelData(yTrue);
+  const yScoreData = getNumericLabelData(yScore);
+  const trueOffset = createFlatOffsetter(yTrue);
+  const scoreOffset = createFlatOffsetter(yScore);
+  const pairs = [];
+  let nPos = 0;
+  for (let i = 0; i < n; i++) {
+    const label = readNumericLabel(yTrueData, trueOffset, i, "yTrue");
+    ensureBinaryValue(label, "yTrue", i);
+    const score = readNumericLabel(yScoreData, scoreOffset, i, "yScore");
+    pairs.push({ score, label });
+    if (label === 1) nPos++;
+  }
+  pairs.sort((a, b) => b.score - a.score);
+  if (nPos === 0) return [tensor([]), tensor([]), tensor([])];
+  const prec = [1];
+  const rec = [0];
+  const thresholds = [Infinity];
+  let tp = 0;
+  let fp = 0;
+  let idx = 0;
+  while (idx < pairs.length) {
+    const threshold = pairs[idx]?.score ?? 0;
+    while (idx < pairs.length && (pairs[idx]?.score ?? 0) === threshold) {
+      const label = pairs[idx]?.label ?? 0;
+      if (label === 1) tp++;
+      else fp++;
+      idx++;
+    }
+    const precisionVal = tp + fp === 0 ? 1 : tp / (tp + fp);
+    const recallVal = tp / nPos;
+    prec.push(precisionVal);
+    rec.push(recallVal);
+    thresholds.push(threshold);
+  }
+  return [tensor(prec), tensor(rec), tensor(thresholds)];
+}
+function averagePrecisionScore(yTrue, yScore) {
+  const curves = precisionRecallCurve(yTrue, yScore);
+  const precT = curves[0];
+  const recT = curves[1];
+  if (!precT || !recT || precT.size === 0 || recT.size === 0) return 0;
+  const precData = getNumericLabelData(precT);
+  const recData = getNumericLabelData(recT);
+  const precOffset = createFlatOffsetter(precT);
+  const recOffset = createFlatOffsetter(recT);
+  let ap = 0;
+  let prevRecall = readNumericLabel(recData, recOffset, 0, "recall");
+  for (let i = 1; i < recT.size; i++) {
+    const recall2 = readNumericLabel(recData, recOffset, i, "recall");
+    const precision2 = readNumericLabel(precData, precOffset, i, "precision");
+    const deltaRecall = recall2 - prevRecall;
+    if (deltaRecall > 0) {
+      ap += deltaRecall * precision2;
+    }
+    prevRecall = recall2;
+  }
+  return ap;
+}
+function logLoss(yTrue, yPred) {
+  assertSameSizeVectors(yTrue, yPred, "yTrue", "yPred");
+  if (yTrue.size === 0) return 0;
+  const yTrueData = getNumericLabelData(yTrue);
+  const yPredData = getNumericLabelData(yPred);
+  const trueOffset = createFlatOffsetter(yTrue);
+  const predOffset = createFlatOffsetter(yPred);
+  const eps = 1e-15;
+  let loss = 0;
+  for (let i = 0; i < yTrue.size; i++) {
+    const trueVal = readNumericLabel(yTrueData, trueOffset, i, "yTrue");
+    ensureBinaryValue(trueVal, "yTrue", i);
+    const predRaw = readNumericLabel(yPredData, predOffset, i, "yPred");
+    if (predRaw < 0 || predRaw > 1) {
+      throw new InvalidParameterError(
+        `yPred must contain probabilities in range [0, 1], found ${String(predRaw)} at index ${i}`,
+        "yPred",
+        predRaw
+      );
+    }
+    const predVal = Math.max(eps, Math.min(1 - eps, predRaw));
+    loss -= trueVal * Math.log(predVal) + (1 - trueVal) * Math.log(1 - predVal);
+  }
+  return loss / yTrue.size;
+}
+function hammingLoss(yTrue, yPred) {
+  assertSameSizeVectors(yTrue, yPred, "yTrue", "yPred");
+  if (yTrue.size === 0) return 0;
+  assertComparableLabelTypes(yTrue, yPred);
+  const trueOffset = createFlatOffsetter(yTrue);
+  const predOffset = createFlatOffsetter(yPred);
+  let errors = 0;
+  for (let i = 0; i < yTrue.size; i++) {
+    const trueVal = readComparableLabel(yTrue, trueOffset, i, "yTrue");
+    const predVal = readComparableLabel(yPred, predOffset, i, "yPred");
+    if (trueVal !== predVal) {
+      errors++;
+    }
+  }
+  return errors / yTrue.size;
+}
+function jaccardScore(yTrue, yPred) {
+  assertSameSizeVectors(yTrue, yPred, "yTrue", "yPred");
+  if (yTrue.size === 0) return 1;
+  const yTrueData = getNumericLabelData(yTrue);
+  const yPredData = getNumericLabelData(yPred);
+  const trueOffset = createFlatOffsetter(yTrue);
+  const predOffset = createFlatOffsetter(yPred);
+  let tp = 0, fp = 0, fn = 0;
+  for (let i = 0; i < yTrue.size; i++) {
+    const trueVal = readNumericLabel(yTrueData, trueOffset, i, "yTrue");
+    const predVal = readNumericLabel(yPredData, predOffset, i, "yPred");
+    ensureBinaryValue(trueVal, "yTrue", i);
+    ensureBinaryValue(predVal, "yPred", i);
+    if (trueVal === 1 && predVal === 1) tp++;
+    else if (trueVal === 0 && predVal === 1) fp++;
+    else if (trueVal === 1 && predVal === 0) fn++;
+  }
+  return tp + fp + fn === 0 ? 1 : tp / (tp + fp + fn);
+}
+function matthewsCorrcoef(yTrue, yPred) {
+  assertSameSizeVectors(yTrue, yPred, "yTrue", "yPred");
+  if (yTrue.size === 0) return 0;
+  const yTrueData = getNumericLabelData(yTrue);
+  const yPredData = getNumericLabelData(yPred);
+  const trueOffset = createFlatOffsetter(yTrue);
+  const predOffset = createFlatOffsetter(yPred);
+  let tp = 0, tn = 0, fp = 0, fn = 0;
+  for (let i = 0; i < yTrue.size; i++) {
+    const trueVal = readNumericLabel(yTrueData, trueOffset, i, "yTrue");
+    const predVal = readNumericLabel(yPredData, predOffset, i, "yPred");
+    ensureBinaryValue(trueVal, "yTrue", i);
+    ensureBinaryValue(predVal, "yPred", i);
+    if (trueVal === 1 && predVal === 1) tp++;
+    else if (trueVal === 0 && predVal === 0) tn++;
+    else if (trueVal === 0 && predVal === 1) fp++;
+    else if (trueVal === 1 && predVal === 0) fn++;
+  }
+  const numerator = tp * tn - fp * fn;
+  const denominator = Math.sqrt((tp + fp) * (tp + fn) * (tn + fp) * (tn + fn));
+  return denominator === 0 ? 0 : numerator / denominator;
+}
+function cohenKappaScore(yTrue, yPred) {
+  assertSameSizeVectors(yTrue, yPred, "yTrue", "yPred");
+  const n = yTrue.size;
+  if (n === 0) return 0;
+  const yTrueData = getNumericLabelData(yTrue);
+  const yPredData = getNumericLabelData(yPred);
+  const trueOffset = createFlatOffsetter(yTrue);
+  const predOffset = createFlatOffsetter(yPred);
+  let po = 0;
+  const trueCount = /* @__PURE__ */ new Map();
+  const predCount = /* @__PURE__ */ new Map();
+  for (let i = 0; i < n; i++) {
+    const t = readNumericLabel(yTrueData, trueOffset, i, "yTrue");
+    const p = readNumericLabel(yPredData, predOffset, i, "yPred");
+    if (t === p) {
+      po++;
+    }
+    trueCount.set(t, (trueCount.get(t) ?? 0) + 1);
+    predCount.set(p, (predCount.get(p) ?? 0) + 1);
+  }
+  po /= n;
+  let pe = 0;
+  const allClasses = /* @__PURE__ */ new Set([...trueCount.keys(), ...predCount.keys()]);
+  for (const c of allClasses) {
+    const trueProb = (trueCount.get(c) ?? 0) / n;
+    const predProb = (predCount.get(c) ?? 0) / n;
+    pe += trueProb * predProb;
+  }
+  const denom = 1 - pe;
+  if (denom === 0) return po === 1 ? 1 : 0;
+  return (po - pe) / denom;
+}
+function balancedAccuracyScore(yTrue, yPred) {
+  assertSameSizeVectors(yTrue, yPred, "yTrue", "yPred");
+  if (yTrue.size === 0) return 0;
+  const { classes, stats } = buildClassStats(yTrue, yPred);
+  let sumRecall = 0;
+  let classCount = 0;
+  for (const cls of classes) {
+    const classStats = stats.get(cls);
+    const support = classStats?.support ?? 0;
+    if (support === 0) continue;
+    const tp = classStats?.tp ?? 0;
+    const fn = classStats?.fn ?? 0;
+    const recall2 = tp + fn > 0 ? tp / (tp + fn) : 0;
+    sumRecall += recall2;
+    classCount++;
+  }
+  return classCount === 0 ? 0 : sumRecall / classCount;
+}
+
+// src/metrics/clustering.ts
+function isBigIntTypedArray(x) {
+  return x instanceof BigInt64Array || x instanceof BigUint64Array;
+}
+function readIndex(arr, index, name) {
+  const v = arr[index];
+  if (v === void 0) {
+    throw new DataValidationError(`${name} index out of range: ${index}`);
+  }
+  return v;
+}
+function getNumericTensorData(t, name) {
+  if (t.dtype === "string") {
+    throw new DTypeError(`${name} must be numeric (string tensors not supported)`);
+  }
+  if (t.dtype === "int64") {
+    throw new DTypeError(`${name} must be numeric (int64 tensors not supported)`);
+  }
+  const data = t.data;
+  if (!isTypedArray(data) || !isNumericTypedArray(data)) {
+    throw new DTypeError(`${name} must be a numeric tensor`);
+  }
+  return data;
+}
+function getFeatureAccessor(X) {
+  const data = getNumericTensorData(X, "X");
+  if (X.ndim === 0 || X.ndim > 2) {
+    throw new ShapeError("X must be a 1D or 2D tensor");
+  }
+  const nSamples = X.shape[0] ?? 0;
+  const nFeatures = X.ndim === 1 ? 1 : X.shape[1] ?? 0;
+  if (nFeatures === 0) {
+    throw new ShapeError("X must have at least one feature");
+  }
+  const logicalStrides = computeLogicalStrides(X.shape);
+  const logical0 = logicalStrides[0];
+  if (logical0 === void 0) throw new ShapeError("Invalid logical strides");
+  const sampleStride = X.strides[0] ?? logical0 ?? nFeatures;
+  const featureStride = X.ndim === 1 ? 0 : X.strides[1] ?? logicalStrides[1] ?? 1;
+  if (X.ndim === 2 && featureStride === 0) {
+    throw new ShapeError("X must have a non-degenerate feature stride");
+  }
+  return {
+    data,
+    nSamples,
+    nFeatures,
+    sampleStride,
+    featureStride,
+    offset: X.offset
+  };
+}
+function readLabelValue(labels, offsetter, index, name) {
+  const data = labels.data;
+  const flat = offsetter(index);
+  if (isBigIntTypedArray(data)) {
+    const v = data[flat];
+    if (v === void 0) {
+      throw new DataValidationError(`${name} must contain a value for index ${index}`);
+    }
+    return v;
+  }
+  if (isTypedArray(data) && isNumericTypedArray(data)) {
+    const v = getNumericElement(data, flat);
+    assertFiniteNumber(v, name, `index ${index}`);
+    if ((labels.dtype === "float32" || labels.dtype === "float64") && !Number.isInteger(v)) {
+      throw new DataValidationError(
+        `${name} must contain discrete labels; found non-integer ${String(v)} at index ${index}`
+      );
+    }
+    if (labels.dtype === "int64" && (!Number.isInteger(v) || !Number.isSafeInteger(v))) {
+      throw new DataValidationError(
+        `${name} contains an int64 value that cannot be represented safely as a number at index ${index}`
+      );
+    }
+    return v;
+  }
+  if (Array.isArray(data)) {
+    const v = data[flat];
+    if (v === void 0 || v === null) {
+      throw new DataValidationError(`${name} must contain a value for index ${index}`);
+    }
+    if (typeof v === "string") return v;
+    if (typeof v === "boolean") return v;
+    if (typeof v === "number") {
+      assertFiniteNumber(v, name, `index ${index}`);
+      if ((labels.dtype === "float32" || labels.dtype === "float64") && !Number.isInteger(v)) {
+        throw new DataValidationError(
+          `${name} must contain discrete labels; found non-integer ${String(v)} at index ${index}`
+        );
+      }
+      if (labels.dtype === "int64" && (!Number.isInteger(v) || !Number.isSafeInteger(v))) {
+        throw new DataValidationError(
+          `${name} contains an int64 value that cannot be represented safely as a number at index ${index}`
+        );
+      }
+      return v;
+    }
+    throw new DTypeError(`${name} must contain primitive labels (string, boolean, number, bigint)`);
+  }
+  throw new DTypeError(`${name} has unsupported backing storage for labels`);
+}
+function encodeLabels(labels, name) {
+  if (labels.dtype === "string") {
+    throw new DTypeError(`${name}: string labels not supported for clustering metrics`);
+  }
+  const n = labels.size;
+  const codes = new Int32Array(n);
+  const offsetter = createFlatOffsetter(labels);
+  const map = /* @__PURE__ */ new Map();
+  let next = 0;
+  for (let i = 0; i < n; i++) {
+    const raw = readLabelValue(labels, offsetter, i, name);
+    const existing = map.get(raw);
+    if (existing === void 0) {
+      map.set(raw, next);
+      codes[i] = next;
+      next++;
+    } else {
+      codes[i] = existing;
+    }
+  }
+  return { codes, nClusters: next };
+}
+function comb2(x) {
+  return x <= 1 ? 0 : x * (x - 1) / 2;
+}
+function buildContingencyStats(labelsTrue, labelsPred) {
+  assertSameSize(labelsTrue, labelsPred, "labelsTrue", "labelsPred");
+  const n = labelsTrue.size;
+  const encT = encodeLabels(labelsTrue, "labelsTrue");
+  const encP = encodeLabels(labelsPred, "labelsPred");
+  const trueCodes = encT.codes;
+  const predCodes = encP.codes;
+  const nTrue = encT.nClusters;
+  const nPred = encP.nClusters;
+  const trueCount = new Int32Array(nTrue);
+  const predCount = new Int32Array(nPred);
+  for (let i = 0; i < n; i++) {
+    const t = readIndex(trueCodes, i, "trueCodes");
+    const p = readIndex(predCodes, i, "predCodes");
+    trueCount[t] = (trueCount[t] ?? 0) + 1;
+    predCount[p] = (predCount[p] ?? 0) + 1;
+  }
+  const denseSize = nTrue * nPred;
+  const maxDenseCells = 4e6;
+  if (denseSize > 0 && denseSize <= maxDenseCells) {
+    const contingency2 = new Int32Array(denseSize);
+    for (let i = 0; i < n; i++) {
+      const t = readIndex(trueCodes, i, "trueCodes");
+      const p = readIndex(predCodes, i, "predCodes");
+      const idx = t * nPred + p;
+      contingency2[idx] = (contingency2[idx] ?? 0) + 1;
+    }
+    return {
+      contingencyDense: contingency2,
+      contingencySparse: null,
+      trueCount,
+      predCount,
+      nTrue,
+      nPred,
+      n
+    };
+  }
+  const contingency = /* @__PURE__ */ new Map();
+  for (let i = 0; i < n; i++) {
+    const t = readIndex(trueCodes, i, "trueCodes");
+    const p = readIndex(predCodes, i, "predCodes");
+    const key = t * nPred + p;
+    contingency.set(key, (contingency.get(key) ?? 0) + 1);
+  }
+  return {
+    contingencyDense: null,
+    contingencySparse: contingency,
+    trueCount,
+    predCount,
+    nTrue,
+    nPred,
+    n
+  };
+}
+function entropyFromCountArray(counts, n) {
+  if (n === 0) return 0;
+  let h = 0;
+  for (let i = 0; i < counts.length; i++) {
+    const c = readIndex(counts, i, "counts");
+    if (c > 0) {
+      const p = c / n;
+      h -= p * Math.log(p);
+    }
+  }
+  return h;
+}
+function mutualInformationFromContingency(stats) {
+  const { contingencyDense, contingencySparse, trueCount, predCount, nPred, n } = stats;
+  if (n === 0) return 0;
+  let mi = 0;
+  if (contingencyDense) {
+    for (let idx = 0; idx < contingencyDense.length; idx++) {
+      const nij = readIndex(contingencyDense, idx, "contingencyDense");
+      if (nij <= 0) continue;
+      const t = Math.floor(idx / nPred);
+      const p = idx - t * nPred;
+      const ni = readIndex(trueCount, t, "trueCount");
+      const nj = readIndex(predCount, p, "predCount");
+      if (ni > 0 && nj > 0) {
+        mi += nij / n * Math.log(n * nij / (ni * nj));
+      }
+    }
+    return mi;
+  }
+  if (contingencySparse) {
+    for (const [key, nij] of contingencySparse) {
+      if (nij <= 0) continue;
+      const t = Math.floor(key / nPred);
+      const p = key - t * nPred;
+      const ni = readIndex(trueCount, t, "trueCount");
+      const nj = readIndex(predCount, p, "predCount");
+      if (ni > 0 && nj > 0) {
+        mi += nij / n * Math.log(n * nij / (ni * nj));
+      }
+    }
+    return mi;
+  }
+  return 0;
+}
+function buildLogFactorials(n) {
+  const out = new Float64Array(n + 1);
+  for (let i = 1; i <= n; i++) {
+    out[i] = (out[i - 1] ?? 0) + Math.log(i);
+  }
+  return out;
+}
+function logCombination(n, k, logFactorials) {
+  if (k < 0 || k > n) return Number.NEGATIVE_INFINITY;
+  const a = readIndex(logFactorials, n, "logFactorials");
+  const b = readIndex(logFactorials, k, "logFactorials");
+  const c = readIndex(logFactorials, n - k, "logFactorials");
+  return a - b - c;
+}
+var LOG_EXP_UNDERFLOW_CUTOFF = -745;
+function expectedMutualInformation(stats) {
+  const { trueCount, predCount, n } = stats;
+  if (n <= 1) return 0;
+  const rowSums = Array.from(trueCount);
+  const colSums = Array.from(predCount);
+  const logFactorials = buildLogFactorials(n);
+  let emi = 0;
+  let comp = 0;
+  for (const a of rowSums) {
+    if (a <= 0) continue;
+    for (const b of colSums) {
+      if (b <= 0) continue;
+      const nijMin = Math.max(1, a + b - n);
+      const nijMax = Math.min(a, b);
+      if (nijMin > nijMax) continue;
+      const logDenominator = logCombination(n, b, logFactorials);
+      for (let nij = nijMin; nij <= nijMax; nij++) {
+        const logProbability = logCombination(a, nij, logFactorials) + logCombination(n - a, b - nij, logFactorials) - logDenominator;
+        if (logProbability < LOG_EXP_UNDERFLOW_CUTOFF) continue;
+        const probability = Math.exp(logProbability);
+        if (!Number.isFinite(probability) || probability === 0) continue;
+        const miTerm = nij / n * Math.log(n * nij / (a * b));
+        const y = probability * miTerm - comp;
+        const t = emi + y;
+        comp = t - emi - y;
+        emi = t;
+      }
+    }
+  }
+  return emi;
+}
+function averageEntropy(hTrue, hPred, method) {
+  if (method === "min") return Math.min(hTrue, hPred);
+  if (method === "max") return Math.max(hTrue, hPred);
+  if (method === "geometric") return Math.sqrt(hTrue * hPred);
+  return (hTrue + hPred) / 2;
+}
+function euclideanDistance(data, offset, sampleStride, featureStride, nFeatures, i, j) {
+  let sum = 0;
+  const baseI = offset + i * sampleStride;
+  const baseJ = offset + j * sampleStride;
+  for (let k = 0; k < nFeatures; k++) {
+    const vi = getNumericElement(data, baseI + k * featureStride);
+    const vj = getNumericElement(data, baseJ + k * featureStride);
+    assertFiniteNumber(vi, "X", `sample ${i}, feature ${k}`);
+    assertFiniteNumber(vj, "X", `sample ${j}, feature ${k}`);
+    const d = vi - vj;
+    sum += d * d;
+  }
+  return Math.sqrt(sum);
+}
+function getPrecomputedDistanceAccessor(X, n) {
+  const data = getNumericTensorData(X, "X");
+  if (X.ndim !== 2) {
+    throw new ShapeError("X must be a 2D tensor for metric='precomputed'");
+  }
+  const rows = X.shape[0] ?? 0;
+  const cols = X.shape[1] ?? 0;
+  if (rows !== n || cols !== n) {
+    throw new ShapeError(
+      "For metric='precomputed', X must be a square [n_samples, n_samples] matrix"
+    );
+  }
+  const logicalStrides = computeLogicalStrides(X.shape);
+  const rowStride = X.strides[0] ?? logicalStrides[0] ?? n;
+  const colStride = X.strides[1] ?? logicalStrides[1] ?? 1;
+  if (rowStride === 0 || colStride === 0) {
+    throw new ShapeError("Precomputed distance matrix must have non-degenerate strides");
+  }
+  const base = X.offset;
+  return (i, j) => {
+    const v = getNumericElement(data, base + i * rowStride + j * colStride);
+    assertFiniteNumber(v, "X", `distance[${i},${j}]`);
+    if (v < 0) {
+      throw new DataValidationError(
+        `Precomputed distances must be non-negative; found ${String(v)} at [${i},${j}]`
+      );
+    }
+    return v;
+  };
+}
+function validateSilhouetteLabels(labels, nSamples) {
+  if (labels.size !== nSamples) {
+    throw new ShapeError("labels length must match number of samples");
+  }
+  const enc = encodeLabels(labels, "labels");
+  const k = enc.nClusters;
+  if (k < 2 || k > nSamples - 1) {
+    throw new InvalidParameterError(
+      "silhouette requires 2 <= n_clusters <= n_samples - 1",
+      "n_clusters",
+      k
+    );
+  }
+  return enc;
+}
+function reservoirSampleIndices(n, k, seed) {
+  let state = (seed ?? 0) >>> 0;
+  const hasSeed = seed !== void 0;
+  const randU32 = () => {
+    if (!hasSeed) return Math.random() * 4294967296 >>> 0;
+    state = 1664525 * state + 1013904223 >>> 0;
+    return state;
+  };
+  const randInt = (exclusiveMax) => randU32() % exclusiveMax;
+  const out = new Int32Array(k);
+  for (let i = 0; i < k; i++) out[i] = i;
+  for (let i = k; i < n; i++) {
+    const j = randInt(i + 1);
+    if (j < k) out[j] = i;
+  }
+  return out;
+}
+function reencodeSubset(codes) {
+  const out = new Int32Array(codes.length);
+  const map = /* @__PURE__ */ new Map();
+  let next = 0;
+  for (let i = 0; i < codes.length; i++) {
+    const v = readIndex(codes, i, "codes");
+    const existing = map.get(v);
+    if (existing === void 0) {
+      map.set(v, next);
+      out[i] = next;
+      next++;
+    } else {
+      out[i] = existing;
+    }
+  }
+  return { codes: out, nClusters: next };
+}
+function silhouetteMeanEuclidean(X, labels, indices) {
+  const { data, nSamples, nFeatures, sampleStride, featureStride, offset } = getFeatureAccessor(X);
+  const n = indices ? indices.length : nSamples;
+  if (nSamples < 2 || n < 2) {
+    throw new InvalidParameterError("silhouette requires at least 2 samples", "n_samples", n);
+  }
+  const encAll = validateSilhouetteLabels(labels, nSamples);
+  const subsetCodesRaw = new Int32Array(n);
+  for (let i = 0; i < n; i++) {
+    const src = indices ? readIndex(indices, i, "indices") : i;
+    const c = readIndex(encAll.codes, src, "labels.codes");
+    subsetCodesRaw[i] = c;
+  }
+  const re = reencodeSubset(subsetCodesRaw);
+  const codes = re.codes;
+  const k = re.nClusters;
+  if (k < 2 || k > n - 1) {
+    throw new InvalidParameterError(
+      "silhouette requires 2 <= n_clusters <= n_samples - 1",
+      "n_clusters",
+      k
+    );
+  }
+  const clusterSizes = new Int32Array(k);
+  for (let i = 0; i < n; i++) {
+    const ci = readIndex(codes, i, "codes");
+    clusterSizes[ci] = (clusterSizes[ci] ?? 0) + 1;
+  }
+  const sumsToClusters = new Float64Array(k);
+  let sum = 0;
+  let comp = 0;
+  for (let i = 0; i < n; i++) {
+    const ci = readIndex(codes, i, "codes");
+    const sizeOwn = readIndex(clusterSizes, ci, "clusterSizes");
+    if (sizeOwn <= 1) continue;
+    sumsToClusters.fill(0);
+    const srcI = indices ? readIndex(indices, i, "indices") : i;
+    for (let j = 0; j < n; j++) {
+      if (i === j) continue;
+      const srcJ = indices ? readIndex(indices, j, "indices") : j;
+      const cj = readIndex(codes, j, "codes");
+      const d = euclideanDistance(data, offset, sampleStride, featureStride, nFeatures, srcI, srcJ);
+      sumsToClusters[cj] = (sumsToClusters[cj] ?? 0) + d;
+    }
+    const a = readIndex(sumsToClusters, ci, "sumsToClusters") / (sizeOwn - 1);
+    let b = Infinity;
+    for (let cl = 0; cl < k; cl++) {
+      if (cl === ci) continue;
+      const sz = readIndex(clusterSizes, cl, "clusterSizes");
+      if (sz <= 0) continue;
+      const mean = readIndex(sumsToClusters, cl, "sumsToClusters") / sz;
+      if (mean < b) b = mean;
+    }
+    if (!Number.isFinite(b) || b === Infinity) continue;
+    const denom = Math.max(a, b);
+    const s = denom > 0 ? (b - a) / denom : 0;
+    const y = s - comp;
+    const t = sum + y;
+    comp = t - sum - y;
+    sum = t;
+  }
+  return sum / n;
+}
+function silhouetteMeanPrecomputed(X, labels, indices) {
+  const nSamples = labels.size;
+  if (nSamples < 2) {
+    throw new InvalidParameterError(
+      "silhouette requires at least 2 samples",
+      "n_samples",
+      nSamples
+    );
+  }
+  const encAll = validateSilhouetteLabels(labels, nSamples);
+  const dist = getPrecomputedDistanceAccessor(X, nSamples);
+  const n = indices ? indices.length : nSamples;
+  if (n < 2) {
+    throw new InvalidParameterError("silhouette requires at least 2 samples", "n_samples", n);
+  }
+  for (let i = 0; i < n; i++) {
+    const src = indices ? readIndex(indices, i, "indices") : i;
+    const d0 = dist(src, src);
+    if (!Number.isFinite(d0) || Math.abs(d0) > 1e-12) {
+      throw new DataValidationError(
+        `Precomputed distance matrix diagonal must be ~0; found ${String(d0)} at [${src},${src}]`
+      );
+    }
+  }
+  const subsetCodesRaw = new Int32Array(n);
+  for (let i = 0; i < n; i++) {
+    const src = indices ? readIndex(indices, i, "indices") : i;
+    const c = readIndex(encAll.codes, src, "labels.codes");
+    subsetCodesRaw[i] = c;
+  }
+  const re = reencodeSubset(subsetCodesRaw);
+  const codes = re.codes;
+  const k = re.nClusters;
+  if (k < 2 || k > n - 1) {
+    throw new InvalidParameterError(
+      "silhouette requires 2 <= n_clusters <= n_samples - 1",
+      "n_clusters",
+      k
+    );
+  }
+  const clusterSizes = new Int32Array(k);
+  for (let i = 0; i < n; i++) {
+    const ci = readIndex(codes, i, "codes");
+    clusterSizes[ci] = (clusterSizes[ci] ?? 0) + 1;
+  }
+  const sumsToClusters = new Float64Array(k);
+  let sum = 0;
+  let comp = 0;
+  for (let i = 0; i < n; i++) {
+    const ci = readIndex(codes, i, "codes");
+    const sizeOwn = readIndex(clusterSizes, ci, "clusterSizes");
+    if (sizeOwn <= 1) continue;
+    sumsToClusters.fill(0);
+    const srcI = indices ? readIndex(indices, i, "indices") : i;
+    for (let j = 0; j < n; j++) {
+      if (i === j) continue;
+      const srcJ = indices ? readIndex(indices, j, "indices") : j;
+      const cj = readIndex(codes, j, "codes");
+      const d = dist(srcI, srcJ);
+      sumsToClusters[cj] = (sumsToClusters[cj] ?? 0) + d;
+    }
+    const a = readIndex(sumsToClusters, ci, "sumsToClusters") / (sizeOwn - 1);
+    let b = Infinity;
+    for (let cl = 0; cl < k; cl++) {
+      if (cl === ci) continue;
+      const sz = readIndex(clusterSizes, cl, "clusterSizes");
+      if (sz <= 0) continue;
+      const mean = readIndex(sumsToClusters, cl, "sumsToClusters") / sz;
+      if (mean < b) b = mean;
+    }
+    if (!Number.isFinite(b) || b === Infinity) continue;
+    const denom = Math.max(a, b);
+    const s = denom > 0 ? (b - a) / denom : 0;
+    const y = s - comp;
+    const t = sum + y;
+    comp = t - sum - y;
+    sum = t;
+  }
+  return sum / n;
+}
+function silhouetteScore(X, labels, metric = "euclidean", options) {
+  const sampleSize = options?.sampleSize;
+  const randomState = options?.randomState;
+  const nSamples = labels.size;
+  if (nSamples < 2) {
+    throw new InvalidParameterError(
+      "silhouette requires at least 2 samples",
+      "n_samples",
+      nSamples
+    );
+  }
+  const maxFull = 2e3;
+  if (sampleSize === void 0 && nSamples > maxFull) {
+    throw new InvalidParameterError(
+      `silhouetteScore is O(n\xB2) and n_samples=${nSamples} is too large for full computation; provide options.sampleSize`,
+      "sampleSize",
+      sampleSize
+    );
+  }
+  if (sampleSize !== void 0) {
+    if (!Number.isFinite(sampleSize) || !Number.isInteger(sampleSize)) {
+      throw new InvalidParameterError("sampleSize must be an integer", "sampleSize", sampleSize);
+    }
+    if (sampleSize < 2 || sampleSize > nSamples) {
+      throw new InvalidParameterError(
+        "sampleSize must satisfy 2 <= sampleSize <= n_samples",
+        "sampleSize",
+        sampleSize
+      );
+    }
+  }
+  const indices = sampleSize !== void 0 && sampleSize < nSamples ? reservoirSampleIndices(nSamples, sampleSize, randomState) : null;
+  if (metric === "euclidean") return silhouetteMeanEuclidean(X, labels, indices);
+  if (metric === "precomputed") return silhouetteMeanPrecomputed(X, labels, indices);
+  throw new InvalidParameterError(
+    `Unsupported metric: '${String(metric)}'. Must be 'euclidean' or 'precomputed'`,
+    "metric",
+    metric
+  );
+}
+function silhouetteSamples(X, labels, metric = "euclidean") {
+  const nSamples = labels.size;
+  if (nSamples < 2) {
+    throw new InvalidParameterError(
+      "silhouette requires at least 2 samples",
+      "n_samples",
+      nSamples
+    );
+  }
+  const enc = validateSilhouetteLabels(labels, nSamples);
+  const codes = enc.codes;
+  const k = enc.nClusters;
+  const silhouettes = new Float64Array(nSamples);
+  const clusterSizes = new Int32Array(k);
+  for (let i = 0; i < nSamples; i++) {
+    const ci = readIndex(codes, i, "codes");
+    clusterSizes[ci] = (clusterSizes[ci] ?? 0) + 1;
+  }
+  const sumsToClusters = new Float64Array(k);
+  if (metric === "euclidean") {
+    const { data, nFeatures, sampleStride, featureStride, offset } = getFeatureAccessor(X);
+    for (let i = 0; i < nSamples; i++) {
+      const ci = readIndex(codes, i, "codes");
+      const sizeOwn = readIndex(clusterSizes, ci, "clusterSizes");
+      if (sizeOwn <= 1) {
+        silhouettes[i] = 0;
+        continue;
+      }
+      sumsToClusters.fill(0);
+      for (let j = 0; j < nSamples; j++) {
+        if (i === j) continue;
+        const cj = readIndex(codes, j, "codes");
+        const d = euclideanDistance(data, offset, sampleStride, featureStride, nFeatures, i, j);
+        sumsToClusters[cj] = (sumsToClusters[cj] ?? 0) + d;
+      }
+      const a = readIndex(sumsToClusters, ci, "sumsToClusters") / (sizeOwn - 1);
+      let b = Infinity;
+      for (let cl = 0; cl < k; cl++) {
+        if (cl === ci) continue;
+        const sz = readIndex(clusterSizes, cl, "clusterSizes");
+        if (sz <= 0) continue;
+        const mean = readIndex(sumsToClusters, cl, "sumsToClusters") / sz;
+        if (mean < b) b = mean;
+      }
+      if (!Number.isFinite(b) || b === Infinity) {
+        silhouettes[i] = 0;
+        continue;
+      }
+      const denom = Math.max(a, b);
+      silhouettes[i] = denom > 0 ? (b - a) / denom : 0;
+    }
+    return tensor(silhouettes);
+  }
+  if (metric === "precomputed") {
+    const dist = getPrecomputedDistanceAccessor(X, nSamples);
+    for (let i = 0; i < nSamples; i++) {
+      const d0 = dist(i, i);
+      if (!Number.isFinite(d0) || Math.abs(d0) > 1e-12) {
+        throw new DataValidationError(
+          `Precomputed distance matrix diagonal must be ~0; found ${String(d0)} at [${i},${i}]`
+        );
+      }
+    }
+    for (let i = 0; i < nSamples; i++) {
+      const ci = readIndex(codes, i, "codes");
+      const sizeOwn = readIndex(clusterSizes, ci, "clusterSizes");
+      if (sizeOwn <= 1) {
+        silhouettes[i] = 0;
+        continue;
+      }
+      sumsToClusters.fill(0);
+      for (let j = 0; j < nSamples; j++) {
+        if (i === j) continue;
+        const cj = readIndex(codes, j, "codes");
+        const d = dist(i, j);
+        sumsToClusters[cj] = (sumsToClusters[cj] ?? 0) + d;
+      }
+      const a = readIndex(sumsToClusters, ci, "sumsToClusters") / (sizeOwn - 1);
+      let b = Infinity;
+      for (let cl = 0; cl < k; cl++) {
+        if (cl === ci) continue;
+        const sz = readIndex(clusterSizes, cl, "clusterSizes");
+        if (sz <= 0) continue;
+        const mean = readIndex(sumsToClusters, cl, "sumsToClusters") / sz;
+        if (mean < b) b = mean;
+      }
+      if (!Number.isFinite(b) || b === Infinity) {
+        silhouettes[i] = 0;
+        continue;
+      }
+      const denom = Math.max(a, b);
+      silhouettes[i] = denom > 0 ? (b - a) / denom : 0;
+    }
+    return tensor(silhouettes);
+  }
+  throw new InvalidParameterError(
+    `Unsupported metric: '${String(metric)}'. Must be 'euclidean' or 'precomputed'`,
+    "metric",
+    metric
+  );
+}
+function daviesBouldinScore(X, labels) {
+  const { data, nSamples, nFeatures, sampleStride, featureStride, offset } = getFeatureAccessor(X);
+  if (nSamples === 0) return 0;
+  if (labels.size !== nSamples) {
+    throw new ShapeError("labels length must match number of samples");
+  }
+  const enc = encodeLabels(labels, "labels");
+  const codes = enc.codes;
+  const k = enc.nClusters;
+  if (k < 2) return 0;
+  const centroids = new Array(k);
+  for (let c = 0; c < k; c++) centroids[c] = new Float64Array(nFeatures);
+  const clusterSizes = new Int32Array(k);
+  for (let i = 0; i < nSamples; i++) {
+    const c = readIndex(codes, i, "codes");
+    clusterSizes[c] = (clusterSizes[c] ?? 0) + 1;
+    const base = offset + i * sampleStride;
+    const centroid = readIndex(centroids, c, "centroids");
+    for (let f = 0; f < nFeatures; f++) {
+      const v = getNumericElement(data, base + f * featureStride);
+      assertFiniteNumber(v, "X", `sample ${i}, feature ${f}`);
+      centroid[f] = (centroid[f] ?? 0) + v;
+    }
+  }
+  for (let c = 0; c < k; c++) {
+    const sz = readIndex(clusterSizes, c, "clusterSizes");
+    if (sz <= 0) continue;
+    const centroid = readIndex(centroids, c, "centroids");
+    for (let f = 0; f < nFeatures; f++) {
+      centroid[f] = (centroid[f] ?? 0) / sz;
+    }
+  }
+  const scatterSum = new Float64Array(k);
+  for (let i = 0; i < nSamples; i++) {
+    const c = readIndex(codes, i, "codes");
+    const centroid = readIndex(centroids, c, "centroids");
+    let distSq = 0;
+    const base = offset + i * sampleStride;
+    for (let f = 0; f < nFeatures; f++) {
+      const v = getNumericElement(data, base + f * featureStride);
+      assertFiniteNumber(v, "X", `sample ${i}, feature ${f}`);
+      const d = v - (centroid[f] ?? 0);
+      distSq += d * d;
+    }
+    scatterSum[c] = (scatterSum[c] ?? 0) + Math.sqrt(distSq);
+  }
+  const S = new Float64Array(k);
+  for (let c = 0; c < k; c++) {
+    const sz = readIndex(clusterSizes, c, "clusterSizes");
+    const sc = readIndex(scatterSum, c, "scatterSum");
+    S[c] = sz > 0 ? sc / sz : 0;
+  }
+  let db = 0;
+  for (let i = 0; i < k; i++) {
+    let maxRatio = Number.NEGATIVE_INFINITY;
+    const ci = readIndex(centroids, i, "centroids");
+    for (let j = 0; j < k; j++) {
+      if (i === j) continue;
+      const cj = readIndex(centroids, j, "centroids");
+      let distSq = 0;
+      for (let f = 0; f < nFeatures; f++) {
+        const d = (ci[f] ?? 0) - (cj[f] ?? 0);
+        distSq += d * d;
+      }
+      const dist = Math.sqrt(distSq);
+      const si = readIndex(S, i, "S");
+      const sj = readIndex(S, j, "S");
+      const ratio = dist === 0 ? Number.POSITIVE_INFINITY : (si + sj) / dist;
+      if (ratio > maxRatio) maxRatio = ratio;
+    }
+    db += maxRatio;
+  }
+  return db / k;
+}
+function calinskiHarabaszScore(X, labels) {
+  const { data, nSamples, nFeatures, sampleStride, featureStride, offset } = getFeatureAccessor(X);
+  if (nSamples === 0) return 0;
+  if (labels.size !== nSamples) {
+    throw new ShapeError("labels length must match number of samples");
+  }
+  const enc = encodeLabels(labels, "labels");
+  const codes = enc.codes;
+  const k = enc.nClusters;
+  const overallMean = new Float64Array(nFeatures);
+  for (let i = 0; i < nSamples; i++) {
+    const base = offset + i * sampleStride;
+    for (let f = 0; f < nFeatures; f++) {
+      const v = getNumericElement(data, base + f * featureStride);
+      assertFiniteNumber(v, "X", `sample ${i}, feature ${f}`);
+      overallMean[f] = (overallMean[f] ?? 0) + v;
+    }
+  }
+  for (let f = 0; f < nFeatures; f++) {
+    overallMean[f] = (overallMean[f] ?? 0) / nSamples;
+  }
+  const centroids = new Array(k);
+  for (let c = 0; c < k; c++) centroids[c] = new Float64Array(nFeatures);
+  const clusterSizes = new Int32Array(k);
+  for (let i = 0; i < nSamples; i++) {
+    const c = readIndex(codes, i, "codes");
+    clusterSizes[c] = (clusterSizes[c] ?? 0) + 1;
+    const base = offset + i * sampleStride;
+    const centroid = readIndex(centroids, c, "centroids");
+    for (let f = 0; f < nFeatures; f++) {
+      const v = getNumericElement(data, base + f * featureStride);
+      assertFiniteNumber(v, "X", `sample ${i}, feature ${f}`);
+      centroid[f] = (centroid[f] ?? 0) + v;
+    }
+  }
+  for (let c = 0; c < k; c++) {
+    const sz = readIndex(clusterSizes, c, "clusterSizes");
+    if (sz <= 0) continue;
+    const centroid = readIndex(centroids, c, "centroids");
+    for (let f = 0; f < nFeatures; f++) {
+      centroid[f] = (centroid[f] ?? 0) / sz;
+    }
+  }
+  let bgss = 0;
+  for (let c = 0; c < k; c++) {
+    const sz = readIndex(clusterSizes, c, "clusterSizes");
+    if (sz <= 0) continue;
+    const centroid = readIndex(centroids, c, "centroids");
+    let distSq = 0;
+    for (let f = 0; f < nFeatures; f++) {
+      const d = (centroid[f] ?? 0) - (overallMean[f] ?? 0);
+      distSq += d * d;
+    }
+    bgss += sz * distSq;
+  }
+  let wgss = 0;
+  for (let i = 0; i < nSamples; i++) {
+    const c = readIndex(codes, i, "codes");
+    const centroid = readIndex(centroids, c, "centroids");
+    const base = offset + i * sampleStride;
+    for (let f = 0; f < nFeatures; f++) {
+      const v = getNumericElement(data, base + f * featureStride);
+      assertFiniteNumber(v, "X", `sample ${i}, feature ${f}`);
+      const d = v - (centroid[f] ?? 0);
+      wgss += d * d;
+    }
+  }
+  if (k < 2 || wgss === 0) return 0;
+  return bgss / (k - 1) / (wgss / (nSamples - k));
+}
+function adjustedRandScore(labelsTrue, labelsPred) {
+  assertSameSize(labelsTrue, labelsPred, "labelsTrue", "labelsPred");
+  const n = labelsTrue.size;
+  if (n <= 1) return 1;
+  const stats = buildContingencyStats(labelsTrue, labelsPred);
+  const { contingencyDense, contingencySparse, trueCount, predCount } = stats;
+  let sumComb = 0;
+  if (contingencyDense) {
+    for (let idx = 0; idx < contingencyDense.length; idx++) {
+      const nij = readIndex(contingencyDense, idx, "contingencyDense");
+      if (nij > 0) sumComb += comb2(nij);
+    }
+  } else if (contingencySparse) {
+    for (const nij of contingencySparse.values()) {
+      sumComb += comb2(nij);
+    }
+  }
+  let sumCombTrue = 0;
+  for (let i = 0; i < trueCount.length; i++) {
+    sumCombTrue += comb2(readIndex(trueCount, i, "trueCount"));
+  }
+  let sumCombPred = 0;
+  for (let j = 0; j < predCount.length; j++) {
+    sumCombPred += comb2(readIndex(predCount, j, "predCount"));
+  }
+  const totalPairs = comb2(n);
+  if (totalPairs === 0) return 1;
+  const expectedIndex = sumCombTrue * sumCombPred / totalPairs;
+  const maxIndex = (sumCombTrue + sumCombPred) / 2;
+  const denom = maxIndex - expectedIndex;
+  if (denom === 0) return 1;
+  return (sumComb - expectedIndex) / denom;
+}
+function adjustedMutualInfoScore(labelsTrue, labelsPred, averageMethod = "arithmetic") {
+  const stats = buildContingencyStats(labelsTrue, labelsPred);
+  const { n, trueCount, predCount } = stats;
+  if (n <= 1) return 1;
+  const mi = mutualInformationFromContingency(stats);
+  const hTrue = entropyFromCountArray(trueCount, n);
+  const hPred = entropyFromCountArray(predCount, n);
+  const emi = expectedMutualInformation(stats);
+  const normalizer = averageEntropy(hTrue, hPred, averageMethod);
+  if (Math.abs(normalizer) < 1e-15) return 1;
+  const denom = normalizer - emi;
+  if (Math.abs(denom) < 1e-15) return 0;
+  const ami = (mi - emi) / denom;
+  if (!Number.isFinite(ami)) return 0;
+  if (ami > 1) return 1;
+  if (ami < -1) return -1;
+  return ami;
+}
+function normalizedMutualInfoScore(labelsTrue, labelsPred, averageMethod = "arithmetic") {
+  const stats = buildContingencyStats(labelsTrue, labelsPred);
+  const { n, trueCount, predCount } = stats;
+  const mi = mutualInformationFromContingency(stats);
+  const ht = entropyFromCountArray(trueCount, n);
+  const hp = entropyFromCountArray(predCount, n);
+  if (ht === 0 || hp === 0) {
+    return ht === 0 && hp === 0 ? 1 : 0;
+  }
+  const normalizer = averageEntropy(ht, hp, averageMethod);
+  if (normalizer === 0) return 0;
+  const nmi = mi / normalizer;
+  if (nmi > 1) return 1;
+  if (nmi < 0) return 0;
+  return nmi;
+}
+function fowlkesMallowsScore(labelsTrue, labelsPred) {
+  const stats = buildContingencyStats(labelsTrue, labelsPred);
+  const { contingencyDense, contingencySparse, trueCount, predCount, n } = stats;
+  if (n === 0) return 1;
+  let tk = 0;
+  if (contingencyDense) {
+    for (let idx = 0; idx < contingencyDense.length; idx++) {
+      const nij = readIndex(contingencyDense, idx, "contingencyDense");
+      if (nij > 0) tk += comb2(nij);
+    }
+  } else if (contingencySparse) {
+    for (const nij of contingencySparse.values()) {
+      tk += comb2(nij);
+    }
+  }
+  let pk = 0;
+  for (let i = 0; i < trueCount.length; i++) pk += comb2(readIndex(trueCount, i, "trueCount"));
+  let qk = 0;
+  for (let j = 0; j < predCount.length; j++) qk += comb2(readIndex(predCount, j, "predCount"));
+  if (pk === 0 || qk === 0) return 0;
+  return tk / Math.sqrt(pk * qk);
+}
+function homogeneityScore(labelsTrue, labelsPred) {
+  const stats = buildContingencyStats(labelsTrue, labelsPred);
+  const { contingencyDense, contingencySparse, predCount, trueCount, nPred, n } = stats;
+  if (n === 0) return 1;
+  let hck = 0;
+  if (contingencyDense) {
+    for (let idx = 0; idx < contingencyDense.length; idx++) {
+      const nij = readIndex(contingencyDense, idx, "contingencyDense");
+      if (nij <= 0) continue;
+      const p = idx - Math.floor(idx / nPred) * nPred;
+      const nj = readIndex(predCount, p, "predCount");
+      if (nj > 0) hck -= nij / n * Math.log(nij / nj);
+    }
+  } else if (contingencySparse) {
+    for (const [key, nij] of contingencySparse) {
+      if (nij <= 0) continue;
+      const p = key - Math.floor(key / nPred) * nPred;
+      const nj = readIndex(predCount, p, "predCount");
+      if (nj > 0) hck -= nij / n * Math.log(nij / nj);
+    }
+  }
+  const hc = entropyFromCountArray(trueCount, n);
+  return hc === 0 ? 1 : 1 - hck / hc;
+}
+function completenessScore(labelsTrue, labelsPred) {
+  const stats = buildContingencyStats(labelsTrue, labelsPred);
+  const { contingencyDense, contingencySparse, trueCount, predCount, nPred, n } = stats;
+  if (n === 0) return 1;
+  let hkc = 0;
+  if (contingencyDense) {
+    for (let idx = 0; idx < contingencyDense.length; idx++) {
+      const nij = readIndex(contingencyDense, idx, "contingencyDense");
+      if (nij <= 0) continue;
+      const t = Math.floor(idx / nPred);
+      const ni = readIndex(trueCount, t, "trueCount");
+      if (ni > 0) hkc -= nij / n * Math.log(nij / ni);
+    }
+  } else if (contingencySparse) {
+    for (const [key, nij] of contingencySparse) {
+      if (nij <= 0) continue;
+      const t = Math.floor(key / nPred);
+      const ni = readIndex(trueCount, t, "trueCount");
+      if (ni > 0) hkc -= nij / n * Math.log(nij / ni);
+    }
+  }
+  const hk = entropyFromCountArray(predCount, n);
+  return hk === 0 ? 1 : 1 - hkc / hk;
+}
+function vMeasureScore(labelsTrue, labelsPred, beta = 1) {
+  if (!Number.isFinite(beta) || beta <= 0) {
+    throw new InvalidParameterError("beta must be a positive finite number", "beta", beta);
+  }
+  const h = homogeneityScore(labelsTrue, labelsPred);
+  const c = completenessScore(labelsTrue, labelsPred);
+  if (h + c === 0) return 0;
+  return (1 + beta) * h * c / (beta * h + c);
+}
+
+// src/metrics/regression.ts
+function getNumericRegressionData(t, name) {
+  if (t.dtype === "string") {
+    throw new DTypeError(`${name} must be numeric tensors`);
+  }
+  if (t.dtype === "int64") {
+    throw new DTypeError(`${name} must be numeric tensors (int64 not supported)`);
+  }
+  const data = t.data;
+  if (!isTypedArray(data) || !isNumericTypedArray(data)) {
+    throw new DTypeError(`${name} must be numeric tensors`);
+  }
+  return data;
+}
+function readNumeric(data, offsetter, index, name) {
+  const value = getNumericElement(data, offsetter(index));
+  assertFiniteNumber(value, name, `index ${index}`);
+  return value;
+}
+function mse(yTrue, yPred) {
+  assertSameSizeVectors(yTrue, yPred, "yTrue", "yPred");
+  const yTrueData = getNumericRegressionData(yTrue, "yTrue");
+  const yPredData = getNumericRegressionData(yPred, "yPred");
+  if (yTrue.size === 0) return 0;
+  const trueOffset = createFlatOffsetter(yTrue);
+  const predOffset = createFlatOffsetter(yPred);
+  let sumSquaredError = 0;
+  for (let i = 0; i < yTrue.size; i++) {
+    const diff = readNumeric(yTrueData, trueOffset, i, "yTrue") - readNumeric(yPredData, predOffset, i, "yPred");
+    sumSquaredError += diff * diff;
+  }
+  return sumSquaredError / yTrue.size;
+}
+function rmse(yTrue, yPred) {
+  return Math.sqrt(mse(yTrue, yPred));
+}
+function mae(yTrue, yPred) {
+  assertSameSizeVectors(yTrue, yPred, "yTrue", "yPred");
+  const yTrueData = getNumericRegressionData(yTrue, "yTrue");
+  const yPredData = getNumericRegressionData(yPred, "yPred");
+  if (yTrue.size === 0) return 0;
+  const trueOffset = createFlatOffsetter(yTrue);
+  const predOffset = createFlatOffsetter(yPred);
+  let sumAbsError = 0;
+  for (let i = 0; i < yTrue.size; i++) {
+    const diff = readNumeric(yTrueData, trueOffset, i, "yTrue") - readNumeric(yPredData, predOffset, i, "yPred");
+    sumAbsError += Math.abs(diff);
+  }
+  return sumAbsError / yTrue.size;
+}
+function r2Score(yTrue, yPred) {
+  assertSameSizeVectors(yTrue, yPred, "yTrue", "yPred");
+  const yTrueData = getNumericRegressionData(yTrue, "yTrue");
+  const yPredData = getNumericRegressionData(yPred, "yPred");
+  if (yTrue.size === 0) {
+    throw new InvalidParameterError("r2Score requires at least one sample", "yTrue", yTrue.size);
+  }
+  const trueOffset = createFlatOffsetter(yTrue);
+  const predOffset = createFlatOffsetter(yPred);
+  let sumTrue = 0;
+  for (let i = 0; i < yTrue.size; i++) {
+    sumTrue += readNumeric(yTrueData, trueOffset, i, "yTrue");
+  }
+  const mean = sumTrue / yTrue.size;
+  let ssRes = 0;
+  let ssTot = 0;
+  for (let i = 0; i < yTrue.size; i++) {
+    const trueVal = readNumeric(yTrueData, trueOffset, i, "yTrue");
+    const predVal = readNumeric(yPredData, predOffset, i, "yPred");
+    ssRes += (trueVal - predVal) ** 2;
+    ssTot += (trueVal - mean) ** 2;
+  }
+  if (ssTot === 0) {
+    return ssRes === 0 ? 1 : 0;
+  }
+  return 1 - ssRes / ssTot;
+}
+function adjustedR2Score(yTrue, yPred, nFeatures) {
+  if (!Number.isFinite(nFeatures) || !Number.isInteger(nFeatures) || nFeatures < 0) {
+    throw new InvalidParameterError(
+      "nFeatures must be a non-negative integer",
+      "nFeatures",
+      nFeatures
+    );
+  }
+  assertSameSizeVectors(yTrue, yPred, "yTrue", "yPred");
+  const n = yTrue.size;
+  const p = nFeatures;
+  if (n <= p + 1) {
+    throw new InvalidParameterError(
+      `Adjusted R\xB2 requires n > p + 1 (samples > features + 1). Got n=${n}, p=${p}`,
+      "nFeatures",
+      nFeatures
+    );
+  }
+  const r2 = r2Score(yTrue, yPred);
+  return 1 - (1 - r2) * (n - 1) / (n - p - 1);
+}
+function mape(yTrue, yPred) {
+  assertSameSizeVectors(yTrue, yPred, "yTrue", "yPred");
+  const yTrueData = getNumericRegressionData(yTrue, "yTrue");
+  const yPredData = getNumericRegressionData(yPred, "yPred");
+  if (yTrue.size === 0) return 0;
+  const trueOffset = createFlatOffsetter(yTrue);
+  const predOffset = createFlatOffsetter(yPred);
+  let sumPercentError = 0;
+  let nonZeroCount = 0;
+  for (let i = 0; i < yTrue.size; i++) {
+    const trueVal = readNumeric(yTrueData, trueOffset, i, "yTrue");
+    const predVal = readNumeric(yPredData, predOffset, i, "yPred");
+    if (trueVal !== 0) {
+      sumPercentError += Math.abs((trueVal - predVal) / trueVal);
+      nonZeroCount++;
+    }
+  }
+  if (nonZeroCount === 0) {
+    return 0;
+  }
+  return sumPercentError / nonZeroCount * 100;
+}
+function medianAbsoluteError(yTrue, yPred) {
+  assertSameSizeVectors(yTrue, yPred, "yTrue", "yPred");
+  const yTrueData = getNumericRegressionData(yTrue, "yTrue");
+  const yPredData = getNumericRegressionData(yPred, "yPred");
+  if (yTrue.size === 0) return 0;
+  const trueOffset = createFlatOffsetter(yTrue);
+  const predOffset = createFlatOffsetter(yPred);
+  const errors = [];
+  for (let i = 0; i < yTrue.size; i++) {
+    const diff = Math.abs(
+      readNumeric(yTrueData, trueOffset, i, "yTrue") - readNumeric(yPredData, predOffset, i, "yPred")
+    );
+    errors.push(diff);
+  }
+  errors.sort((a, b) => a - b);
+  const mid = Math.floor(errors.length / 2);
+  return errors.length % 2 !== 0 ? errors[mid] ?? 0 : ((errors[mid - 1] ?? 0) + (errors[mid] ?? 0)) / 2;
+}
+function maxError(yTrue, yPred) {
+  assertSameSizeVectors(yTrue, yPred, "yTrue", "yPred");
+  const yTrueData = getNumericRegressionData(yTrue, "yTrue");
+  const yPredData = getNumericRegressionData(yPred, "yPred");
+  const trueOffset = createFlatOffsetter(yTrue);
+  const predOffset = createFlatOffsetter(yPred);
+  let maxErr = 0;
+  for (let i = 0; i < yTrue.size; i++) {
+    const diff = Math.abs(
+      readNumeric(yTrueData, trueOffset, i, "yTrue") - readNumeric(yPredData, predOffset, i, "yPred")
+    );
+    maxErr = Math.max(maxErr, diff);
+  }
+  return maxErr;
+}
+function explainedVarianceScore(yTrue, yPred) {
+  assertSameSizeVectors(yTrue, yPred, "yTrue", "yPred");
+  const yTrueData = getNumericRegressionData(yTrue, "yTrue");
+  const yPredData = getNumericRegressionData(yPred, "yPred");
+  if (yTrue.size === 0) {
+    throw new InvalidParameterError(
+      "explainedVarianceScore requires at least one sample",
+      "yTrue",
+      yTrue.size
+    );
+  }
+  const trueOffset = createFlatOffsetter(yTrue);
+  const predOffset = createFlatOffsetter(yPred);
+  let sumTrue = 0;
+  let sumResidual = 0;
+  for (let i = 0; i < yTrue.size; i++) {
+    const trueVal = readNumeric(yTrueData, trueOffset, i, "yTrue");
+    const predVal = readNumeric(yPredData, predOffset, i, "yPred");
+    sumTrue += trueVal;
+    sumResidual += trueVal - predVal;
+  }
+  const meanTrue = sumTrue / yTrue.size;
+  const meanResidual = sumResidual / yTrue.size;
+  let varResidual = 0;
+  let varTrue = 0;
+  for (let i = 0; i < yTrue.size; i++) {
+    const trueVal = readNumeric(yTrueData, trueOffset, i, "yTrue");
+    const predVal = readNumeric(yPredData, predOffset, i, "yPred");
+    const residual = trueVal - predVal;
+    varResidual += (residual - meanResidual) ** 2;
+    varTrue += (trueVal - meanTrue) ** 2;
+  }
+  if (varTrue === 0) {
+    return varResidual === 0 ? 1 : 0;
+  }
+  return 1 - varResidual / varTrue;
+}
+
+export { accuracy, adjustedMutualInfoScore, adjustedR2Score, adjustedRandScore, averagePrecisionScore, balancedAccuracyScore, calinskiHarabaszScore, classificationReport, cohenKappaScore, completenessScore, confusionMatrix, daviesBouldinScore, explainedVarianceScore, f1Score, fbetaScore, fowlkesMallowsScore, hammingLoss, homogeneityScore, jaccardScore, logLoss, mae, mape, matthewsCorrcoef, maxError, medianAbsoluteError, metrics_exports, mse, normalizedMutualInfoScore, precision, precisionRecallCurve, r2Score, recall, rmse, rocAucScore, rocCurve, silhouetteSamples, silhouetteScore, vMeasureScore };
+//# sourceMappingURL=chunk-FJYLIGJX.js.map
+//# sourceMappingURL=chunk-FJYLIGJX.js.map