Struct JacobiPrecond 

pub struct JacobiPrecond<T> { /* private fields */ }

Point-Jacobi preconditioner: M^{-1} y = diag(A)^{-1} y.

Stores the reciprocals of A’s diagonal and multiplies them into the right-hand side. Apply is O(n) and allocates nothing. See the module documentation for when this is the right choice.

Implementations

impl<T> JacobiPrecond<T>

pub fn from_inverse_diagonal(inv_diag: Vec<T>) -> Self

Build directly from the already-inverted diagonal 1 / diag(A).

No checking is done — use this only when you have computed the reciprocals yourself. Prefer Self::try_from_diagonal otherwise.

pub fn inverse_diagonal(&self) -> &[T]

The stored inverse diagonal, 1 / diag(A).

pub fn dim(&self) -> usize

Dimension n of the preconditioner.

pub fn is_empty(&self) -> bool

true if the preconditioner has dimension zero.

impl<T: ComplexField> JacobiPrecond<T>

pub fn try_from_diagonal(diag: &[T]) -> Result<Self, JacobiError>

Build from a slice holding the diagonal of A.

Errors

Returns JacobiError::ZeroDiagonalEntry if any entry is zero.

pub fn try_from_matrix_diagonal(mat: MatRef<'_, T>) -> Result<Self, JacobiError>

Build by reading the diagonal of a dense matrix mat.

Errors

Returns JacobiError::NonSquareMatrix if mat is not square, or JacobiError::ZeroDiagonalEntry if any diagonal entry is zero.

Trait Implementations

impl<T> BiLinOp<T> for JacobiPrecond<T>

where 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<T> BiPrecond<T> for JacobiPrecond<T>

where 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<T: Clone> Clone for JacobiPrecond<T>

fn clone(&self) -> JacobiPrecond<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for JacobiPrecond<T>

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

Formats the value using the given formatter.

impl<T> LinOp<T> for JacobiPrecond<T>

where 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<T> Precond<T> for JacobiPrecond<T>

where 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