Struct HostCsr 

pub struct HostCsr {
    pub nrows: usize,
    pub ncols: usize,
    pub row_ptr: Vec<usize>,
    pub col_indices: Vec<usize>,
    pub values: Vec<f64>,
}

A square or rectangular sparse matrix stored on the host in CSR layout.

Column indices within each row are kept sorted in ascending order, which the numeric kernels rely on for efficient merging. All values are f64; the advanced solvers accumulate in double precision regardless of the storage precision of any originating device matrix.

Fields

nrows: usize

Number of rows.

ncols: usize

Number of columns.

row_ptr: Vec<usize>

Row pointer array of length nrows + 1.

col_indices: Vec<usize>

Column indices of length nnz, sorted ascending within each row.

values: Vec<f64>

Non-zero values of length nnz.

Implementations

impl HostCsr

pub fn new( nrows: usize, ncols: usize, row_ptr: Vec<usize>, col_indices: Vec<usize>, values: Vec<f64>, ) -> SparseResult<Self>

Builds a host CSR matrix from raw arrays, validating the structure.

Errors

Returns SparseError::InvalidFormat if the array lengths are inconsistent, row_ptr is not monotone, or a column index is out of range.

pub fn from_gpu<T: GpuFloat>(matrix: &CsrMatrix<T>) -> SparseResult<Self>

Downloads a GPU CSR matrix into a host CSR matrix.

The values are converted to f64. Column indices within each row are sorted ascending so the host kernels can merge rows efficiently.

Errors

Returns SparseError::Cuda on a device-to-host transfer failure.

pub fn to_gpu<T: GpuFloat>(&self) -> SparseResult<CsrMatrix<T>>

Materialises this host matrix onto the device as a GPU CSR matrix.

Empty matrices are rejected because the device format forbids zero nnz.

Errors

Returns SparseError::ZeroNnz if the matrix has no stored entries, or SparseError::Cuda on an allocation/transfer failure.

pub fn nnz(&self) -> usize

Number of stored non-zeros.

pub fn get(&self, row: usize, col: usize) -> Option<f64>

Returns the value at (row, col) if present, else None.

pub fn diagonal(&self) -> Vec<f64>

Extracts the main diagonal as a dense vector of length min(nrows, ncols).

pub fn matvec(&self, x: &[f64]) -> Vec<f64>

Computes y = A * x for a dense vector x of length ncols.

The output has length nrows. This is the host SpMV reference reused by every iterative method in the module.

pub fn transpose(&self) -> HostCsr

Returns the transpose Aᵀ as a new host CSR matrix.

Used to form the restriction operator R = Pᵀ in algebraic multigrid.

pub fn matmul(&self, rhs: &HostCsr) -> SparseResult<HostCsr>

Computes the sparse-sparse product C = A * B.

This is the host counterpart of the crate’s GPU SpGEMM (symbolic + numeric phases) and is the workhorse of the algebraic-multigrid Galerkin triple product Pᵀ A P. The implementation uses a per-row dense accumulator (sparse accumulator / SPA) with a touched-column list, which is the standard Gustavson formulation.

Errors

Returns SparseError::DimensionMismatch if self.ncols != rhs.nrows.

pub fn to_dense(&self) -> Vec<f64>

Converts the matrix to a dense row-major nrows × ncols array.

Intended for small matrices (coarse-level operators, test assertions).

Trait Implementations

impl Clone for HostCsr

fn clone(&self) -> HostCsr

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for HostCsr

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

Formats the value using the given formatter.

impl PartialEq for HostCsr

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