Struct IdentityPrecond 

pub struct IdentityPrecond {
    pub dim: usize,
}

identity preconditioner, no-op for most operations

Fields

dim: usize

dimension of the preconditioner, equal to the dimension of the solution

Trait Implementations

impl<T: ComplexField> BiLinOp<T> for IdentityPrecond

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

computes the workspace size and alignment 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: ComplexField> BiPrecond<T> for IdentityPrecond

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

computes the workspace size and alignment 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 Clone for IdentityPrecond

fn clone(&self) -> IdentityPrecond

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for IdentityPrecond

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

Formats the value using the given formatter.

impl<T: ComplexField> LinOp<T> for IdentityPrecond

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

computes the workspace size and alignment 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 Ord for IdentityPrecond

fn cmp(&self, other: &IdentityPrecond) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for IdentityPrecond

fn eq(&self, other: &IdentityPrecond) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for IdentityPrecond

fn partial_cmp(&self, other: &IdentityPrecond) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T: ComplexField> Precond<T> for IdentityPrecond

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

computes the workspace size and alignment 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

impl Copy for IdentityPrecond

impl Eq for IdentityPrecond

impl StructuralPartialEq for IdentityPrecond