Struct PackedNodeI16 

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

8-byte quantized decision tree node. Integer-only traversal for FPU-less targets.

8 nodes per 64-byte cache line. All comparisons are i16 — no floating point in the hot loop. On Cortex-M0+ (no FPU), this is ~25x faster than f32.

Field layout

• value: quantized split threshold (internal nodes) or quantized leaf prediction (leaf nodes). For splits: (threshold * feature_scale[feat_idx]) as i16. For leaves: (lr * leaf_f64 * leaf_scale) as i16.
• feature_flags: bit 15 = is_leaf flag. Bits 14:0 = feature index (max 32767). For leaves, the feature index is unused.
• children: packed left (low u16) and right (high u16) child indices. For leaves, this field is unused (set to 0).

Fields

value: i16

Quantized split threshold (internal) or quantized leaf prediction (leaf).

feature_flags: u16

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

children: u32

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

Implementations

impl PackedNodeI16

pub const LEAF_FLAG: u16 = 0x8000

Bit mask for the is_leaf flag in feature_flags.

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

Create a leaf node with a quantized prediction value.

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

Create an internal (split) node with a quantized threshold.

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 PackedNodeI16

fn clone(&self) -> PackedNodeI16

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PackedNodeI16

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

Formats the value using the given formatter.

impl Hash for PackedNodeI16

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for PackedNodeI16

fn eq(&self, other: &PackedNodeI16) -> 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 PackedNodeI16

impl Eq for PackedNodeI16

impl StructuralPartialEq for PackedNodeI16