Struct PackedNode 

#[repr(C, align(4))]
pub struct PackedNode {
    pub value: f32,
    pub children: u32,
    pub feature_flags: u16,
    pub _reserved: u16,
}

12-byte packed decision tree node. AoS layout for cache-optimal inference.

5 nodes per 64-byte cache line (60 bytes used, 4 bytes padding). All fields for one traversal step are adjacent in memory — no cross-vector striding like the SoA TreeArena used during training.

Field layout

• value: split threshold (internal nodes) or leaf prediction (leaf nodes). For leaves, the learning rate is already baked in: value = lr * leaf_f64 as f32.
• children: packed left (low u16) and right (high u16) child indices. For leaves, this field is unused (set to 0).
• feature_flags: bit 15 = is_leaf flag. Bits 14:0 = feature index (max 32767). For leaves, the feature index is unused.
• _reserved: padding for future use (categorical flag, metadata, etc.).

Fields

value: f32

Split threshold (internal) or prediction value (leaf, with lr baked in).

children: u32

Packed children: left = low u16, right = high u16.

feature_flags: u16

Bit 15 = is_leaf. Bits 14:0 = feature index.

_reserved: u16

Reserved for future use.

Implementations

impl PackedNode

pub const LEAF_FLAG: u16 = 0x8000

Bit mask for the is_leaf flag in feature_flags.

pub const fn leaf(value: f32) -> Self

Create a leaf node with a prediction value.

pub const fn split( threshold: f32, feature_idx: u16, left: u16, right: u16, ) -> Self

Create an internal (split) node.

pub const fn is_leaf(&self) -> bool

Returns true if this is a leaf node.

pub const fn feature_idx(&self) -> u16

Feature index (bits 14:0). Only meaningful for internal nodes.

pub const fn left_child(&self) -> u16

Left child index (low 16 bits of children).

pub const fn right_child(&self) -> u16

Right child index (high 16 bits of children).

Trait Implementations

impl Clone for PackedNode

fn clone(&self) -> PackedNode

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PackedNode

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

Formats the value using the given formatter.

impl PartialEq for PackedNode

fn eq(&self, other: &PackedNode) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for PackedNode

impl StructuralPartialEq for PackedNode