Struct DenseLayer 

pub struct DenseLayer {
    pub n_inputs: usize,
    pub n_neurons: usize,
    pub length: usize,
    pub words_per_input: usize,
    pub weights: Vec<Vec<f64>>,
    packed_weights_flat: Vec<u64>,
    weight_seed: u64,
}

Vectorized stochastic dense layer.

Fields

n_inputs: usize

Number of input features.

n_neurons: usize

Number of output neurons.

length: usize

Bitstream length per encoded scalar.

words_per_input: usize

Words per packed input stream (ceil(length / 64)).

weights: Vec<Vec<f64>>

Probability-domain weights in [0, 1].

packed_weights_flat: Vec<u64>

Packed bitstream weights in row-major contiguous layout: [neuron][input][word].

weight_seed: u64

Implementations

impl DenseLayer

pub fn new(n_inputs: usize, n_neurons: usize, length: usize, seed: u64) -> Self

Create a layer with random weights sampled from U(0,1).

fn weight_slice(&self, neuron: usize, input: usize) -> &[u64]

Return a single [word] slice for one neuron/input pair.

pub fn get_weights(&self) -> Vec<Vec<f64>>

Return a copy of weight matrix.

pub fn set_weights(&mut self, weights: Vec<Vec<f64>>) -> Result<(), String>

Set probability weights and refresh packed representation.

pub fn refresh_packed_weights(&mut self)

Rebuild packed weight bitstreams from current weight matrix.

pub fn forward( &self, input_values: &[f64], seed: u64, ) -> Result<Vec<f64>, String>

Forward pass using stochastic bitstreams.

Returns one activation value per neuron.

pub fn forward_fast( &self, input_values: &[f64], seed: u64, ) -> Result<Vec<f64>, String>

Forward pass with parallel input encoding.

Each input is encoded with an independently-seeded RNG: seed + input_index (wrapping).

pub fn forward_fused( &self, input_values: &[f64], seed: u64, ) -> Result<Vec<f64>, String>

Forward pass with fused encode+AND+popcount.

This path avoids materializing encoded inputs and consumes each encoded word immediately against its corresponding weight words.

pub fn forward_batch_into( &self, inputs_flat: &[f64], n_samples: usize, seed: u64, output: &mut [f64], ) -> Result<(), String>

Batched forward pass writing into an existing row-major output buffer.

• inputs_flat: shape [n_samples, n_inputs]
• output: shape [n_samples, n_neurons]

pub fn forward_batch( &self, inputs_flat: &[f64], n_samples: usize, seed: u64, ) -> Result<Vec<f64>, String>

Batched forward pass: process N input vectors in one call.

inputs_flat is row-major: [n_samples, n_inputs]. Returns flat output: [n_samples, n_neurons].

pub fn forward_prepacked( &self, packed_inputs: &[Vec<u64>], ) -> Result<Vec<f64>, String>

Forward pass with pre-packed input bitstreams.

packed_inputs must have shape:

• outer length = n_inputs
• inner length = ceil(length / 64)

pub fn forward_prepacked_2d( &self, packed_flat: &[u64], n_inputs: usize, words: usize, ) -> Result<Vec<f64>, String>

Forward pass with pre-packed inputs from a 2-D contiguous array.

packed_flat is a flat row-major buffer of shape [n_inputs, words]. Each row is one input’s packed bitstream words.

pub fn forward_numpy_inner( &self, input_values: &[f64], seed: u64, ) -> Result<Vec<f64>, String>

Single-call dense forward with parallel Bernoulli encoding.

This mirrors forward_fast and exists for numpy-native Python bindings.

Trait Implementations

impl Clone for DenseLayer

fn clone(&self) -> DenseLayer

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DenseLayer

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

Formats the value using the given formatter.