class HCL_LinearOp_d : public HCL_Base

HCL_LinearOp_d is the base class for all linear operators

Inheritance:


Public Methods

virtual HCL_VectorSpace_d& Domain () const
Domain space access
virtual HCL_VectorSpace_d& Range () const
Range space access
virtual void Image ( const HCL_Vector_d & x, HCL_Vector_d & y ) const
Image computes the action of the operator on x, giving y
virtual void AdjImage ( const HCL_Vector_d & y, HCL_Vector_d & x ) const
AdjImage computes the action of the adjoint on y, giving x
int CheckAdj (int Display = 1, double tol = 1000 )
CheckAdj tests that the operator and its adjoint satisfy the "adjointness" relationship
virtual void NormalImage ( const HCL_Vector_d & x, HCL_Vector_d & z ) const
NormalImage computes the action of the normal on x, giving z
int CheckNormal ( int display = 1, double tol = 100 )
CheckNormal tests that the normal operator N is really defined by N = A'A
virtual void InvImage (const HCL_Vector_d & y, HCL_Vector_d & x) const
InvImage computes the action of the inverse on y, giving x
virtual void InvAdjImage (const HCL_Vector_d & x, HCL_Vector_d & y) const
InvAdjImage computes the action of the inverse adjoint on x, giving y
virtual void ImageAdd (const HCL_Vector_d & x, const HCL_Vector_d & z, HCL_Vector_d & y, double a=1.0, double b=1.0) const
ImageAdd implements
virtual void AdjImageAdd (const HCL_Vector_d & x, const HCL_Vector_d & z, HCL_Vector_d & y, double a=1.0, double b=1.0) const
AdjImageAdd implements
virtual void NormalImageAdd (const HCL_Vector_d & x, const HCL_Vector_d & z, HCL_Vector_d & y, double a=1.0, double b=1.0) const
NormalImageAdd implements
virtual void InvImageAdd (const HCL_Vector_d & x, const HCL_Vector_d & z, HCL_Vector_d & y, double a=1.0, double b=1.0) const
InvImageAdd implements
virtual void InvAdjImageAdd (const HCL_Vector_d & x, const HCL_Vector_d & z, HCL_Vector_d & y, double a=1.0, double b=1.0) const
InvAdjImageAdd implements
virtual void ImageAdd (const HCL_Vector_d & x, HCL_Vector_d & y, double a=1.0, double b=1.0) const
ImageAdd implements
virtual void AdjImageAdd (const HCL_Vector_d & x, HCL_Vector_d & y, double a=1.0, double b=1.0) const
AdjImageAdd implements
virtual void NormalImageAdd (const HCL_Vector_d & x, HCL_Vector_d & y, double a=1.0, double b=1.0) const
NormalImageAdd implements
virtual void InvImageAdd (const HCL_Vector_d & x, HCL_Vector_d & y, double a=1.0, double b=1.0) const
InvImageAdd implements
virtual void InvAdjImageAdd (const HCL_Vector_d & x, HCL_Vector_d & y, double a=1.0, double b=1.0) const
InvAdjImageAdd implements

Inherited from HCL_Base:

Public Methods

void IncCount() const
void DecCount() const
int Count() const
virtual ostream& Write(ostream &) const

Documentation

HCL_LinearOp_d is the base class for all linear operators. This class represents a linear operator mapping one vector space to another. The primary methods are: Note that this class makes no assumption about the representation of the operator. Examples include operators defined by dense or sparse matrices and solution operators of (linear) PDEs defined by simulations.
virtual HCL_VectorSpace_d& Domain() const
Domain space access. Returns a reference to the domain of the operator, which is an HCL_VectorSpace_d. Pure virtual: must be implemented in any derived instantiable class.

virtual HCL_VectorSpace_d& Range() const
Range space access. Returns a reference to the range of the operator, which is an HCL_VectorSpace_d. Pure virtual: must be implemented in any derived instantiable class.

virtual void Image( const HCL_Vector_d & x, HCL_Vector_d & y ) const
Image computes the action of the operator on x, giving y. Pure virtual: must be implemented in any derived instantiable class.

