Struct Poly 

pub struct Poly<I, T> { /* private fields */ }

Polynomial preconditioner M^{-1} = p(A).

Stores an owned copy of A and the polynomial coefficients. Apply is a sequence of sparse matvecs and vector updates with no triangular solves and no heap allocation. See the module documentation for guidance.

Implementations

impl<I: Index, T: ComplexField> Poly<I, T>

pub fn try_new( a: SparseColMatRef<'_, I, T>, params: PolyParams, ) -> Result<Self, PolyError>

Build a polynomial preconditioner with an explicit PolyKind.

Errors

• PolyError::NonSquareMatrix if a is not square.
• PolyError::ZeroDegree if degree is zero.
• PolyError::InvalidOmega / PolyError::InvalidBounds if the kind parameters are out of range.

pub fn try_new_auto( a: SparseColMatRef<'_, I, T>, degree: usize, estimate: BoundEstimate, ) -> Result<Self, PolyError>

Build a Chebyshev preconditioner, estimating the spectral interval with estimate.

Chebyshev acceleration is only as good as its bounds; see BoundEstimate. For precise control pass BoundEstimate::Manual or use Poly::try_new with PolyKind::Chebyshev.

Errors

As Poly::try_new, plus PolyError::InvalidBounds if the estimate does not yield a usable 0 < lambda_min < lambda_max.

pub fn refactorize( &mut self, a: SparseColMatRef<'_, I, T>, ) -> Result<(), PolyError>

Refactorise against a new matrix with the same sparsity pattern.

Updates the stored operator values in place. If the preconditioner was built via Poly::try_new_auto, the spectral bounds are re-estimated from the new values; otherwise the original PolyKind is retained.

Errors

PolyError::PatternMismatch if a’s shape or column lengths disagree with the stored pattern.

impl<I, T> Poly<I, T>

pub fn dim(&self) -> usize

Dimension n of the preconditioner.

pub fn degree(&self) -> usize

Polynomial degree (number of matvecs per apply).

Trait Implementations

impl<I, T> BiLinOp<T> for Poly<I, T>

where I: Index, T: ComplexField + Debug + Sync,

fn transpose_apply_scratch(&self, rhs_ncols: usize, _par: Par) -> StackReq

computes the workspace layout required to apply the transpose or adjoint o self to a matrix with rhs_ncols columns

fn transpose_apply( &self, out: MatMut<'_, T>, rhs: MatRef<'_, T>, par: Par, stack: &mut MemStack, )

applies the transpose of self to rhs, and stores the result in out

fn adjoint_apply( &self, out: MatMut<'_, T>, rhs: MatRef<'_, T>, par: Par, stack: &mut MemStack, )

applies the adjoint of self to rhs, and stores the result in out

impl<I, T> BiPrecond<T> for Poly<I, T>

where I: Index, T: ComplexField + Debug + Sync,

fn transpose_apply_in_place_scratch( &self, rhs_ncols: usize, _par: Par, ) -> StackReq

computes the workspace layout required to apply the transpose or adjoint of self to a matrix with rhs_ncols columns in place

fn transpose_apply_in_place( &self, rhs: MatMut<'_, T>, par: Par, stack: &mut MemStack, )

applies the transpose of self to rhs, and stores the result in rhs

fn adjoint_apply_in_place( &self, rhs: MatMut<'_, T>, par: Par, stack: &mut MemStack, )

applies the adjoint of self to rhs, and stores the result in rhs

impl<I: Clone, T: Clone> Clone for Poly<I, T>

fn clone(&self) -> Poly<I, T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<I: Debug, T: Debug> Debug for Poly<I, T>

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

Formats the value using the given formatter.

impl<I, T> LinOp<T> for Poly<I, T>

where I: Index, T: ComplexField + Debug + Sync,

fn apply_scratch(&self, rhs_ncols: usize, _par: Par) -> StackReq

computes the workspace layout required to apply self or the conjugate o self to a matrix with rhs_ncols columns

fn nrows(&self) -> usize

output dimension of the operator

fn ncols(&self) -> usize

input dimension of the operator

fn apply( &self, out: MatMut<'_, T>, rhs: MatRef<'_, T>, par: Par, stack: &mut MemStack, )

applies self to rhs, and stores the result in out

fn conj_apply( &self, out: MatMut<'_, T>, rhs: MatRef<'_, T>, par: Par, stack: &mut MemStack, )

applies the conjugate of self to rhs, and stores the result in out

impl<I, T> Precond<T> for Poly<I, T>

where I: Index, T: ComplexField + Debug + Sync,

fn apply_in_place_scratch(&self, rhs_ncols: usize, _par: Par) -> StackReq

computes the workspace layout required to apply self or the conjugate of self to a matrix with rhs_ncols columns in place

fn apply_in_place(&self, rhs: MatMut<'_, T>, par: Par, stack: &mut MemStack)

applies self to rhs, and stores the result in rhs

fn conj_apply_in_place( &self, rhs: MatMut<'_, T>, par: Par, stack: &mut MemStack, )

applies the conjugate of self to rhs, and stores the result in rhs