bun-scikit 0.1.3 → 0.1.5

package/src/metrics/classification.ts

@@ -292,3 +292,33 @@ export function classificationReport(
     },
   };
 }
+
+export function balancedAccuracyScore(yTrue: number[], yPred: number[]): number {
+  const report = classificationReport(yTrue, yPred);
+  return report.macroAvg.recall;
+}
+
+export function matthewsCorrcoef(
+  yTrue: number[],
+  yPred: number[],
+  positiveLabel = 1,
+): number {
+  const { tp, fp, fn, tn } = confusionCounts(yTrue, yPred, positiveLabel);
+  const numerator = tp * tn - fp * fn;
+  const denominator = Math.sqrt((tp + fp) * (tp + fn) * (tn + fp) * (tn + fn));
+  if (denominator === 0) {
+    return 0;
+  }
+  return numerator / denominator;
+}
+
+export function brierScoreLoss(yTrue: number[], yPredProb: number[]): number {
+  validateInputs(yTrue, yPredProb);
+  validateBinaryTargets(yTrue);
+  let total = 0;
+  for (let i = 0; i < yTrue.length; i += 1) {
+    const diff = yPredProb[i] - yTrue[i];
+    total += diff * diff;
+  }
+  return total / yTrue.length;
+}

package/src/metrics/regression.ts

@@ -49,3 +49,43 @@ export function r2Score(yTrue: number[], yPred: number[]): number {
 
   return 1 - ssRes / ssTot;
 }
+
+export function meanAbsolutePercentageError(yTrue: number[], yPred: number[]): number {
+  validateInputs(yTrue, yPred);
+  let total = 0;
+  for (let i = 0; i < yTrue.length; i += 1) {
+    const denom = Math.max(Math.abs(yTrue[i]), 1e-12);
+    total += Math.abs((yTrue[i] - yPred[i]) / denom);
+  }
+  return total / yTrue.length;
+}
+
+export function explainedVarianceScore(yTrue: number[], yPred: number[]): number {
+  validateInputs(yTrue, yPred);
+  const n = yTrue.length;
+  const yTrueMean = mean(yTrue);
+  const residuals = new Array<number>(n);
+  let residualMean = 0;
+  for (let i = 0; i < n; i += 1) {
+    const r = yTrue[i] - yPred[i];
+    residuals[i] = r;
+    residualMean += r;
+  }
+  residualMean /= n;
+
+  let varTrue = 0;
+  let varResidual = 0;
+  for (let i = 0; i < n; i += 1) {
+    const centeredY = yTrue[i] - yTrueMean;
+    const centeredR = residuals[i] - residualMean;
+    varTrue += centeredY * centeredY;
+    varResidual += centeredR * centeredR;
+  }
+
+  varTrue /= n;
+  varResidual /= n;
+  if (varTrue === 0) {
+    return varResidual === 0 ? 1 : 0;
+  }
+  return 1 - varResidual / varTrue;
+}

package/src/model_selection/RandomizedSearchCV.ts