virtual void AdjImage( const HCL_Vector_d & y, HCL_Vector_d & x ) const
AdjImage computes the action of the adjoint on y, giving x. This method is implemented in the base class to return an error message. To obtain a working AdjImage in any derived instantiable class, you must override this default.

int CheckAdj(int Display = 1, double tol = 1000 )
CheckAdj tests that the operator and its adjoint satisfy the "adjointness" relationship. The return value is 1 if an error is detected, zero otherwise. The first input is a display flag; zero means no display, 1 means display a message only if there is an error, and 2 means displays the results of the test, whether there is an error or not. The second input sets the tolerance for the floating-point tests; an error is reported if two results which ought to be equal differ by a relative amount greater than tol times machine epsilon. This method is implemented in this class.

virtual void NormalImage( const HCL_Vector_d & x, HCL_Vector_d & z ) const
NormalImage computes the action of the normal on x, giving z. This method is given a default implementation in this class. Custom implementations may be more efficient than the default.

int CheckNormal( int display = 1, double tol = 100 )
CheckNormal tests that the normal operator N is really defined by N = A'A. The return value is 1 if an error is detected, zero otherwise. The first input is a display flag; zero means no display, 1 means display a message only if there is an error, and 2 means displays the results of the test, whether there is an error or not. The second input sets the tolerance for the floating-point tests; an error is reported if two results which ought to be equal differ by a relative amount greater than tol times machine epsilon. This method is implemented in this class.

virtual void InvImage(const HCL_Vector_d & y, HCL_Vector_d & x) const
InvImage computes the action of the inverse on y, giving x. This method is implemented in the base class to return an error message. To obtain a working InvImage in any derived instantiable class, you must override this default.

virtual void InvAdjImage(const HCL_Vector_d & x, HCL_Vector_d & y) const
InvAdjImage computes the action of the inverse adjoint on x, giving y. This method is implemented in the base class to return an error message. To obtain a working InvAdjImage in any derived instantiable class, you must override this default.

virtual void ImageAdd(const HCL_Vector_d & x, const HCL_Vector_d & z, HCL_Vector_d & y, double a=1.0, double b=1.0) const
ImageAdd implements . This provides for efficiency in creating linear combinations of the operator output and another vector. An efficient implementation will avoid temporary storage of intermediate results, as well as multiple passes through the data. The scalars default to 1.0; if left at their default values, no multiplies are actually performed. For convenience we provide a default (inefficient) implementation: efficient implementations for concrete operators will override this.

virtual void AdjImageAdd(const HCL_Vector_d & x, const HCL_Vector_d & z, HCL_Vector_d & y, double a=1.0, double b=1.0) const
AdjImageAdd implements . This provides for efficiency in creating linear combinations of the operator output and another vector. An efficient implementation will avoid temporary storage of intermediate results, as well as multiple passes through the data. The scalars default to 1.0; if left at their default values, no multiplies are actually performed. For convenience we provide a default (inefficient) implementation: efficient implementations for concrete operators will override this.

virtual void NormalImageAdd(const HCL_Vector_d & x, const HCL_Vector_d & z, HCL_Vector_d & y, double a=1.0, double b=1.0) const
NormalImageAdd implements . This provides for efficiency in creating linear combinations of the operator output and another vector, as frequently occurs in iterative algorithms. An efficient implementation will avoid temporary storage of intermediate results, as well as multiple passes through the data. The scalars default to 1.0; if left at their default values, no multiplies are actually performed. For convenience we provide a default (inefficient) implementation: efficient implementations for concrete operators will override this.

virtual void InvImageAdd(const HCL_Vector_d & x, const HCL_Vector_d & z, HCL_Vector_d & y, double a=1.0, double b=1.0) const
InvImageAdd implements . This provides for efficiency in creating linear combinations of the operator output and another vector, as frequently occurs in iterative algorithms. An efficient implementation will avoid temporary storage of intermediate results, as well as multiple passes through the data. The scalars default to 1.0; if left at their default values, no multiplies are actually performed. For convenience we provide a default (inefficient) implementation: efficient implementations for concrete operators will override this.

