Struct BlrCore 

pub struct BlrCore {
    pub rows: usize,
    pub cols: usize,
    pub paths: usize,
    pub rank: usize,
    pub h: Vec<Vec<f32>>,
    pub g: Vec<Vec<f32>>,
    pub l: Vec<Vec<f32>>,
    pub u_off: Vec<usize>,
    pub v_off: Vec<usize>,
}

Parsed header + f32 scales of a blr payload; kernels take the bytes.

Fields

rows: usize

cols: usize

paths: usize

rank: usize

h: Vec<Vec<f32>>

Per path: h (rows), g (cols), ℓ (rank), f32.

g: Vec<Vec<f32>>

l: Vec<Vec<f32>>

u_off: Vec<usize>

Per path: byte offsets of U (rows × r/8) and V (r × cols/8) in the payload.

v_off: Vec<usize>

Implementations

impl BlrCore

pub fn parse(shape: &[usize], bytes: &[u8]) -> Result<Self, String>

pub fn planes<'a>(&self, b: &'a [u8], p: usize) -> (&'a [u8], &'a [u8])

Sign bits of path p: (U, V) byte slices.

pub fn matvec( &self, bytes: &[u8], x: &[f32], out: &mut [f32], pool: Option<&Pool>, )

Single-vector product out[..rows] = W x.

pub fn matmat( &self, bytes: &[u8], xs: &[f32], b: usize, out: &mut [f32], pool: Option<&Pool>, )

Batched product: out[b·rows] = xs[b·cols] · Wᵀ.

pub fn row_f32(&self, bytes: &[u8], i: usize, dst: &mut [f32])

One row of W (embedding-style lookup; rare path).

pub fn add_col_scaled(&self, bytes: &[u8], c: usize, w: f32, out: &mut [f32])

One column of W: out[i] += w · W[i, c].