Struct Tree 

pub struct Tree { /* private fields */ }

Decision tree

Implementations

impl Tree

pub fn new(root_value: f32, num_samples: usize, sum_g: f32, sum_h: f32) -> Self

Create a new tree with a single root leaf

pub fn from_nodes(nodes: Vec<Node>) -> Self

Create from a vector of nodes

pub fn root(&self) -> &Node

Get the root node

pub fn get_node(&self, idx: usize) -> &Node

Get a node by index

pub fn get_node_mut(&mut self, idx: usize) -> &mut Node

Get mutable node by index

pub fn add_node(&mut self, node: Node) -> usize

Add a node and return its index

pub fn num_nodes(&self) -> usize

Number of nodes

pub fn num_leaves(&self) -> usize

Number of leaves

pub fn max_depth(&self) -> usize

Maximum depth of the tree

pub fn predict<F>(&self, get_bin: F) -> f32

where F: Fn(usize) -> u8,

Predict for a single sample using binned features

Arguments

• get_bin - Function to get bin value for a feature: |feature_idx| -> u8

pub fn predict_row(&self, dataset: &BinnedDataset, row_idx: usize) -> f32

Predict for a single row in a dataset

pub fn predict_all(&self, dataset: &BinnedDataset) -> Vec<f32>

Predict for all rows in a dataset

pub fn predict_raw<F>(&self, get_value: F) -> f32

where F: Fn(usize) -> f64,

Predict for a single sample using raw feature values (no binning needed)

This uses the split_value stored in internal nodes to compare directly against raw feature values. Much faster than binning + predict.

Arguments

• get_value - Function to get feature value: |feature_idx| -> f64

pub fn predict_batch_add_raw( &self, features: &[f64], num_features: usize, predictions: &mut [f32], )

Batch predict using raw feature values: add this tree’s contribution

Similar to predict_batch_add but uses split_value for comparison instead of bin thresholds. Input is raw feature values, not binned data.

Uses parallel execution for large datasets (>= 10K rows).

Arguments

• features - Row-major feature matrix: features[row * num_features + feature]
• num_features - Number of features per row
• predictions - Mutable slice to accumulate predictions into

pub fn predict_batch_add( &self, dataset: &BinnedDataset, predictions: &mut [f32], )

Batch predict: add this tree’s contribution to all predictions

This is the tree-wise prediction approach: traverse one tree for ALL rows, then move to the next tree. More cache-friendly than row-wise traversal.

Uses parallel execution for large datasets (>= 10K rows).

Arguments

• dataset - The binned dataset
• predictions - Mutable slice to accumulate predictions into

pub fn predict_batch_add_columnar( &self, dataset: &BinnedDataset, predictions: &mut [f32], )

Batch predict with contiguous feature columns

Optimized version that accesses feature columns directly for better cache behavior. For each internal node, we fetch the entire feature column once.

pub fn leaves(&self) -> impl Iterator<Item = (usize, &Node)>

Get all leaf nodes

pub fn internal_nodes(&self) -> impl Iterator<Item = (usize, &Node)>

Get all internal nodes

pub fn nodes(&self) -> &[Node]

Get nodes as slice

Trait Implementations

impl Archive for Tree

where Vec<Node>: Archive,

const COPY_OPTIMIZATION: CopyOptimization<Self>

An optimization flag that allows the bytes of this type to be copied directly to a writer instead of calling serialize.

type Archived = ArchivedTree

The archived representation of this type.

type Resolver = TreeResolver

The resolver for this type. It must contain all the additional information from serializing needed to make the archived type from the normal type.

fn resolve(&self, resolver: Self::Resolver, out: Place<Self::Archived>)

Creates the archived version of this value at the given position and writes it to the given output.

impl Clone for Tree

fn clone(&self) -> Tree

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Tree

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Tree

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<__D: Fallible + ?Sized> Deserialize<Tree, __D> for Archived<Tree>

where Vec<Node>: Archive, <Vec<Node> as Archive>::Archived: Deserialize<Vec<Node>, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<Tree, <__D as Fallible>::Error>

Deserializes using the given deserializer

impl<__S: Fallible + ?Sized> Serialize<__S> for Tree

where Vec<Node>: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<Self as Archive>::Resolver, <__S as Fallible>::Error>

Writes the dependencies for the object and returns a resolver that can create the archived type.

impl Serialize for Tree

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.