Struct NeumannSolver 

pub struct NeumannSolver {
    pub tolerance: f64,
    pub max_iterations: usize,
}

Neumann Series solver for sparse linear systems.

Computes x = sum_{k=0}^{K} (I - A)^k * b by maintaining a residual vector and accumulating partial sums until convergence.

Example

use ruvector_solver::types::CsrMatrix;
use ruvector_solver::neumann::NeumannSolver;

// Diagonally dominant 2x2: A = [[2, -0.5], [-0.5, 2]]
let a = CsrMatrix::<f32>::from_coo(2, 2, vec![
    (0, 0, 2.0_f32), (0, 1, -0.5_f32),
    (1, 0, -0.5_f32), (1, 1, 2.0_f32),
]);
let b = vec![1.0_f32, 1.0];

let solver = NeumannSolver::new(1e-6, 500);
let result = solver.solve(&a, &b).unwrap();
assert!(result.residual_norm < 1e-4);

Fields

tolerance: f64

Target residual L2 norm for convergence.

max_iterations: usize

Maximum number of iterations before giving up.

Implementations

impl NeumannSolver

pub fn new(tolerance: f64, max_iterations: usize) -> Self

Create a new NeumannSolver.

Arguments

• tolerance - Stop when ||r|| < tolerance.
• max_iterations - Upper bound on iterations.

pub fn estimate_spectral_radius(matrix: &CsrMatrix<f32>) -> f64

Estimate the spectral radius of M = I - D^{-1}A via 10-step power iteration.

Runs [POWER_ITERATION_STEPS] iterations of the power method on the Jacobi iteration matrix M = I - D^{-1}A. Returns the Rayleigh-quotient estimate of the dominant eigenvalue magnitude.

Arguments

• matrix - The coefficient matrix A (must be square).

Returns

Estimated |lambda_max(I - D^{-1}A)|. If this is >= 1.0, the Jacobi-preconditioned Neumann series will diverge.

pub fn solve( &self, matrix: &CsrMatrix<f32>, rhs: &[f32], ) -> Result<SolverResult, SolverError>

Core Jacobi-preconditioned Neumann-series solve operating on f32.

Validates inputs, checks the spectral radius of I - D^{-1}A via power iteration, then runs the iteration returning a SolverResult.

Errors

• SolverError::InvalidInput if the matrix is non-square or the RHS length does not match.
• SolverError::SpectralRadiusExceeded if rho(I - D^{-1}A) >= 1.
• SolverError::NumericalInstability if the residual grows by more than 2x in a single step.
• SolverError::NonConvergence if the iteration budget is exhausted.

Trait Implementations

impl Clone for NeumannSolver

fn clone(&self) -> NeumannSolver

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for NeumannSolver

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

Formats the value using the given formatter.

impl SolverEngine for NeumannSolver

fn solve( &self, matrix: &CsrMatrix<f64>, rhs: &[f64], budget: &ComputeBudget, ) -> Result<SolverResult, SolverError>

Solve via the Neumann series.

Adapts the f64 trait interface to the internal f32 solver by converting the input matrix and RHS, running the solver, then returning the f32 solution.

fn estimate_complexity( &self, profile: &SparsityProfile, n: usize, ) -> ComplexityEstimate

Estimate the computational cost of solving the given system without actually performing the solve.

fn algorithm(&self) -> Algorithm

Return the algorithm identifier for this engine.