Struct SparseVec 

pub struct SparseVec { /* private fields */ }

A sparse ternary vector using COO (Coordinate) format.

Only non-zero values are stored, making this efficient for vectors where most elements are zero (high sparsity).

Storage

Non-zero indices are stored separately for positive and negative values:

• positive_indices: indices where value is +1
• negative_indices: indices where value is -1

When to Use

Use SparseVec when sparsity > 90% for memory efficiency. Use PackedTritVec for denser vectors or when operations like dot product need consistent O(n) time regardless of sparsity.

Examples

use trit_vsa::{SparseVec, Trit};

let mut vec = SparseVec::new(1000);
vec.set(10, Trit::P);
vec.set(500, Trit::N);

assert_eq!(vec.get(10), Trit::P);
assert_eq!(vec.get(500), Trit::N);
assert_eq!(vec.get(0), Trit::Z);
assert_eq!(vec.count_nonzero(), 2);

Implementations

impl SparseVec

pub fn new(num_dims: usize) -> SparseVec

Create a new sparse vector with given dimension count.

All values are initialized to zero (no storage needed).

pub fn from_indices( positive_indices: Vec<usize>, negative_indices: Vec<usize>, num_dims: usize, ) -> Result<SparseVec, TernaryError>

Create from separate index lists.

Arguments

• positive_indices - Indices where value is +1
• negative_indices - Indices where value is -1
• num_dims - Logical dimension count

Errors

Returns error if any index is out of bounds or if there are duplicates across positive and negative lists.

pub fn from_trits(trits: &[Trit]) -> SparseVec

Create from a slice of trits.

pub fn from_packed(packed: &PackedTritVec) -> SparseVec

Create from a PackedTritVec.

pub const fn len(&self) -> usize

Get the number of logical dimensions.

pub const fn is_empty(&self) -> bool

Check if the vector is empty.

pub fn set(&mut self, dim: usize, value: Trit)

Set a dimension to a trit value.

Panics

Panics if dim >= len().

pub fn get(&self, dim: usize) -> Trit

Get the trit value at a dimension.

Panics

Panics if dim >= len().

pub fn count_nonzero(&self) -> usize

Count non-zero elements.

pub fn count_positive(&self) -> usize

Count positive (+1) elements.

pub fn count_negative(&self) -> usize

Count negative (-1) elements.

pub fn sparsity(&self) -> f32

Calculate sparsity (fraction of zeros).

pub fn dot(&self, other: &SparseVec) -> i32

Compute dot product with another sparse vector.

This is O(k1 + k2) where k1 and k2 are the number of non-zero elements.

Panics

Panics if vectors have different dimensions.

pub fn dot_packed(&self, other: &PackedTritVec) -> i32

Compute dot product with a packed vector.

Efficient when this sparse vector has few non-zeros.

Panics

Panics if vectors have different dimensions.

pub fn sum(&self) -> i32

Compute the sum of all elements.

pub fn negated(&self) -> SparseVec

Return a negated copy.

pub fn positive_indices(&self) -> &[usize]

Get reference to positive indices.

pub fn negative_indices(&self) -> &[usize]

Get reference to negative indices.

pub fn to_packed(&self) -> PackedTritVec

Convert to a PackedTritVec.

pub fn to_trits(&self) -> Vec<Trit>

Convert to a vector of trits.

pub fn memory_bytes(&self) -> usize

Memory size in bytes (approximate).

Trait Implementations

impl Clone for SparseVec

fn clone(&self) -> SparseVec

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SparseVec

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for SparseVec

fn deserialize<__D>( __deserializer: __D, ) -> Result<SparseVec, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for SparseVec

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for SparseVec