Struct BlockJacobiPrecond 

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

Block-Jacobi preconditioner: M^{-1} y = blkdiag(A_k^{-1}) y.

The factorisation is computed once at construction. apply, apply_in_place, and the transpose/adjoint variants perform only dense triangular solves and permutation applications — they require no heap allocation and all scratch flows through the MemStack provided by faer’s trait interface.

Storage

All p LU factors are packed contiguously in column-major order into a single Vec<T>, and the partial-pivoting permutations are packed into two Vec<usize> of total length n. This keeps the working set cache-friendly during apply.

Implementations

impl<T> BlockJacobiPrecond<T>

pub fn dim(&self) -> usize

Dimension n of the preconditioner (sum of block sizes).

pub fn is_empty(&self) -> bool

true if the preconditioner has dimension zero.

pub fn block_count(&self) -> usize

Number of diagonal blocks.

pub fn block_offsets(&self) -> &[usize]

Slice of length block_count() + 1 giving the row/column offsets of each block.

pub fn max_block_size(&self) -> usize

Size of the largest block — useful for sizing external scratch buffers.

impl<T: ComplexField> BlockJacobiPrecond<T>

pub fn try_new( a: MatRef<'_, T>, block_offsets: &[usize], ) -> Result<Self, BlockJacobiError>

Build a block-Jacobi preconditioner from a and a block partition.

block_offsets must satisfy block_offsets[0] == 0, the values must be strictly increasing, and block_offsets[block_offsets.len() - 1] must equal a.nrows().

Errors

Returns BlockJacobiError::NonSquareMatrix if a is not square, validation errors for ill-formed block_offsets, and BlockJacobiError::SingularBlock if any diagonal block is rank-deficient.

Trait Implementations

impl<T> BiLinOp<T> for BlockJacobiPrecond<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 BlockJacobiPrecond<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 BlockJacobiPrecond<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for BlockJacobiPrecond<T>

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

Formats the value using the given formatter.

impl<T> LinOp<T> for BlockJacobiPrecond<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 BlockJacobiPrecond<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