Struct GenericCsrOp 

pub struct GenericCsrOp<S: KrystScalar> { /* private fields */ }

Available on crate feature backend-faer only.

Scalar-generic CSR linear operator backed by ScalarCsrMatrix.

This wrapper tracks StructureId/ValuesId so callers can mutate the owned matrix and keep format caches valid. After any in-place edits, call mark_structure_changed or mark_values_changed before reusing the operator in cached conversions.

The operator wires the scalar-polymorphic sparse matrix storage into the LinOp trait by constructing an SpmvPlan at creation time. Real builds continue to select SIMD kernels when available while complex builds transparently fall back to the portable scalar path.

Implementations

impl<S: KrystScalar> GenericCsrOp<S>

pub fn new(matrix: Arc<ScalarCsrMatrix<S>>, tuning: &SpmvTuning) -> Self

Wraps an Arc around the provided matrix and builds an SpMV plan using the supplied tuning parameters.

pub fn from_matrix(matrix: ScalarCsrMatrix<S>, tuning: &SpmvTuning) -> Self

Builds an operator from an owned matrix by first wrapping it in an Arc for cheap cloning.

pub fn from_real_csr(real: &CsrMatrix<f64>, tuning: &SpmvTuning) -> Self

where S: KrystScalar<Real = f64>,

Lifts a real-valued CSR matrix into the active scalar domain.

This clones the underlying structure and converts the numeric values through KrystScalar::from_real, enabling solvers in complex builds to reuse pre-existing f64 sparsity patterns without reassembly.

pub fn matrix(&self) -> &ScalarCsrMatrix<S>

Returns the underlying CSR matrix.

pub fn plan(&self) -> &ScalarSpmvPlan<S>

Returns a reference to the cached SpMV plan.

pub fn rebuild_plan(&mut self, tuning: &SpmvTuning)

Rebuilds the internal SpMV plan using the latest tuning parameters.

pub fn with_comm(self, comm: UniverseComm) -> Self

Attaches a communicator to the operator, mirroring the legacy API.

pub fn with_layout(self, layout: DistLayout) -> Self

Attach a distributed layout to this operator.

pub fn mark_structure_changed(&self)

Marks the sparsity pattern as changed for cache bookkeeping.

pub fn mark_values_changed(&self)

Marks only the numeric values as changed.

Trait Implementations

impl KLinOp for GenericCsrOp<Complex64>

Available on crate feature complex only.

type Scalar = Complex<f64>

fn dims(&self) -> (usize, usize)

Dimensions of the operator (nrows, ncols).

fn matvec_s( &self, x: &[Complex64], y: &mut [Complex64], _scratch: &mut BridgeScratch, )

Perform y <- A x.

fn supports_t_matvec_s(&self) -> bool

Whether the operator exposes a transpose/adjoint matvec.

fn t_matvec_s( &self, x: &[Complex64], y: &mut [Complex64], _scratch: &mut BridgeScratch, )

Perform y <- A^T x (or A^H x in complex builds).

impl<S: KrystScalar> LinOp for GenericCsrOp<S>

type S = S

fn dims(&self) -> (usize, usize)

Dimensions (rows, cols).

fn matvec(&self, x: &[S], y: &mut [S])

Compute y = A x.

fn try_matvec(&self, x: &[S], y: &mut [S]) -> Result<(), KError>

Fallible matvec. Default delegates to matvec and returns Ok(()). Implementations that can detect/return errors should override this.

fn as_any(&self) -> &dyn Any

Downcast hook for specialized solvers/preconditioners.

fn structure_id(&self) -> StructureId

Changes when the nonzero pattern / shape changes. Default 0 -> unknown; higher layers may fall back to pointer identity.

fn values_id(&self) -> ValuesId

Changes when only numerical values change. Default 0 -> unknown.

fn comm(&self) -> UniverseComm

Parallel communicator for this operator.

fn dist_layout(&self) -> Option<&DistLayout>

Optional distributed layout metadata for MPI-enabled operators.

fn format(&self) -> OpFormat

Operator storage format, if known.

fn supports_transpose(&self) -> bool

Whether this operator supports t_matvec.

fn t_matvec(&self, _x: &[Self::S], _y: &mut [Self::S])

Optional transpose/adjoint matvec. Default panics if unsupported.

fn halo_exchange(&self) -> Option<&dyn HaloExchange<Self::S>>

Optional halo exchange support for operator-aligned vectors.

impl LinOpF64 for GenericCsrOp<f64>

fn dims(&self) -> (usize, usize)

fn matvec(&self, x: &[f64], y: &mut [f64])