Struct SparseSynapticMap 

pub struct SparseSynapticMap<const N: usize> {
    pub row_ptr: Vec<usize>,
    pub col_indices: Vec<u16>,
    pub values: Vec<f32>,
}

Compressed Sparse Row representation of the synaptic weight matrix.

Generic over N (number of neurons) to support both small channel routers and full 2048-neuron routing fabrics.

N must be at most MAX_SPARSE_NEURONS (65,536): target index 65,535 is representable as u16, target 65,536 is not. Constructors and insertion APIs reject out-of-range or non-u16 indices rather than truncating them into a different valid connection.

Fields

row_ptr: Vec<usize>

Row pointers: row_ptr[i] gives the start index in col_indices/values for neuron i. Length is N + 1.

col_indices: Vec<u16>

Column indices: target neuron for each non-zero entry.

values: Vec<f32>

Non-zero weight values.

Implementations

impl<const N: usize> SparseSynapticMap<N>

pub fn new() -> Self

Create an empty sparse synaptic map with N neurons.

Panics

Panics if N exceeds MAX_SPARSE_NEURONS. Prefer SparseSynapticMap::try_new for a recoverable error.

pub fn try_new() -> Result<Self>

Fallible constructor that rejects an N larger than the u16 target address space.

pub fn from_dense(matrix: &[[f32; N]; N], sparsity_threshold: f32) -> Self

Build from a dense weight matrix (for migration from dense representations).

Panics

Panics if N exceeds MAX_SPARSE_NEURONS.

pub fn try_from_dense( matrix: &[[f32; N]; N], sparsity_threshold: f32, ) -> Result<Self>

Fallible counterpart of SparseSynapticMap::from_dense.

pub fn from_adjacency(adjacency: &[Vec<Synapse>]) -> Self

Build from explicit adjacency lists.

Panics

Panics if N is unsupported, adjacency.len() is not N, or any stored target is >= N. Prefer SparseSynapticMap::try_from_adjacency.

pub fn try_from_adjacency(adjacency: &[Vec<Synapse>]) -> Result<Self>

Fallible counterpart of SparseSynapticMap::from_adjacency.

pub fn get_row(&self, row: usize) -> impl Iterator<Item = (u16, f32)> + '_

Get all synapses for a given neuron (row).

pub fn get_weight(&self, row: usize, col: usize) -> f32

Get the weight from neuron row to neuron col. Returns 0.0 if not connected.

pub fn set_weight( &mut self, row: usize, col: usize, weight: f32, sparsity_threshold: f32, )

Update a single synaptic weight. Creates the connection if it doesn’t exist (when weight exceeds threshold) or removes it (when weight drops below).

Panics

Panics if row or col is >= N, or if col cannot be represented as u16. Prefer SparseSynapticMap::try_set_weight.

pub fn try_set_weight( &mut self, row: usize, col: usize, weight: f32, sparsity_threshold: f32, ) -> Result<()>

Fallible counterpart of SparseSynapticMap::set_weight.

On error the map is left unchanged.

pub fn nnz(&self) -> usize

Number of non-zero synapses.

pub fn sparsity(&self) -> f32

Sparsity ratio: fraction of zero entries in the full $N \times N$ matrix.

The denominator is computed in u64 so N = 65_536 does not overflow usize on 32-bit targets (65_536² = 2³²).

pub fn to_dense(&self) -> [[f32; N]; N]

Convert back to dense matrix (for debugging / interoperability).

pub fn to_gpu_arrays(&self) -> (Vec<u32>, Vec<u32>, Vec<f32>)

Export as GPU-ready flat arrays for kernel launch. Returns (row_ptr, col_indices, values) as owned vectors.

Panics

Panics if a row-pointer offset exceeds u32::MAX. Prefer SparseSynapticMap::try_to_gpu_arrays.

pub fn try_to_gpu_arrays(&self) -> Result<(Vec<u32>, Vec<u32>, Vec<f32>)>

Fallible counterpart of SparseSynapticMap::to_gpu_arrays.

Trait Implementations

impl<const N: usize> Clone for SparseSynapticMap<N>

fn clone(&self) -> SparseSynapticMap<N>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<const N: usize> Debug for SparseSynapticMap<N>

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

Formats the value using the given formatter.

impl<const N: usize> Default for SparseSynapticMap<N>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, const N: usize> Deserialize<'de> for SparseSynapticMap<N>

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<const N: usize> Serialize for SparseSynapticMap<N>

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.