Struct CsrMatrixSetView 

pub struct CsrMatrixSetView<'a, T> { /* private fields */ }

An immutable view of a CSR matrix set for efficient read-only access.

This structure provides zero-cost abstraction access to multiple CSR matrices stored in a compact, consolidated format. It’s designed for scenarios where you need to read or process multiple sparse matrices without the overhead of copying data or creating separate matrix objects.

Use Cases

Views are particularly useful for:

Parallel Processing

use algebra_sparse::CsrMatrixSet;

let mut set = CsrMatrixSet::default();
// Add some matrices to the set
{
    let mut builder = set.new_matrix(3, 1e-10);
    builder.new_row().push(0, 1.0);
}
{
    let mut builder = set.new_matrix(2, 1e-10);
    builder.new_row().push(1, 2.0);
}

let view = set.as_view();
assert_eq!(view.len(),2);
let (left, right) = view.split_at(view.len() / 2);
assert_eq!(left.len(),1);
assert_eq!(right.len(),1);

Implementations

impl<'a, T> CsrMatrixSetView<'a, T>

pub fn get(self, index: usize) -> CsrMatrixView<'a, T>

Returns the view of the matrix at the given index.

Arguments

• index - Index of the matrix to retrieve

Returns

A CsrMatrixView representing the requested matrix

Panics

Panics if the index is out of bounds

pub fn len(&self) -> usize

Returns the number of matrices in the set.

pub fn is_empty(&self) -> bool

Returns true if the set contains no matrices.

pub fn split_at(self, index: usize) -> (Self, Self)

Splits the matrix set view into two at the given index.

This is a zero-cost operation that creates two independent views that reference the same underlying data but represent disjoint subsets of the matrices. The operation is O(1) and involves no copying or allocation of matrix data.

Arguments

• index - The split position. The left view will contain matrices at indices [0, index), and the right view will contain matrices at indices [index, len).

Returns

A tuple of two views: (left, right) where:

• left contains matrices 0..index
• right contains matrices index..len

Panics

Panics if index > len(). Splitting at index = 0 or index = len() is allowed and will return an empty view on one side.

Examples

use algebra_sparse::CsrMatrixSet;

let mut set = CsrMatrixSet::default();
// Add 3 matrices to the set
{
    let mut builder = set.new_matrix(2, 1e-10);
    builder.new_row().push(0, 1.0);
}
{
    let mut builder = set.new_matrix(2, 1e-10);
    builder.new_row().push(1, 2.0);
}
{
    let mut builder = set.new_matrix(2, 1e-10);
    builder.new_row().push(0, 3.0);
}

let view = set.as_view();

// Split in the middle
let (left, right) = view.split_at(1);
assert_eq!(left.len(), 1);  // matrices 0
assert_eq!(right.len(), 2); // matrices 1, 2

// Split at the beginning
let (empty, all) = view.split_at(0);
assert!(empty.is_empty());
assert_eq!(all.len(), 3);

// Split at the end
let (all, empty) = view.split_at(3);
assert_eq!(all.len(), 3);
assert!(empty.is_empty());

Parallel Processing

This method is particularly useful for parallel processing:

let view = set.as_view();
let midpoint = view.len() / 2;
let (left, right) = view.split_at(midpoint);

// Process halves independently (parallel processing example)
// This is conceptual - actual parallel processing would use rayon or similar

Memory Efficiency

Both resulting views share references to the same underlying data:

• No matrix data is copied during the split
• Both views have independent lifetimes

Trait Implementations

impl<'a, T: Clone> Clone for CsrMatrixSetView<'a, T>

fn clone(&self) -> CsrMatrixSetView<'a, T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a, T: Copy> Copy for CsrMatrixSetView<'a, T>