Struct LinearSegment 

pub struct LinearSegment {
    pub weights: Vec<f32>,
    pub in_dim: usize,
    pub out_dim: usize,
}

A simple fully-connected (linear/dense) layer operating on flat f32 vectors.

Implements the linear transformation y = W x (no bias) where W is a [out_dim × in_dim] matrix stored in row-major order.

This is primarily intended for testing gradient-checkpointing mechanics without pulling in heavy tensor libraries.

Fields

weights: Vec<f32>

Weight matrix stored row-major: weights[i * in_dim + j] = W[i, j].

in_dim: usize

Number of input features.

out_dim: usize

Number of output features.

Implementations

impl LinearSegment

pub fn new(weights: Vec<f32>, in_dim: usize, out_dim: usize) -> Self

Create a LinearSegment from explicit weights.

Panics (debug only)

Panics if weights.len() != in_dim * out_dim.

pub fn random_init(in_dim: usize, out_dim: usize, seed: u64) -> Self

Initialise weights pseudo-randomly using a simple 64-bit LCG.

The LCG parameters (multiplier / increment) are the same as used by Knuth and Numerical Recipes. Weights are scaled to [-1, 1] using Xavier-style normalisation: w ∈ [-sqrt(6/(in+out)), sqrt(6/(in+out))].

No external rand crate is required.

Trait Implementations

impl Clone for LinearSegment

fn clone(&self) -> LinearSegment

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Recomputable for LinearSegment

fn forward(&self, input: &Vec<f32>) -> Vec<f32>

Compute y = W x where x has length in_dim and y has length out_dim.

fn input_memory_bytes(input: &Vec<f32>) -> usize

Each f32 is 4 bytes.

type Input = Vec<f32>

The input type accepted by this segment.

type Output = Vec<f32>

The output type produced by this segment.