bun-scikit 0.1.1

package/scripts/install-native.ts

@@ -0,0 +1,160 @@
+import { access, mkdir, readFile, writeFile } from "node:fs/promises";
+import { constants } from "node:fs";
+import { resolve } from "node:path";
+
+interface PackageJson {
+  version: string;
+  repository?: {
+    url?: string;
+  };
+}
+
+function mapOs(value: NodeJS.Platform): "windows" | "linux" | null {
+  if (value === "win32") {
+    return "windows";
+  }
+  if (value === "linux") {
+    return "linux";
+  }
+  return null;
+}
+
+function mapArch(value: string): "x64" | "arm64" | null {
+  if (value === "x64") {
+    return "x64";
+  }
+  if (value === "arm64") {
+    return "arm64";
+  }
+  return null;
+}
+
+function kernelExtension(osName: "windows" | "linux"): string {
+  return osName === "windows" ? "dll" : "so";
+}
+
+function parseRepositorySlug(url: string | undefined): string | null {
+  if (!url) {
+    return null;
+  }
+  const normalized = url.replace("git+", "").replace(/\.git$/, "");
+  const match = normalized.match(/github\.com\/([^/]+\/[^/]+)/i);
+  return match?.[1] ?? null;
+}
+
+async function fileExists(path: string): Promise<boolean> {
+  try {
+    await access(path, constants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function downloadToFile(url: string, path: string): Promise<boolean> {
+  const response = await fetch(url);
+  if (!response.ok) {
+    return false;
+  }
+  const bytes = await response.arrayBuffer();
+  await writeFile(path, Buffer.from(bytes));
+  return true;
+}
+
+async function tryDownloadPrebuilt(): Promise<boolean> {
+  const packageJsonRaw = await readFile(resolve("package.json"), "utf-8");
+  const packageJson = JSON.parse(packageJsonRaw) as PackageJson;
+
+  const osName = mapOs(process.platform);
+  const arch = mapArch(process.arch);
+  if (!osName || !arch) {
+    console.log(
+      `[bun-scikit] prebuilt binaries are unavailable for platform=${process.platform} arch=${process.arch}`,
+    );
+    return false;
+  }
+
+  const repoSlug = parseRepositorySlug(packageJson.repository?.url) ?? "Seyamalam/bun-scikit";
+  const version = packageJson.version;
+  const ext = kernelExtension(osName);
+  const tag = `v${version}`;
+  const base =
+    `https://github.com/${repoSlug}/releases/download/${tag}`;
+
+  const kernelName = `bun_scikit_kernels-v${version}-${osName}-${arch}.${ext}`;
+  const addonName = `bun_scikit_node_addon-v${version}-${osName}-${arch}.node`;
+  const kernelUrl = `${base}/${kernelName}`;
+  const addonUrl = `${base}/${addonName}`;
+
+  const outDir = resolve("dist", "native");
+  await mkdir(outDir, { recursive: true });
+  const kernelPath = resolve(outDir, `bun_scikit_kernels.${ext}`);
+  const addonPath = resolve(outDir, "bun_scikit_node_addon.node");
+
+  const [kernelOk, addonOk] = await Promise.all([
+    downloadToFile(kernelUrl, kernelPath),
+    downloadToFile(addonUrl, addonPath),
+  ]);
+
+  if (kernelOk && addonOk) {
+    console.log(`[bun-scikit] downloaded native prebuilt artifacts for ${osName}-${arch}`);
+    return true;
+  }
+
+  return false;
+}
+
+async function tryLocalBuild(): Promise<void> {
+  console.log("[bun-scikit] prebuilt binaries not found; attempting local native build");
+  {
+    const child = Bun.spawn(["bun", "run", "native:build"], {
+      stdout: "inherit",
+      stderr: "inherit",
+    });
+    const code = await child.exited;
+    if (code !== 0) {
+      throw new Error(`native:build failed with exit code ${code}`);
+    }
+  }
+
+  {
+    const child = Bun.spawn(["bun", "run", "native:build:node-addon"], {
+      stdout: "inherit",
+      stderr: "inherit",
+    });
+    const code = await child.exited;
+    if (code !== 0) {
+      console.warn(
+        "[bun-scikit] Node-API addon local build failed; the Zig FFI backend can still be used.",
+      );
+    }
+  }
+}
+
+async function main(): Promise<void> {
+  if (process.env.BUN_SCIKIT_SKIP_NATIVE_INSTALL === "1" || process.env.CI === "true") {
+    console.log("[bun-scikit] skipping native install bootstrap in CI/skip mode");
+    return;
+  }
+
+  const existingKernelDll = resolve("dist", "native", "bun_scikit_kernels.dll");
+  const existingKernelSo = resolve("dist", "native", "bun_scikit_kernels.so");
+  if (await fileExists(existingKernelDll) || (await fileExists(existingKernelSo))) {
+    return;
+  }
+
+  const downloaded = await tryDownloadPrebuilt();
+  if (downloaded) {
+    return;
+  }
+
+  try {
+    await tryLocalBuild();
+  } catch (error) {
+    console.warn("[bun-scikit] native postinstall setup did not complete.", error);
+  }
+}
+
+main().catch((error) => {
+  console.warn("[bun-scikit] native install script error:", error);
+});

package/scripts/package-native-artifacts.ts

@@ -0,0 +1,62 @@
+import { cp, mkdir, readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+
+interface PackageJson {
+  version: string;
+}
+
+function argValue(flag: string): string | null {
+  const index = Bun.argv.indexOf(flag);
+  if (index === -1 || index + 1 >= Bun.argv.length) {
+    return null;
+  }
+  return Bun.argv[index + 1];
+}
+
+function kernelExtension(osName: string): string {
+  switch (osName) {
+    case "windows":
+      return "dll";
+    case "linux":
+      return "so";
+    default:
+      throw new Error(`Unsupported OS for packaging assets: ${osName}`);
+  }
+}
+
+async function main(): Promise<void> {
+  const osName = argValue("--os");
+  const arch = argValue("--arch");
+  if (!osName || !arch) {
+    throw new Error("Usage: bun run scripts/package-native-artifacts.ts --os <linux|windows> --arch <x64|arm64>");
+  }
+
+  const packageJsonRaw = await readFile(resolve("package.json"), "utf-8");
+  const packageJson = JSON.parse(packageJsonRaw) as PackageJson;
+  const version = packageJson.version;
+  const extension = kernelExtension(osName);
+
+  const sourceKernel = resolve("dist", "native", `bun_scikit_kernels.${extension}`);
+  const sourceAddon = resolve("dist", "native", "bun_scikit_node_addon.node");
+
+  const outDir = resolve("dist", "release-assets");
+  await mkdir(outDir, { recursive: true });
+
+  const targetKernel = resolve(
+    outDir,
+    `bun_scikit_kernels-v${version}-${osName}-${arch}.${extension}`,
+  );
+  const targetAddon = resolve(
+    outDir,
+    `bun_scikit_node_addon-v${version}-${osName}-${arch}.node`,
+  );
+
+  await cp(sourceKernel, targetKernel, { force: true });
+  await cp(sourceAddon, targetAddon, { force: true });
+  console.log(`Packaged release assets:\n- ${targetKernel}\n- ${targetAddon}`);
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});

package/scripts/sync-benchmark-readme.ts

@@ -0,0 +1,181 @@
+import { readFile, writeFile } from "node:fs/promises";
+import { resolve } from "node:path";
+
+interface SharedBenchmarkResult {
+  implementation: string;
+  model: string;
+  fitMsMedian: number;
+  predictMsMedian: number;
+}
+
+interface RegressionBenchmarkResult extends SharedBenchmarkResult {
+  mse: number;
+  r2: number;
+}
+
+interface ClassificationBenchmarkResult extends SharedBenchmarkResult {
+  accuracy: number;
+  f1: number;
+}
+
+type TreeModelKey = "decision_tree" | "random_forest";
+
+interface TreeModelComparison {
+  key: TreeModelKey;
+  bun: ClassificationBenchmarkResult;
+  sklearn: ClassificationBenchmarkResult;
+  comparison: {
+    fitSpeedupVsSklearn: number;
+    predictSpeedupVsSklearn: number;
+    accuracyDeltaVsSklearn: number;
+    f1DeltaVsSklearn: number;
+  };
+}
+
+interface BenchmarkSnapshot {
+  generatedAt: string;
+  dataset: {
+    path: string;
+    samples: number;
+    features: number;
+    testFraction: number;
+  };
+  suites: {
+    regression: {
+      results: [RegressionBenchmarkResult, RegressionBenchmarkResult];
+      comparison: {
+        fitSpeedupVsSklearn: number;
+        predictSpeedupVsSklearn: number;
+        mseDeltaVsSklearn: number;
+        r2DeltaVsSklearn: number;
+      };
+    };
+    classification: {
+      results: [ClassificationBenchmarkResult, ClassificationBenchmarkResult];
+      comparison: {
+        fitSpeedupVsSklearn: number;
+        predictSpeedupVsSklearn: number;
+        accuracyDeltaVsSklearn: number;
+        f1DeltaVsSklearn: number;
+      };
+    };
+    treeClassification: {
+      models: [TreeModelComparison, TreeModelComparison];
+    };
+  };
+}
+
+const START_MARKER = "<!-- BENCHMARK_TABLE_START -->";
+const END_MARKER = "<!-- BENCHMARK_TABLE_END -->";
+const README_PATH = resolve("README.md");
+const DEFAULT_SNAPSHOT_PATH = resolve("bench/results/heart-ci-latest.json");
+
+function parseArgValue(flag: string): string | null {
+  const index = Bun.argv.indexOf(flag);
+  if (index === -1 || index + 1 >= Bun.argv.length) {
+    return null;
+  }
+  return Bun.argv[index + 1];
+}
+
+function normalizeLineEndings(content: string): string {
+  return content.replace(/\r\n/g, "\n");
+}
+
+function renderBenchmarkSection(snapshot: BenchmarkSnapshot): string {
+  const regression = snapshot.suites.regression;
+  const classification = snapshot.suites.classification;
+  const treeClassification = snapshot.suites.treeClassification;
+  const [bunReg, sklearnReg] = regression.results;
+  const [bunCls, sklearnCls] = classification.results;
+  const [decisionTree, randomForest] = treeClassification.models;
+
+  return [
+    START_MARKER,
+    "Benchmark snapshot source: `bench/results/heart-ci-latest.json` (generated in CI workflow `Benchmark Snapshot`).",
+    `Dataset: \`${snapshot.dataset.path}\` (${snapshot.dataset.samples} samples, ${snapshot.dataset.features} features, test fraction ${snapshot.dataset.testFraction}).`,
+    "",
+    "### Regression",
+    "",
+    "| Implementation | Model | Fit median (ms) | Predict median (ms) | MSE | R2 |",
+    "|---|---|---:|---:|---:|---:|",
+    `| ${bunReg.implementation} | ${bunReg.model} | ${bunReg.fitMsMedian.toFixed(4)} | ${bunReg.predictMsMedian.toFixed(4)} | ${bunReg.mse.toFixed(6)} | ${bunReg.r2.toFixed(6)} |`,
+    `| ${sklearnReg.implementation} | ${sklearnReg.model} | ${sklearnReg.fitMsMedian.toFixed(4)} | ${sklearnReg.predictMsMedian.toFixed(4)} | ${sklearnReg.mse.toFixed(6)} | ${sklearnReg.r2.toFixed(6)} |`,
+    "",
+    `Bun fit speedup vs scikit-learn: ${regression.comparison.fitSpeedupVsSklearn.toFixed(3)}x`,
+    `Bun predict speedup vs scikit-learn: ${regression.comparison.predictSpeedupVsSklearn.toFixed(3)}x`,
+    `MSE delta (bun - sklearn): ${regression.comparison.mseDeltaVsSklearn.toExponential(3)}`,
+    `R2 delta (bun - sklearn): ${regression.comparison.r2DeltaVsSklearn.toExponential(3)}`,
+    "",
+    "### Classification",
+    "",
+    "| Implementation | Model | Fit median (ms) | Predict median (ms) | Accuracy | F1 |",
+    "|---|---|---:|---:|---:|---:|",
+    `| ${bunCls.implementation} | ${bunCls.model} | ${bunCls.fitMsMedian.toFixed(4)} | ${bunCls.predictMsMedian.toFixed(4)} | ${bunCls.accuracy.toFixed(6)} | ${bunCls.f1.toFixed(6)} |`,
+    `| ${sklearnCls.implementation} | ${sklearnCls.model} | ${sklearnCls.fitMsMedian.toFixed(4)} | ${sklearnCls.predictMsMedian.toFixed(4)} | ${sklearnCls.accuracy.toFixed(6)} | ${sklearnCls.f1.toFixed(6)} |`,
+    "",
+    `Bun fit speedup vs scikit-learn: ${classification.comparison.fitSpeedupVsSklearn.toFixed(3)}x`,
+    `Bun predict speedup vs scikit-learn: ${classification.comparison.predictSpeedupVsSklearn.toFixed(3)}x`,
+    `Accuracy delta (bun - sklearn): ${classification.comparison.accuracyDeltaVsSklearn.toExponential(3)}`,
+    `F1 delta (bun - sklearn): ${classification.comparison.f1DeltaVsSklearn.toExponential(3)}`,
+    "",
+    "### Tree Classification",
+    "",
+    "| Model | Implementation | Fit median (ms) | Predict median (ms) | Accuracy | F1 |",
+    "|---|---|---:|---:|---:|---:|",
+    `| ${decisionTree.bun.model} | ${decisionTree.bun.implementation} | ${decisionTree.bun.fitMsMedian.toFixed(4)} | ${decisionTree.bun.predictMsMedian.toFixed(4)} | ${decisionTree.bun.accuracy.toFixed(6)} | ${decisionTree.bun.f1.toFixed(6)} |`,
+    `| ${decisionTree.sklearn.model} | ${decisionTree.sklearn.implementation} | ${decisionTree.sklearn.fitMsMedian.toFixed(4)} | ${decisionTree.sklearn.predictMsMedian.toFixed(4)} | ${decisionTree.sklearn.accuracy.toFixed(6)} | ${decisionTree.sklearn.f1.toFixed(6)} |`,
+    `| ${randomForest.bun.model} | ${randomForest.bun.implementation} | ${randomForest.bun.fitMsMedian.toFixed(4)} | ${randomForest.bun.predictMsMedian.toFixed(4)} | ${randomForest.bun.accuracy.toFixed(6)} | ${randomForest.bun.f1.toFixed(6)} |`,
+    `| ${randomForest.sklearn.model} | ${randomForest.sklearn.implementation} | ${randomForest.sklearn.fitMsMedian.toFixed(4)} | ${randomForest.sklearn.predictMsMedian.toFixed(4)} | ${randomForest.sklearn.accuracy.toFixed(6)} | ${randomForest.sklearn.f1.toFixed(6)} |`,
+    "",
+    `DecisionTree fit speedup vs scikit-learn: ${decisionTree.comparison.fitSpeedupVsSklearn.toFixed(3)}x`,
+    `DecisionTree predict speedup vs scikit-learn: ${decisionTree.comparison.predictSpeedupVsSklearn.toFixed(3)}x`,
+    `DecisionTree accuracy delta (bun - sklearn): ${decisionTree.comparison.accuracyDeltaVsSklearn.toExponential(3)}`,
+    `DecisionTree f1 delta (bun - sklearn): ${decisionTree.comparison.f1DeltaVsSklearn.toExponential(3)}`,
+    "",
+    `RandomForest fit speedup vs scikit-learn: ${randomForest.comparison.fitSpeedupVsSklearn.toFixed(3)}x`,
+    `RandomForest predict speedup vs scikit-learn: ${randomForest.comparison.predictSpeedupVsSklearn.toFixed(3)}x`,
+    `RandomForest accuracy delta (bun - sklearn): ${randomForest.comparison.accuracyDeltaVsSklearn.toExponential(3)}`,
+    `RandomForest f1 delta (bun - sklearn): ${randomForest.comparison.f1DeltaVsSklearn.toExponential(3)}`,
+    "",
+    `Snapshot generated at: ${snapshot.generatedAt}`,
+    END_MARKER,
+  ].join("\n");
+}
+
+const inputPath = resolve(parseArgValue("--input") ?? DEFAULT_SNAPSHOT_PATH);
+const checkMode = Bun.argv.includes("--check");
+
+const [readme, snapshotRaw] = await Promise.all([
+  readFile(README_PATH, "utf-8"),
+  readFile(inputPath, "utf-8"),
+]);
+const snapshot = JSON.parse(snapshotRaw) as BenchmarkSnapshot;
+
+const startIndex = readme.indexOf(START_MARKER);
+const endIndex = readme.indexOf(END_MARKER);
+if (startIndex === -1 || endIndex === -1 || endIndex < startIndex) {
+  throw new Error(
+    `README markers are missing or invalid. Expected markers: ${START_MARKER} and ${END_MARKER}.`,
+  );
+}
+
+const existingSectionEnd = endIndex + END_MARKER.length;
+const nextReadme =
+  readme.slice(0, startIndex) +
+  renderBenchmarkSection(snapshot) +
+  readme.slice(existingSectionEnd);
+
+if (checkMode) {
+  if (normalizeLineEndings(nextReadme) !== normalizeLineEndings(readme)) {
+    console.error(
+      "README benchmark section is out of date. Run: bun run bench:sync-readme",
+    );
+    process.exit(1);
+  }
+  console.log("README benchmark section is up to date.");
+  process.exit(0);
+}
+
+await writeFile(README_PATH, nextReadme, "utf-8");
+console.log(`Updated README benchmark section from ${inputPath}`);

package/scripts/update-benchmark-history.ts

@@ -0,0 +1,91 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+
+interface BenchmarkSnapshot {
+  generatedAt: string;
+  benchmarkConfig: {
+    iterations: number;
+    warmup: number;
+  };
+  suites: {
+    regression: {
+      comparison: {
+        fitSpeedupVsSklearn: number;
+        predictSpeedupVsSklearn: number;
+        mseDeltaVsSklearn: number;
+        r2DeltaVsSklearn: number;
+      };
+    };
+    classification: {
+      comparison: {
+        fitSpeedupVsSklearn: number;
+        predictSpeedupVsSklearn: number;
+        accuracyDeltaVsSklearn: number;
+        f1DeltaVsSklearn: number;
+      };
+    };
+    treeClassification: {
+      models: Array<{
+        key: string;
+        comparison: {
+          fitSpeedupVsSklearn: number;
+          predictSpeedupVsSklearn: number;
+          accuracyDeltaVsSklearn: number;
+          f1DeltaVsSklearn: number;
+        };
+      }>;
+    };
+  };
+}
+
+function parseArgValue(flag: string): string | null {
+  const index = Bun.argv.indexOf(flag);
+  if (index === -1 || index + 1 >= Bun.argv.length) {
+    return null;
+  }
+  return Bun.argv[index + 1];
+}
+
+const inputPath = resolve(
+  parseArgValue("--input") ?? "bench/results/heart-ci-latest.json",
+);
+const outputPath = resolve(
+  parseArgValue("--output") ?? "bench/results/history/heart-ci-history.jsonl",
+);
+
+const snapshot = JSON.parse(await readFile(inputPath, "utf-8")) as BenchmarkSnapshot;
+
+const historyRecord = {
+  generatedAt: snapshot.generatedAt,
+  benchmarkConfig: snapshot.benchmarkConfig,
+  regression: snapshot.suites.regression.comparison,
+  classification: snapshot.suites.classification.comparison,
+  treeClassification: snapshot.suites.treeClassification.models.map((model) => ({
+    key: model.key,
+    ...model.comparison,
+  })),
+};
+
+let existing = "";
+try {
+  existing = await readFile(outputPath, "utf-8");
+} catch {
+  existing = "";
+}
+
+const lines = existing
+  .split(/\r?\n/)
+  .map((line) => line.trim())
+  .filter((line) => line.length > 0);
+
+if (lines.length > 0) {
+  const last = JSON.parse(lines[lines.length - 1]) as { generatedAt?: string };
+  if (last.generatedAt === historyRecord.generatedAt) {
+    console.log(`History already contains snapshot ${historyRecord.generatedAt}.`);
+    process.exit(0);
+  }
+}
+
+await mkdir(dirname(outputPath), { recursive: true });
+await writeFile(outputPath, `${existing}${JSON.stringify(historyRecord)}\n`, "utf-8");
+console.log(`Appended benchmark history: ${outputPath}`);

package/src/ensemble/RandomForestClassifier.ts

@@ -0,0 +1,136 @@
+import type { ClassificationModel, Matrix, Vector } from "../types";
+import { accuracyScore } from "../metrics/classification";
+import { DecisionTreeClassifier, type MaxFeaturesOption } from "../tree/DecisionTreeClassifier";
+import { assertFiniteVector, validateClassificationInputs } from "../utils/validation";
+
+export interface RandomForestClassifierOptions {
+  nEstimators?: number;
+  maxDepth?: number;
+  minSamplesSplit?: number;
+  minSamplesLeaf?: number;
+  maxFeatures?: MaxFeaturesOption;
+  bootstrap?: boolean;
+  randomState?: number;
+}
+
+function mulberry32(seed: number): () => number {
+  let state = seed >>> 0;
+  return () => {
+    state += 0x6d2b79f5;
+    let t = Math.imul(state ^ (state >>> 15), 1 | state);
+    t ^= t + Math.imul(t ^ (t >>> 7), 61 | t);
+    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+  };
+}
+
+export class RandomForestClassifier implements ClassificationModel {
+  classes_: Vector = [0, 1];
+  private readonly nEstimators: number;
+  private readonly maxDepth?: number;
+  private readonly minSamplesSplit?: number;
+  private readonly minSamplesLeaf?: number;
+  private readonly maxFeatures: MaxFeaturesOption;
+  private readonly bootstrap: boolean;
+  private readonly randomState?: number;
+  private trees: DecisionTreeClassifier[] = [];
+
+  constructor(options: RandomForestClassifierOptions = {}) {
+    this.nEstimators = options.nEstimators ?? 50;
+    this.maxDepth = options.maxDepth ?? 12;
+    this.minSamplesSplit = options.minSamplesSplit ?? 2;
+    this.minSamplesLeaf = options.minSamplesLeaf ?? 1;
+    this.maxFeatures = options.maxFeatures ?? "sqrt";
+    this.bootstrap = options.bootstrap ?? true;
+    this.randomState = options.randomState;
+
+    if (!Number.isInteger(this.nEstimators) || this.nEstimators < 1) {
+      throw new Error(`nEstimators must be a positive integer. Got ${this.nEstimators}.`);
+    }
+  }
+
+  fit(X: Matrix, y: Vector): this {
+    validateClassificationInputs(X, y);
+
+    const sampleCount = X.length;
+    const featureCount = X[0].length;
+    const random = this.randomState === undefined ? Math.random : mulberry32(this.randomState);
+    const flattenedX = this.flattenTrainingMatrix(X, sampleCount, featureCount);
+    const yBinary = this.buildBinaryTargets(y);
+    this.trees = new Array(this.nEstimators);
+
+    for (let estimatorIndex = 0; estimatorIndex < this.nEstimators; estimatorIndex += 1) {
+      const sampleIndices = new Uint32Array(sampleCount);
+      if (this.bootstrap) {
+        for (let i = 0; i < sampleCount; i += 1) {
+          sampleIndices[i] = Math.floor(random() * sampleCount);
+        }
+      } else {
+        for (let i = 0; i < sampleCount; i += 1) {
+          sampleIndices[i] = i;
+        }
+      }
+
+      const tree = new DecisionTreeClassifier({
+        maxDepth: this.maxDepth,
+        minSamplesSplit: this.minSamplesSplit,
+        minSamplesLeaf: this.minSamplesLeaf,
+        maxFeatures: this.maxFeatures,
+        randomState:
+          this.randomState === undefined ? undefined : this.randomState + estimatorIndex + 1,
+      });
+      tree.fit(X, y, sampleIndices, true, flattenedX, yBinary);
+      this.trees[estimatorIndex] = tree;
+    }
+
+    return this;
+  }
+
+  predict(X: Matrix): Vector {
+    if (this.trees.length === 0) {
+      throw new Error("RandomForestClassifier has not been fitted.");
+    }
+
+    const treePredictions = this.trees.map((tree) => tree.predict(X));
+    const sampleCount = X.length;
+    const predictions = new Array(sampleCount).fill(0);
+
+    for (let sampleIndex = 0; sampleIndex < sampleCount; sampleIndex += 1) {
+      let positiveVotes = 0;
+      for (let treeIndex = 0; treeIndex < treePredictions.length; treeIndex += 1) {
+        positiveVotes += treePredictions[treeIndex][sampleIndex] === 1 ? 1 : 0;
+      }
+      predictions[sampleIndex] = positiveVotes * 2 >= this.trees.length ? 1 : 0;
+    }
+
+    return predictions;
+  }
+
+  score(X: Matrix, y: Vector): number {
+    assertFiniteVector(y);
+    return accuracyScore(y, this.predict(X));
+  }
+
+  private flattenTrainingMatrix(
+    X: Matrix,
+    sampleCount: number,
+    featureCount: number,
+  ): Float64Array {
+    const flattened = new Float64Array(sampleCount * featureCount);
+    for (let i = 0; i < sampleCount; i += 1) {
+      const row = X[i];
+      const rowOffset = i * featureCount;
+      for (let j = 0; j < featureCount; j += 1) {
+        flattened[rowOffset + j] = row[j];
+      }
+    }
+    return flattened;
+  }
+
+  private buildBinaryTargets(y: Vector): Uint8Array {
+    const encoded = new Uint8Array(y.length);
+    for (let i = 0; i < y.length; i += 1) {
+      encoded[i] = y[i] === 1 ? 1 : 0;
+    }
+    return encoded;
+  }
+}