Enum SparseCow 

pub enum SparseCow<'a, T, F, Arch>
where
    T: Send + Sync,
    F: CowFormat,
    Arch: SimdArch,
{
    Borrowed(SparseView<'a, T, F, Arch>),
    Owned(<F as CowFormat>::Owned<T>),
}

Clone-on-Write sparse matrix, generic over the storage format F.

Borrowed wraps a zero-copy SparseView; Owned holds heap-backed storage. Reads never allocate; SparseCow::to_owned promotes exactly once.

Examples

use hermes_simd_core::{Csr, CsrData, Validated};
use hermes_simd_core::sparse::{SparseCow, SparseSpMv};
use hermes_simd_intrinsics::Scalar;

let values = [1.0_f64, 2.0, 3.0];
let col_indices = [0, 2, 1];
let row_ptr = [0, 2, 3];
let data = CsrData::new(&values, &col_indices, &row_ptr, 2, 3);
let matrix = SparseCow::<f64, Validated<Csr>, Scalar>::try_borrowed(data).unwrap();

let x = [10.0, 20.0, 30.0];
let mut y = [0.0; 2];
matrix.spmv(&x, &mut y);

assert_eq!(matrix.nrows(), 2);
assert_eq!(matrix.ncols(), 3);
assert!(matrix.is_borrowed());
assert_eq!(y, [70.0, 60.0]);

Variants

Borrowed(SparseView<'a, T, F, Arch>)

Zero-copy borrowed view.

Owned(<F as CowFormat>::Owned<T>)

Owned heap-backed storage.

Implementations

impl<'a, T, F, Arch> SparseCow<'a, T, F, Arch>

where T: Send + Sync, F: CowFormat, Arch: SimdArch,

pub fn borrowed( data: <F as SparseFormat>::Storage<'a, T>, ) -> SparseCow<'a, T, F, Arch>

Wrap borrowed view storage (zero allocation).

pub fn owned(storage: <F as CowFormat>::Owned<T>) -> SparseCow<'a, T, F, Arch>

Wrap owned storage (already heap-allocated).

pub fn nrows(&self) -> usize

Number of rows.

pub fn ncols(&self) -> usize

Number of columns.

pub fn is_borrowed(&self) -> bool

Returns true if this holds a borrowed view (no heap allocation).

pub fn is_owned(&self) -> bool

Returns true if this holds heap-owned data.

pub fn to_owned(&mut self)

where T: Clone,

Promote to owned, cloning from the borrowed view if needed.

Idempotent: an already-owned container is left untouched.

impl<'a, T, F, Arch> SparseCow<'a, T, Validated<F>, Arch>

where T: Send + Sync, F: CowFormat, Arch: SimdArch, <F as SparseFormat>::Storage<'a, T>: SparseValidate,

pub fn try_borrowed( data: <F as SparseFormat>::Storage<'a, T>, ) -> Result<SparseCow<'a, T, Validated<F>, Arch>, SimdError>

Validate borrowed storage and wrap it in a zero-copy sparse Cow.

Errors

Returns the format-specific validation error if data is malformed.

impl<'a, T, Arch> SparseCow<'a, T, Csr, Arch>

where T: Send + Sync + Clone, Arch: SimdArch,

pub fn from_slices( values: &[T], col_indices: &[i32], row_ptr: &[i32], nrows: usize, ncols: usize, ) -> SparseCow<'a, T, Csr, Arch>

Build an owned CSR Cow from slices.

impl<'a, T, Arch> SparseCow<'a, T, Validated<Csr>, Arch>

where T: Send + Sync + Clone, Arch: SimdArch,

pub fn from_slices( values: &[T], col_indices: &[i32], row_ptr: &[i32], nrows: usize, ncols: usize, ) -> Result<SparseCow<'a, T, Validated<Csr>, Arch>, SimdError>

Build an owned validated CSR Cow from slices.

Errors

Returns the CSR validation error if the sparse structure is malformed.

impl<'a, T, const C: usize, Arch> SparseCow<'a, T, SellP<C>, Arch>

where T: Send + Sync + Clone, Arch: SimdArch,

pub fn from_slices( values: &[T], col_indices: &[i32], slice_ptr: &[i32], slice_col_count: &[i32], nrows: usize, ncols: usize, ) -> SparseCow<'a, T, SellP<C>, Arch>

Build an owned SELL-p Cow from slices.

impl<'a, T, const C: usize, Arch> SparseCow<'a, T, Validated<SellP<C>>, Arch>

where T: Send + Sync + Clone, Arch: SimdArch,

pub fn from_slices( values: &[T], col_indices: &[i32], slice_ptr: &[i32], slice_col_count: &[i32], nrows: usize, ncols: usize, ) -> Result<SparseCow<'a, T, Validated<SellP<C>>, Arch>, SimdError>

Build an owned validated SELL-p Cow from slices.

Errors

Returns the SELL-p validation error if the sparse structure is malformed.

impl<'a, T, const BM: usize, const BN: usize, Arch> SparseCow<'a, T, BlockedCoo<BM, BN>, Arch>

where T: Send + Sync + Clone, Arch: SimdArch,

pub fn from_slices( blocks: &[T], block_row: &[i32], block_col: &[i32], nblocks: usize, nrows: usize, ncols: usize, ) -> SparseCow<'a, T, BlockedCoo<BM, BN>, Arch>

Build an owned Blocked-COO Cow from slices.

impl<'a, T, const BM: usize, const BN: usize, Arch> SparseCow<'a, T, Validated<BlockedCoo<BM, BN>>, Arch>

where T: Send + Sync + Clone, Arch: SimdArch,

pub fn from_slices( blocks: &[T], block_row: &[i32], block_col: &[i32], nblocks: usize, nrows: usize, ncols: usize, ) -> Result<SparseCow<'a, T, Validated<BlockedCoo<BM, BN>>, Arch>, SimdError>

Build an owned validated Blocked-COO Cow from slices.

Errors

Returns the Blocked-COO validation error if the sparse structure is malformed.

impl<'a, T, Arch> SparseCow<'a, T, DenseWithMask, Arch>

where T: Send + Sync + Clone, Arch: SimdArch,

pub fn from_slices( values: &[T], mask: &[bool], nrows: usize, ncols: usize, ) -> SparseCow<'a, T, DenseWithMask, Arch>

Build an owned DenseWithMask Cow from slices.

Trait Implementations

impl<'a, T, F, Arch> SparseOps<T> for SparseCow<'a, T, F, Arch>

where T: NumericElement, F: CowFormat, Arch: SimdArch, SparseView<'b, T, F, Arch>: for<'b> SparseOps<T>,

fn sum_values(&self) -> T

Compute the sum of all elements stored in the sparse matrix.

fn elementwise_mul_dense(&self, dense: &[T], out_values: &mut [T])

Elementwise multiply the sparse matrix values by corresponding entries in a dense matrix, writing the results to out_values.

impl<'a, T, F, Arch> SparseSpMv<T> for SparseCow<'a, T, F, Arch>

where T: NumericElement, F: CowFormat, Arch: SimdArch, SparseView<'b, T, F, Arch>: for<'b> SparseSpMv<T>,

fn spmv(&self, x: &[T], y: &mut [T])

Perform matrix-vector multiplication: y += A * x.

impl<'a, T, F, Arch> SparseValidate for SparseCow<'a, T, F, Arch>

where T: Send + Sync, F: CowFormat, Arch: SimdArch, <F as SparseFormat>::Storage<'b, T>: for<'b> SparseValidate, <F as CowFormat>::Owned<T>: SparseValidate,

fn validate(&self) -> Result<(), SimdError>

Validate structural correctness and bounds checks.