virtual void InvAdjImageAdd(const HCL_Vector_d & x, const HCL_Vector_d & z, HCL_Vector_d & y, double a=1.0, double b=1.0) const
InvAdjImageAdd implements . This provides for efficiency in creating linear combinations of the operator output and another vector, as frequently occurs in iterative algorithms. An efficient implementation will avoid temporary storage of intermediate results, as well as multiple passes through the data. The scalars default to 1.0; if left at their default values, no multiplies are actually performed. For convenience we provide a default (inefficient) implementation: efficient implementations for concrete operators will override this.

virtual void ImageAdd(const HCL_Vector_d & x, HCL_Vector_d & y, double a=1.0, double b=1.0) const
ImageAdd implements . This provides for efficiency in creating linear combinations of the operator output and another vector. An efficient implementation will avoid temporary storage of intermediate results, as well as multiple passes through the data. The scalars default to 1.0; if left at their default values, no multiplies are actually performed. For convenience we provide a default (inefficient) implementation: efficient implementations for concrete operators will override this.

virtual void AdjImageAdd(const HCL_Vector_d & x, HCL_Vector_d & y, double a=1.0, double b=1.0) const
AdjImageAdd implements . This provides for efficiency in creating linear combinations of the operator output and another vector. An efficient implementation will avoid temporary storage of intermediate results, as well as multiple passes through the data. The scalars default to 1.0; if left at their default values, no multiplies are actually performed. For convenience we provide a default (inefficient) implementation: efficient implementations for concrete operators will override this.

virtual void NormalImageAdd(const HCL_Vector_d & x, HCL_Vector_d & y, double a=1.0, double b=1.0) const
NormalImageAdd implements . This provides for efficiency in creating linear combinations of the operator output and another vector, as frequently occurs in iterative algorithms. An efficient implementation will avoid temporary storage of intermediate results, as well as multiple passes through the data. The scalars default to 1.0; if left at their default values, no multiplies are actually performed. For convenience we provide a default (inefficient) implementation: efficient implementations for concrete operators will override this.

virtual void InvImageAdd(const HCL_Vector_d & x, HCL_Vector_d & y, double a=1.0, double b=1.0) const
InvImageAdd implements . This provides for efficiency in creating linear combinations of the operator output and another vector, as frequently occurs in iterative algorithms. An efficient implementation will avoid temporary storage of intermediate results, as well as multiple passes through the data. The scalars default to 1.0; if left at their default values, no multiplies are actually performed. For convenience we provide a default (inefficient) implementation: efficient implementations for concrete operators will override this.

virtual void InvAdjImageAdd(const HCL_Vector_d & x, HCL_Vector_d & y, double a=1.0, double b=1.0) const
InvAdjImageAdd implements . This provides for efficiency in creating linear combinations of the operator output and another vector, as frequently occurs in iterative algorithms. An efficient implementation will avoid temporary storage of intermediate results, as well as multiple passes through the data. The scalars default to 1.0; if left at their default values, no multiplies are actually performed. For convenience we provide a default (inefficient) implementation: efficient implementations for concrete operators will override this.


Direct child classes:
HCL_lmbfgsOp1_d
HCL_ZeroLinearOp_d
HCL_ScaleLinearOp_d
HCL_DiagScaleLinearOp_d
HCL_LinCombLinearOp_d
HCL_CompLinearOp_d
HCL_DiagBlockLinearOp_d
HCL_BlockLinearOp_d
HCL_BigMFcnlHessian_d
HCL_Normal_d
HCL_InvLinearOp_d
HCL_Adjoint_d
HCL_OpDefaultPartialDeriv_d
HCL_OpDefaultDeriv_d
HCL_FunctionalDefaultHessianBlock_d
HCL_FunctionalDefaultHessian_d
HCL_RestrictedBiLinearOp_d
HCL_UpperTriangularMatOp_d
HCL_SymSparseRCSMatOp_d
HCL_SymMatOp_d
HCL_SparseRCSMatOp_d
HCL_LowerTriangularMatOp_d
HCL_GeneralMatOp_d
HCL_TRSSOp_d

alphabetic index hierarchy of classes


this page has been generated automatically by doc++

(c)opyright by Malte Zöckler, Roland Wunderling
contact: doc++@zib.de