@@ -0,0 +1,269 @@
+import type { Matrix, Vector } from "../types";
+import { accuracyScore, f1Score, precisionScore, recallScore } from "../metrics/classification";
+import { meanSquaredError, r2Score } from "../metrics/regression";
+import {
+  crossValScore,
+  type BuiltInScoring,
+  type CrossValEstimator,
+  type CrossValSplitter,
+  type ScoringFn,
+} from "./crossValScore";
+
+export type ParamDistributions = Record<string, readonly unknown[]>;
+
+export interface RandomizedSearchCVOptions {
+  cv?: number | CrossValSplitter;
+  scoring?: BuiltInScoring | ScoringFn;
+  refit?: boolean;
+  errorScore?: "raise" | number;
+  nIter?: number;
+  randomState?: number;
+}
+
+export interface RandomizedSearchResultRow {
+  params: Record<string, unknown>;
+  splitScores: number[];
+  meanTestScore: number;
+  stdTestScore: number;
+  rank: number;
+  status: "ok" | "error";
+  errorMessage?: string;
+}
+
+function mean(values: number[]): number {
+  let sum = 0;
+  for (let i = 0; i < values.length; i += 1) {
+    sum += values[i];
+  }
+  return sum / values.length;
+}
+
+function std(values: number[]): number {
+  if (values.length < 2) {
+    return 0;
+  }
+  const avg = mean(values);
+  let sum = 0;
+  for (let i = 0; i < values.length; i += 1) {
+    const diff = values[i] - avg;
+    sum += diff * diff;
+  }
+  return Math.sqrt(sum / values.length);
+}
+
+function resolveBuiltInScorer(scoring: BuiltInScoring): ScoringFn {
+  switch (scoring) {
+    case "accuracy":
+      return accuracyScore;
+    case "f1":
+      return f1Score;
+    case "precision":
+      return precisionScore;
+    case "recall":
+      return recallScore;
+    case "r2":
+      return r2Score;
+    case "mean_squared_error":
+      return meanSquaredError;
+    case "neg_mean_squared_error":
+      return (yTrue, yPred) => -meanSquaredError(yTrue, yPred);
+    default: {
+      const exhaustive: never = scoring;
+      throw new Error(`Unsupported scoring metric: ${exhaustive}`);
+    }
+  }
+}
+
+function isLossMetric(scoring: BuiltInScoring | ScoringFn | undefined): boolean {
+  return scoring === "mean_squared_error";
+}
+
+class Mulberry32 {
+  private state: number;
+
+  constructor(seed: number) {
+    this.state = seed >>> 0;
+  }
+
+  next(): number {
+    this.state = (this.state + 0x6d2b79f5) >>> 0;
+    let t = this.state ^ (this.state >>> 15);
+    t = Math.imul(t, this.state | 1);
+    t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+  }
+
+  nextInt(maxExclusive: number): number {
+    return Math.floor(this.next() * maxExclusive);
+  }
+}
+
+function sampleParams(
+  distributions: ParamDistributions,
+  nIter: number,
+  randomState: number,
+): Record<string, unknown>[] {
+  const keys = Object.keys(distributions);
+  if (keys.length === 0) {
+    throw new Error("paramDistributions must include at least one parameter.");
+  }
+  for (let i = 0; i < keys.length; i += 1) {
+    const values = distributions[keys[i]];
+    if (!Array.isArray(values) || values.length === 0) {
+      throw new Error(`paramDistributions '${keys[i]}' must be a non-empty array.`);
+    }
+  }
+
+  const rng = new Mulberry32(randomState);
+  const out: Record<string, unknown>[] = [];
+  for (let i = 0; i < nIter; i += 1) {
+    const params: Record<string, unknown> = {};
+    for (let k = 0; k < keys.length; k += 1) {
+      const key = keys[k];
+      const values = distributions[key];
+      params[key] = values[rng.nextInt(values.length)];
+    }
+    out.push(params);
+  }
+  return out;
+}
+
+export class RandomizedSearchCV<TEstimator extends CrossValEstimator> {
+  bestEstimator_: TEstimator | null = null;
+  bestParams_: Record<string, unknown> | null = null;
+  bestScore_: number | null = null;
+  cvResults_: RandomizedSearchResultRow[] = [];
+
+  private readonly estimatorFactory: (params: Record<string, unknown>) => TEstimator;
+  private readonly paramDistributions: ParamDistributions;
+  private readonly cv?: number | CrossValSplitter;
+  private readonly scoring?: BuiltInScoring | ScoringFn;
+  private readonly refit: boolean;
+  private readonly errorScore: "raise" | number;
+  private readonly nIter: number;
+  private readonly randomState: number;
+  private isFitted = false;
+
+  constructor(
+    estimatorFactory: (params: Record<string, unknown>) => TEstimator,
+    paramDistributions: ParamDistributions,
+    options: RandomizedSearchCVOptions = {},
+  ) {
+    if (typeof estimatorFactory !== "function") {
+      throw new Error("estimatorFactory must be a function.");
+    }
+    this.estimatorFactory = estimatorFactory;
+    this.paramDistributions = paramDistributions;
+    this.cv = options.cv;
+    this.scoring = options.scoring;
+    this.refit = options.refit ?? true;
+    this.errorScore = options.errorScore ?? "raise";
+    this.nIter = options.nIter ?? 10;
+    this.randomState = options.randomState ?? 42;
+    if (!Number.isInteger(this.nIter) || this.nIter < 1) {
+      throw new Error(`nIter must be an integer >= 1. Got ${this.nIter}.`);
+    }
+  }
+
+  fit(X: Matrix, y: Vector): this {
+    const candidates = sampleParams(this.paramDistributions, this.nIter, this.randomState);
+    const minimize = isLossMetric(this.scoring);
+    const rows: RandomizedSearchResultRow[] = [];
+    const objectiveScores: number[] = [];
+
+    for (let candidateIndex = 0; candidateIndex < candidates.length; candidateIndex += 1) {
+      const params = candidates[candidateIndex];
+      try {
+        const splitScores = crossValScore(
+          () => this.estimatorFactory(params),
+          X,
+          y,
+          { cv: this.cv, scoring: this.scoring },
+        );
+        const meanTestScore = mean(splitScores);
+        rows.push({
+          params: { ...params },
+          splitScores,
+          meanTestScore,
+          stdTestScore: std(splitScores),
+          rank: 0,
+          status: "ok",
+        });
+        objectiveScores.push(minimize ? -meanTestScore : meanTestScore);
+      } catch (error) {
+        if (this.errorScore === "raise") {
+          throw error;
+        }
+        rows.push({
+          params: { ...params },
+          splitScores: [this.errorScore],
+          meanTestScore: this.errorScore,
+          stdTestScore: 0,
+          rank: 0,
+          status: "error",
+          errorMessage: error instanceof Error ? error.message : String(error),
+        });
+        objectiveScores.push(minimize ? -this.errorScore : this.errorScore);
+      }
+    }
+
+    const order = Array.from({ length: rows.length }, (_, idx) => idx).sort((a, b) => {
+      const delta = objectiveScores[b] - objectiveScores[a];
+      if (delta !== 0) {
+        return delta;
+      }
+      return a - b;
+    });
+
+    for (let rank = 0; rank < order.length; rank += 1) {
+      rows[order[rank]].rank = rank + 1;
+    }
+
+    const bestIndex = order[0];
+    this.bestParams_ = { ...rows[bestIndex].params };
+    this.bestScore_ = rows[bestIndex].meanTestScore;
+    this.cvResults_ = rows;
+
+    if (this.refit) {
+      const estimator = this.estimatorFactory(this.bestParams_);
+      estimator.fit(X, y);
+      this.bestEstimator_ = estimator;
+    } else {
+      this.bestEstimator_ = null;
+    }
+
+    this.isFitted = true;
+    return this;
+  }
+
+  predict(X: Matrix): Vector {
+    if (!this.isFitted) {
+      throw new Error("RandomizedSearchCV has not been fitted.");
+    }
+    if (!this.refit || !this.bestEstimator_) {
+      throw new Error("RandomizedSearchCV predict is unavailable when refit=false.");
+    }
+    return this.bestEstimator_.predict(X);
+  }
+
+  score(X: Matrix, y: Vector): number {
+    if (!this.isFitted) {
+      throw new Error("RandomizedSearchCV has not been fitted.");
+    }
+    if (!this.refit || !this.bestEstimator_) {
+      throw new Error("RandomizedSearchCV score is unavailable when refit=false.");
+    }
+
+    if (this.scoring) {
+      const scorer =
+        typeof this.scoring === "function" ? this.scoring : resolveBuiltInScorer(this.scoring);
+      return scorer(y, this.bestEstimator_.predict(X));
+    }
+
+    if (typeof this.bestEstimator_.score === "function") {
+      return this.bestEstimator_.score(X, y);
+    }
+
+    throw new Error("No scoring function available. Provide scoring in RandomizedSearchCV options.");
+  }
+}

