Enum TreeNode 

#[non_exhaustive]
pub enum TreeNode {
    Leaf {
        prediction: f64,
        n_samples: usize,
        class_counts: Vec<usize>,
        impurity: f64,
    },
    Split {
        feature_idx: usize,
        threshold: f64,
        left: Box<TreeNode>,
        right: Box<TreeNode>,
        n_samples: usize,
        impurity: f64,
        class_counts: Vec<usize>,
        prediction: f64,
    },
}

A node in the decision tree (recursive representation).

Used during tree construction, then flattened into a FlatTree for cache-optimal prediction. Exposed publicly for visualization.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Leaf

A leaf node — produces a prediction.

Fields

prediction: f64

Predicted class (classification) or value (regression).

n_samples: usize

Number of training samples that reached this node.

class_counts: Vec<usize>

Class distribution at this node (classification only).

impurity: f64

Impurity at this node.

Split

An internal split node.

Fields

feature_idx: usize

Index of the feature used for the split.

threshold: f64

Threshold value: left if ≤ threshold, right if > threshold.

left: Box<TreeNode>

Left child (≤ threshold).

right: Box<TreeNode>

Right child (> threshold).

n_samples: usize

Number of training samples that reached this node.

impurity: f64

Impurity at this node (before split).

class_counts: Vec<usize>

Class distribution at this node.

prediction: f64

Majority class prediction at this node.

Implementations

impl TreeNode

pub fn predict(&self, sample: &[f64]) -> f64

Predict for a single sample by walking the tree.

pub fn predict_proba(&self, sample: &[f64], n_classes: usize) -> Vec<f64>

Get class probabilities for a single sample.

pub fn depth(&self) -> usize

Depth of this subtree.

pub fn n_leaves(&self) -> usize

Number of leaf nodes in this subtree.

pub fn n_samples(&self) -> usize

Number of samples at this node.

pub fn total_leaf_impurity(&self) -> f64

Sum of weighted leaf impurities: Σ(impurity_leaf × n_samples_leaf).

This is R(T_t) in the cost-complexity pruning literature.

pub fn prune_ccp(self, ccp_alpha: f64) -> TreeNode

Minimal cost-complexity pruning (MCCP).

Recursively prunes subtrees whose effective alpha is ≤ ccp_alpha. Effective alpha = (R(t) - R(T_t)) / (|T_t| - 1), where R(t) is the re-substitution error if this node were a leaf and R(T_t) is the total leaf impurity of the subtree.

This matches sklearn’s ccp_alpha parameter behavior.

pub fn cost_complexity_pruning_path(&self) -> (Vec<f64>, Vec<f64>)

Compute the cost-complexity pruning path.

Returns (ccp_alphas, total_impurities) — a sequence of effective alpha values and the corresponding total tree impurity at each pruning step. Useful for elbow-method selection of ccp_alpha.

Trait Implementations

impl Clone for TreeNode

fn clone(&self) -> TreeNode

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for TreeNode

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.