Struct SublinearNeumannSolver 

pub struct SublinearNeumannSolver { /* private fields */ }

Sublinear Neumann series solver

Implementations

impl SublinearNeumannSolver

pub fn new(config: SublinearConfig) -> Self

Create a new sublinear Neumann solver

pub fn with_max_terms(self, max_terms: usize) -> Self

Create solver with custom term limit

pub fn solve_sublinear_guaranteed( &self, matrix: &dyn Matrix, b: &[Precision], ) -> Result<SublinearNeumannResult>

Solve with guaranteed O(log n) complexity

Algorithm:

1. Verify matrix is diagonally dominant (required for convergence)
2. Apply Johnson-Lindenstrauss dimension reduction: n → k = O(log n)
3. Solve reduced system: (I - M_k)x_k = D_k^{-1}b_k using O(log k) terms
4. Reconstruct solution in original space
5. Apply Richardson extrapolation for accuracy

Total complexity: O(log n) matrix operations + O(n) dimension reduction = O(n) But for well-conditioned matrices, can achieve O(log n) through adaptive sampling

Trait Implementations

impl Clone for SublinearNeumannSolver

fn clone(&self) -> SublinearNeumannSolver

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Complexity for SublinearNeumannSolver

const CLASS: ComplexityClass

Worst-case complexity class on a single-query call. For iterative solvers this is the per-iter cost; the iteration count is bounded by other configuration (max_iterations, tolerance, ef_construction).

const DETAIL: &'static str = "O(log n) per single-entry query on diagonally-dominant systems via JL + recursive Neumann; \ O(n) base case at n ≤ base_case_threshold."

Optional human-readable detail for documentation / MCP tool schemas. Defaults to the short label of CLASS. Override when there’s a non-obvious constant or k-bound.

impl Debug for SublinearNeumannSolver

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

Formats the value using the given formatter.

impl SublinearSolver for SublinearNeumannSolver

fn verify_sublinear_conditions( &self, matrix: &dyn Matrix, ) -> Result<ComplexityBound>

Verify that the matrix satisfies conditions for sublinear complexity

fn solve_sublinear( &self, matrix: &dyn Matrix, b: &[Precision], config: &SublinearConfig, ) -> Result<Vec<Precision>>

Solve with guaranteed sublinear complexity

fn complexity_bound(&self) -> ComplexityBound

Get the actual complexity bound achieved