package/src/native/node-addon/bun_scikit_addon.cpp

@@ -27,6 +27,24 @@ using LogisticModelFitFn = std::size_t (*)(NativeHandle, const double*, const do
 using LogisticModelFitLbfgsFn = std::size_t (*)(NativeHandle, const double*, const double*, std::size_t, std::size_t, double, double, std::size_t);
 using LogisticModelCopyCoefficientsFn = std::uint8_t (*)(NativeHandle, double*);
 using LogisticModelGetInterceptFn = double (*)(NativeHandle);
+using DecisionTreeModelCreateFn = NativeHandle (*)(std::size_t, std::size_t, std::size_t, std::uint8_t, std::size_t, std::uint32_t, std::uint8_t, std::size_t);
+using DecisionTreeModelDestroyFn = void (*)(NativeHandle);
+using DecisionTreeModelFitFn = std::uint8_t (*)(NativeHandle, const double*, const std::uint8_t*, std::size_t, std::size_t, const std::uint32_t*, std::size_t);
+using DecisionTreeModelPredictFn = std::uint8_t (*)(NativeHandle, const double*, std::size_t, std::size_t, std::uint8_t*);
+using RandomForestClassifierModelCreateFn = NativeHandle (*)(
+    std::size_t,
+    std::size_t,
+    std::size_t,
+    std::size_t,
+    std::uint8_t,
+    std::size_t,
+    std::uint8_t,
+    std::uint32_t,
+    std::uint8_t,
+    std::size_t);
+using RandomForestClassifierModelDestroyFn = void (*)(NativeHandle);
+using RandomForestClassifierModelFitFn = std::uint8_t (*)(NativeHandle, const double*, const std::uint8_t*, std::size_t, std::size_t);
+using RandomForestClassifierModelPredictFn = std::uint8_t (*)(NativeHandle, const double*, std::size_t, std::size_t, std::uint8_t*);
 
 struct KernelLibrary {
 #if defined(_WIN32)
@@ -47,6 +65,14 @@ struct KernelLibrary {
   LogisticModelFitLbfgsFn logistic_model_fit_lbfgs{nullptr};
   LogisticModelCopyCoefficientsFn logistic_model_copy_coefficients{nullptr};
   LogisticModelGetInterceptFn logistic_model_get_intercept{nullptr};
+  DecisionTreeModelCreateFn decision_tree_model_create{nullptr};
+  DecisionTreeModelDestroyFn decision_tree_model_destroy{nullptr};
+  DecisionTreeModelFitFn decision_tree_model_fit{nullptr};
+  DecisionTreeModelPredictFn decision_tree_model_predict{nullptr};
+  RandomForestClassifierModelCreateFn random_forest_classifier_model_create{nullptr};
+  RandomForestClassifierModelDestroyFn random_forest_classifier_model_destroy{nullptr};
+  RandomForestClassifierModelFitFn random_forest_classifier_model_fit{nullptr};
+  RandomForestClassifierModelPredictFn random_forest_classifier_model_predict{nullptr};
 };
 
 KernelLibrary g_library{};
@@ -138,6 +164,22 @@ Napi::Value LoadNativeLibrary(const Napi::CallbackInfo& info) {
       loadSymbol<LogisticModelCopyCoefficientsFn>("logistic_model_copy_coefficients");
   g_library.logistic_model_get_intercept =
       loadSymbol<LogisticModelGetInterceptFn>("logistic_model_get_intercept");
+  g_library.decision_tree_model_create =
+      loadSymbol<DecisionTreeModelCreateFn>("decision_tree_model_create");
+  g_library.decision_tree_model_destroy =
+      loadSymbol<DecisionTreeModelDestroyFn>("decision_tree_model_destroy");
+  g_library.decision_tree_model_fit =
+      loadSymbol<DecisionTreeModelFitFn>("decision_tree_model_fit");
+  g_library.decision_tree_model_predict =
+      loadSymbol<DecisionTreeModelPredictFn>("decision_tree_model_predict");
+  g_library.random_forest_classifier_model_create =
+      loadSymbol<RandomForestClassifierModelCreateFn>("random_forest_classifier_model_create");
+  g_library.random_forest_classifier_model_destroy =
+      loadSymbol<RandomForestClassifierModelDestroyFn>("random_forest_classifier_model_destroy");
+  g_library.random_forest_classifier_model_fit =
+      loadSymbol<RandomForestClassifierModelFitFn>("random_forest_classifier_model_fit");
+  g_library.random_forest_classifier_model_predict =
+      loadSymbol<RandomForestClassifierModelPredictFn>("random_forest_classifier_model_predict");
 
   return Napi::Boolean::New(env, true);
 }
@@ -423,6 +465,262 @@ Napi::Value LogisticModelGetIntercept(const Napi::CallbackInfo& info) {
   return Napi::Number::New(env, g_library.logistic_model_get_intercept(handle));
 }
 
+Napi::Value DecisionTreeModelCreate(const Napi::CallbackInfo& info) {
+  const Napi::Env env = info.Env();
+  if (!isLibraryLoaded(env)) {
+    return env.Null();
+  }
+  if (!g_library.decision_tree_model_create) {
+    throwError(env, "Symbol decision_tree_model_create is unavailable.");
+    return env.Null();
+  }
+  if (info.Length() != 8 || !info[0].IsNumber() || !info[1].IsNumber() || !info[2].IsNumber() ||
+      !info[3].IsNumber() || !info[4].IsNumber() || !info[5].IsNumber() || !info[6].IsNumber() ||
+      !info[7].IsNumber()) {
+    throwTypeError(env, "decisionTreeModelCreate(maxDepth, minSamplesSplit, minSamplesLeaf, maxFeaturesMode, maxFeaturesValue, randomState, useRandomState, nFeatures) expects eight numbers.");
+    return env.Null();
+  }
+
+  const std::size_t max_depth = static_cast<std::size_t>(info[0].As<Napi::Number>().Uint32Value());
+  const std::size_t min_samples_split = static_cast<std::size_t>(info[1].As<Napi::Number>().Uint32Value());
+  const std::size_t min_samples_leaf = static_cast<std::size_t>(info[2].As<Napi::Number>().Uint32Value());
+  const std::uint8_t max_features_mode = static_cast<std::uint8_t>(info[3].As<Napi::Number>().Uint32Value());
+  const std::size_t max_features_value = static_cast<std::size_t>(info[4].As<Napi::Number>().Uint32Value());
+  const std::uint32_t random_state = static_cast<std::uint32_t>(info[5].As<Napi::Number>().Uint32Value());
+  const std::uint8_t use_random_state = static_cast<std::uint8_t>(info[6].As<Napi::Number>().Uint32Value());
+  const std::size_t n_features = static_cast<std::size_t>(info[7].As<Napi::Number>().Uint32Value());
+
+  const NativeHandle handle = g_library.decision_tree_model_create(
+      max_depth,
+      min_samples_split,
+      min_samples_leaf,
+      max_features_mode,
+      max_features_value,
+      random_state,
+      use_random_state,
+      n_features);
+  return Napi::BigInt::New(env, static_cast<std::uint64_t>(handle));
+}
+
+Napi::Value DecisionTreeModelDestroy(const Napi::CallbackInfo& info) {
+  const Napi::Env env = info.Env();
+  if (!isLibraryLoaded(env)) {
+    return env.Null();
+  }
+  if (!g_library.decision_tree_model_destroy) {
+    throwError(env, "Symbol decision_tree_model_destroy is unavailable.");
+    return env.Null();
+  }
+  if (info.Length() != 1) {
+    throwTypeError(env, "decisionTreeModelDestroy(handle) expects one BigInt.");
+    return env.Null();
+  }
+  const NativeHandle handle = handleFromBigInt(info[0], env);
+  if (env.IsExceptionPending()) {
+    return env.Null();
+  }
+  g_library.decision_tree_model_destroy(handle);
+  return env.Undefined();
+}
+
+Napi::Value DecisionTreeModelFit(const Napi::CallbackInfo& info) {
+  const Napi::Env env = info.Env();
+  if (!isLibraryLoaded(env)) {
+    return env.Null();
+  }
+  if (!g_library.decision_tree_model_fit) {
+    throwError(env, "Symbol decision_tree_model_fit is unavailable.");
+    return env.Null();
+  }
+  if (info.Length() != 7 || !info[1].IsTypedArray() || !info[2].IsTypedArray() ||
+      !info[3].IsNumber() || !info[4].IsNumber() || !info[5].IsTypedArray() || !info[6].IsNumber()) {
+    throwTypeError(env, "decisionTreeModelFit(handle, x, y, nSamples, nFeatures, sampleIndices, sampleCount) has invalid arguments.");
+    return env.Null();
+  }
+
+  const NativeHandle handle = handleFromBigInt(info[0], env);
+  if (env.IsExceptionPending()) {
+    return env.Null();
+  }
+  auto x = info[1].As<Napi::Float64Array>();
+  auto y = info[2].As<Napi::Uint8Array>();
+  const std::size_t n_samples = static_cast<std::size_t>(info[3].As<Napi::Number>().Uint32Value());
+  const std::size_t n_features = static_cast<std::size_t>(info[4].As<Napi::Number>().Uint32Value());
+  auto sample_indices = info[5].As<Napi::Uint32Array>();
+  const std::size_t sample_count = static_cast<std::size_t>(info[6].As<Napi::Number>().Uint32Value());
+
+  const std::uint8_t status = g_library.decision_tree_model_fit(
+      handle,
+      x.Data(),
+      y.Data(),
+      n_samples,
+      n_features,
+      sample_indices.Data(),
+      sample_count);
+  return Napi::Number::New(env, status);
+}
+
+Napi::Value DecisionTreeModelPredict(const Napi::CallbackInfo& info) {
+  const Napi::Env env = info.Env();
+  if (!isLibraryLoaded(env)) {
+    return env.Null();
+  }
+  if (!g_library.decision_tree_model_predict) {
+    throwError(env, "Symbol decision_tree_model_predict is unavailable.");
+    return env.Null();
+  }
+  if (info.Length() != 5 || !info[1].IsTypedArray() || !info[2].IsNumber() || !info[3].IsNumber() ||
+      !info[4].IsTypedArray()) {
+    throwTypeError(env, "decisionTreeModelPredict(handle, x, nSamples, nFeatures, outLabels) has invalid arguments.");
+    return env.Null();
+  }
+
+  const NativeHandle handle = handleFromBigInt(info[0], env);
+  if (env.IsExceptionPending()) {
+    return env.Null();
+  }
+  auto x = info[1].As<Napi::Float64Array>();
+  const std::size_t n_samples = static_cast<std::size_t>(info[2].As<Napi::Number>().Uint32Value());
+  const std::size_t n_features = static_cast<std::size_t>(info[3].As<Napi::Number>().Uint32Value());
+  auto out_labels = info[4].As<Napi::Uint8Array>();
+
+  const std::uint8_t status = g_library.decision_tree_model_predict(
+      handle,
+      x.Data(),
+      n_samples,
+      n_features,
+      out_labels.Data());
+  return Napi::Number::New(env, status);
+}
+
+Napi::Value RandomForestClassifierModelCreate(const Napi::CallbackInfo& info) {
+  const Napi::Env env = info.Env();
+  if (!isLibraryLoaded(env)) {
+    return env.Null();
+  }
+  if (!g_library.random_forest_classifier_model_create) {
+    throwError(env, "Symbol random_forest_classifier_model_create is unavailable.");
+    return env.Null();
+  }
+  if (info.Length() != 10 || !info[0].IsNumber() || !info[1].IsNumber() || !info[2].IsNumber() ||
+      !info[3].IsNumber() || !info[4].IsNumber() || !info[5].IsNumber() || !info[6].IsNumber() ||
+      !info[7].IsNumber() || !info[8].IsNumber() || !info[9].IsNumber()) {
+    throwTypeError(env, "randomForestClassifierModelCreate(nEstimators, maxDepth, minSamplesSplit, minSamplesLeaf, maxFeaturesMode, maxFeaturesValue, bootstrap, randomState, useRandomState, nFeatures) expects ten numbers.");
+    return env.Null();
+  }
+
+  const std::size_t n_estimators = static_cast<std::size_t>(info[0].As<Napi::Number>().Uint32Value());
+  const std::size_t max_depth = static_cast<std::size_t>(info[1].As<Napi::Number>().Uint32Value());
+  const std::size_t min_samples_split = static_cast<std::size_t>(info[2].As<Napi::Number>().Uint32Value());
+  const std::size_t min_samples_leaf = static_cast<std::size_t>(info[3].As<Napi::Number>().Uint32Value());
+  const std::uint8_t max_features_mode = static_cast<std::uint8_t>(info[4].As<Napi::Number>().Uint32Value());
+  const std::size_t max_features_value = static_cast<std::size_t>(info[5].As<Napi::Number>().Uint32Value());
+  const std::uint8_t bootstrap = static_cast<std::uint8_t>(info[6].As<Napi::Number>().Uint32Value());
+  const std::uint32_t random_state = static_cast<std::uint32_t>(info[7].As<Napi::Number>().Uint32Value());
+  const std::uint8_t use_random_state = static_cast<std::uint8_t>(info[8].As<Napi::Number>().Uint32Value());
+  const std::size_t n_features = static_cast<std::size_t>(info[9].As<Napi::Number>().Uint32Value());
+
+  const NativeHandle handle = g_library.random_forest_classifier_model_create(
+      n_estimators,
+      max_depth,
+      min_samples_split,
+      min_samples_leaf,
+      max_features_mode,
+      max_features_value,
+      bootstrap,
+      random_state,
+      use_random_state,
+      n_features);
+  return Napi::BigInt::New(env, static_cast<std::uint64_t>(handle));
+}
+
+Napi::Value RandomForestClassifierModelDestroy(const Napi::CallbackInfo& info) {
+  const Napi::Env env = info.Env();
+  if (!isLibraryLoaded(env)) {
+    return env.Null();
+  }
+  if (!g_library.random_forest_classifier_model_destroy) {
+    throwError(env, "Symbol random_forest_classifier_model_destroy is unavailable.");
+    return env.Null();
+  }
+  if (info.Length() != 1) {
+    throwTypeError(env, "randomForestClassifierModelDestroy(handle) expects one BigInt.");
+    return env.Null();
+  }
+  const NativeHandle handle = handleFromBigInt(info[0], env);
+  if (env.IsExceptionPending()) {
+    return env.Null();
+  }
+  g_library.random_forest_classifier_model_destroy(handle);
+  return env.Undefined();
+}
+
+Napi::Value RandomForestClassifierModelFit(const Napi::CallbackInfo& info) {
+  const Napi::Env env = info.Env();
+  if (!isLibraryLoaded(env)) {
+    return env.Null();
+  }
+  if (!g_library.random_forest_classifier_model_fit) {
+    throwError(env, "Symbol random_forest_classifier_model_fit is unavailable.");
+    return env.Null();
+  }
+  if (info.Length() != 5 || !info[1].IsTypedArray() || !info[2].IsTypedArray() ||
+      !info[3].IsNumber() || !info[4].IsNumber()) {
+    throwTypeError(env, "randomForestClassifierModelFit(handle, x, y, nSamples, nFeatures) has invalid arguments.");
+    return env.Null();
+  }
+
+  const NativeHandle handle = handleFromBigInt(info[0], env);
+  if (env.IsExceptionPending()) {
+    return env.Null();
+  }
+  auto x = info[1].As<Napi::Float64Array>();
+  auto y = info[2].As<Napi::Uint8Array>();
+  const std::size_t n_samples = static_cast<std::size_t>(info[3].As<Napi::Number>().Uint32Value());
+  const std::size_t n_features = static_cast<std::size_t>(info[4].As<Napi::Number>().Uint32Value());
+
+  const std::uint8_t status = g_library.random_forest_classifier_model_fit(
+      handle,
+      x.Data(),
+      y.Data(),
+      n_samples,
+      n_features);
+  return Napi::Number::New(env, status);
+}
+
+Napi::Value RandomForestClassifierModelPredict(const Napi::CallbackInfo& info) {
+  const Napi::Env env = info.Env();
+  if (!isLibraryLoaded(env)) {
+    return env.Null();
+  }
+  if (!g_library.random_forest_classifier_model_predict) {
+    throwError(env, "Symbol random_forest_classifier_model_predict is unavailable.");
+    return env.Null();
+  }
+  if (info.Length() != 5 || !info[1].IsTypedArray() || !info[2].IsNumber() || !info[3].IsNumber() ||
+      !info[4].IsTypedArray()) {
+    throwTypeError(env, "randomForestClassifierModelPredict(handle, x, nSamples, nFeatures, outLabels) has invalid arguments.");
+    return env.Null();
+  }
+
+  const NativeHandle handle = handleFromBigInt(info[0], env);
+  if (env.IsExceptionPending()) {
+    return env.Null();
+  }
+  auto x = info[1].As<Napi::Float64Array>();
+  const std::size_t n_samples = static_cast<std::size_t>(info[2].As<Napi::Number>().Uint32Value());
+  const std::size_t n_features = static_cast<std::size_t>(info[3].As<Napi::Number>().Uint32Value());
+  auto out_labels = info[4].As<Napi::Uint8Array>();
+
+  const std::uint8_t status = g_library.random_forest_classifier_model_predict(
+      handle,
+      x.Data(),
+      n_samples,
+      n_features,
+      out_labels.Data());
+  return Napi::Number::New(env, status);
+}
+
 Napi::Object Init(Napi::Env env, Napi::Object exports) {
   exports.Set("loadLibrary", Napi::Function::New(env, LoadNativeLibrary));
   exports.Set("unloadLibrary", Napi::Function::New(env, UnloadLibrary));
@@ -442,6 +740,15 @@ Napi::Object Init(Napi::Env env, Napi::Object exports) {
   exports.Set("logisticModelCopyCoefficients", Napi::Function::New(env, LogisticModelCopyCoefficients));
   exports.Set("logisticModelGetIntercept", Napi::Function::New(env, LogisticModelGetIntercept));
 
+  exports.Set("decisionTreeModelCreate", Napi::Function::New(env, DecisionTreeModelCreate));
+  exports.Set("decisionTreeModelDestroy", Napi::Function::New(env, DecisionTreeModelDestroy));
+  exports.Set("decisionTreeModelFit", Napi::Function::New(env, DecisionTreeModelFit));
+  exports.Set("decisionTreeModelPredict", Napi::Function::New(env, DecisionTreeModelPredict));
+  exports.Set("randomForestClassifierModelCreate", Napi::Function::New(env, RandomForestClassifierModelCreate));
+  exports.Set("randomForestClassifierModelDestroy", Napi::Function::New(env, RandomForestClassifierModelDestroy));
+  exports.Set("randomForestClassifierModelFit", Napi::Function::New(env, RandomForestClassifierModelFit));
+  exports.Set("randomForestClassifierModelPredict", Napi::Function::New(env, RandomForestClassifierModelPredict));
+
   return exports;
 }