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: ParShape) -> 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: ComplexField> BiPrecond<T> for IdentityPrecond

fn transpose_apply_in_place_scratch( &self, _rhs_ncols: usize, _par: ParShape, ) -> 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 Clone for IdentityPrecond

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for IdentityPrecond

impl Debug for IdentityPrecond

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

Formats the value using the given formatter.

impl Eq for IdentityPrecond

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

fn apply_scratch(&self, _rhs_ncols: usize, _par: ParShape) -> 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 Ord for IdentityPrecond

fn cmp(&self, other: &Self) -> 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.

fn clamp_to<R>(self, range: R) -> Self

where Self: Sized, R: ClampBounds<Self>,

🔬This is a nightly-only experimental API. (clamp_to)

Restrict a value to a certain range.

impl PartialEq for IdentityPrecond

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

Equality operator ==.

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

Inequality operator !=.

impl PartialOrd for IdentityPrecond

fn partial_cmp(&self, other: &Self) -> 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: ParShape) -> 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

impl StructuralPartialEq for IdentityPrecond