AbstractLinAlgPack::MatrixOp Class Reference

Base class for all matrices that support basic matrix operations. More...

#include <AbstractLinAlgPack_MatrixOp.hpp>

Inheritance diagram for AbstractLinAlgPack::MatrixOp:
Inheritance graph
[legend]

List of all members.

Classes

class  IncompatibleMatrices
 Thrown if matrices are not compatible. More...
struct  MatNorm
 Returned form calc_norm(). More...
class  MethodNotImplemented
 Thrown if a method is not implemented. More...

Public types



enum  EMatNormType { MAT_NORM_INF, MAT_NORM_2, MAT_NORM_1, MAT_NORM_FORB }
 

Type of matrix norm.

More...

Friends



void Mt_S (MatrixOp *mwo_lhs, value_type alpha)
 
void Mp_StM (MatrixOp *mwo_lhs, value_type alpha, const MatrixOp &M_rhs, BLAS_Cpp::Transp trans_rhs)
 
void Mp_StMtP (MatrixOp *mwo_lhs, value_type alpha, const MatrixOp &M_rhs, BLAS_Cpp::Transp M_trans, const GenPermMatrixSlice &P_rhs, BLAS_Cpp::Transp P_rhs_trans)
 
void Mp_StPtM (MatrixOp *mwo_lhs, value_type alpha, const GenPermMatrixSlice &P_rhs, BLAS_Cpp::Transp P_rhs_trans, const MatrixOp &M_rhs, BLAS_Cpp::Transp M_trans)
 
void Mp_StPtMtP (MatrixOp *mwo_lhs, value_type alpha, const GenPermMatrixSlice &P_rhs1, BLAS_Cpp::Transp P_rhs1_trans, const MatrixOp &M_rhs, BLAS_Cpp::Transp trans_rhs, const GenPermMatrixSlice &P_rhs2, BLAS_Cpp::Transp P_rhs2_trans)
 
void Vp_StMtV (VectorMutable *v_lhs, value_type alpha, const MatrixOp &M_rhs1, BLAS_Cpp::Transp trans_rhs1, const Vector &v_rhs2, value_type beta)
 
void Vp_StMtV (VectorMutable *v_lhs, value_type alpha, const MatrixOp &M_rhs1, BLAS_Cpp::Transp trans_rhs1, const SpVectorSlice &sv_rhs2, value_type beta)
 
void Vp_StPtMtV (VectorMutable *v_lhs, value_type alpha, const GenPermMatrixSlice &P_rhs1, BLAS_Cpp::Transp P_rhs1_trans, const MatrixOp &M_rhs2, BLAS_Cpp::Transp M_rhs2_trans, const Vector &v_rhs3, value_type beta)
 
void Vp_StPtMtV (VectorMutable *v_lhs, value_type alpha, const GenPermMatrixSlice &P_rhs1, BLAS_Cpp::Transp P_rhs1_trans, const MatrixOp &M_rhs2, BLAS_Cpp::Transp M_rhs2_trans, const SpVectorSlice &sv_rhs3, value_type beta)
 
value_type transVtMtV (const Vector &v_rhs1, const MatrixOp &M_rhs2, BLAS_Cpp::Transp trans_rhs2, const Vector &v_rhs3)
 
value_type transVtMtV (const SpVectorSlice &sv_rhs1, const MatrixOp &M_rhs2, BLAS_Cpp::Transp trans_rhs2, const SpVectorSlice &sv_rhs3)
 
void syr2k (const MatrixOp &M, BLAS_Cpp::Transp M_trans, value_type alpha, const GenPermMatrixSlice &P1, BLAS_Cpp::Transp P1_trans, const GenPermMatrixSlice &P2, BLAS_Cpp::Transp P2_trans, value_type beta, MatrixSymOp *symwo_lhs)
 
void Mp_StMtM (MatrixOp *mwo_lhs, value_type alpha, const MatrixOp &mwo_rhs1, BLAS_Cpp::Transp trans_rhs1, const MatrixOp &mwo_rhs2, BLAS_Cpp::Transp trans_rhs2, value_type beta)
 
void syrk (const MatrixOp &mwo_rhs, BLAS_Cpp::Transp M_trans, value_type alpha, value_type beta, MatrixSymOp *sym_lhs)
 

Minimal modifying methods



virtual void zero_out ()
 M_lhs = 0 : Zero out the matrix.
virtual void Mt_S (value_type alpha)
 M_lhs *= alpha : Multiply a matrix by a scalar.
virtual MatrixOpoperator= (const MatrixOp &mwo_rhs)
 M_lhs = mwo_rhs : Virtual assignment operator.

Clone



virtual mat_mut_ptr_t clone ()
 Clone the non-const matrix object (if supported).
virtual mat_ptr_t clone () const
 Clone the const matrix object (if supported).

Output



virtual std::ostream & output (std::ostream &out) const
 Virtual output function.

Norms



const MatNorm calc_norm (EMatNormType requested_norm_type=MAT_NORM_1, bool allow_replacement=false) const
 Compute a norm of this matrix.

Sub-matrix views



virtual mat_ptr_t sub_view (const Range1D &row_rng, const Range1D &col_rng) const
 Create a transient constant sub-matrix view of this matrix (if supported).
mat_ptr_t sub_view (const index_type &rl, const index_type &ru, const index_type &cl, const index_type &cu) const
 Inlined implementation calls this->sub_view(Range1D(rl,ru),Range1D(cl,cu)).

Permuted views



virtual mat_ptr_t perm_view (const Permutation *P_row, const index_type row_part[], int num_row_part, const Permutation *P_col, const index_type col_part[], int num_col_part) const
 Create a permuted view: M_perm = P_row' * M * P_col.
virtual mat_ptr_t perm_view_update (const Permutation *P_row, const index_type row_part[], int num_row_part, const Permutation *P_col, const index_type col_part[], int num_col_part, const mat_ptr_t &perm_view) const
 Reinitialize a permuted view: M_perm = P_row' * M * P_col.

Level-1 BLAS



virtual bool Mp_StM (MatrixOp *mwo_lhs, value_type alpha, BLAS_Cpp::Transp trans_rhs) const
 mwo_lhs += alpha * op(M_rhs) (BLAS xAXPY).
virtual bool Mp_StM (value_type alpha, const MatrixOp &M_rhs, BLAS_Cpp::Transp trans_rhs)
 M_lhs += alpha * op(mwo_rhs) (BLAS xAXPY).
virtual bool Mp_StMtP (MatrixOp *mwo_lhs, value_type alpha, BLAS_Cpp::Transp M_trans, const GenPermMatrixSlice &P_rhs, BLAS_Cpp::Transp P_rhs_trans) const
 mwo_lhs += alpha * op(M_rhs) * op(P_rhs).
virtual bool Mp_StMtP (value_type alpha, const MatrixOp &mwo_rhs, BLAS_Cpp::Transp M_trans, const GenPermMatrixSlice &P_rhs, BLAS_Cpp::Transp P_rhs_trans)
 M_lhs += alpha * op(mwo_rhs) * op(P_rhs).
virtual bool Mp_StPtM (MatrixOp *mwo_lhs, value_type alpha, const GenPermMatrixSlice &P_rhs, BLAS_Cpp::Transp P_rhs_trans, BLAS_Cpp::Transp M_trans) const
 mwo_lhs += alpha * op(P_rhs) * op(M_rhs).
virtual bool Mp_StPtM (value_type alpha, const GenPermMatrixSlice &P_rhs, BLAS_Cpp::Transp P_rhs_trans, const MatrixOp &mwo_rhs, BLAS_Cpp::Transp M_trans)
 M_lhs += alpha * op(P_rhs) * op(mwo_rhs).
virtual bool Mp_StPtMtP (MatrixOp *mwo_lhs, value_type alpha, const GenPermMatrixSlice &P_rhs1, BLAS_Cpp::Transp P_rhs1_trans, BLAS_Cpp::Transp M_trans, const GenPermMatrixSlice &P_rhs2, BLAS_Cpp::Transp P_rhs2_trans) const
 mwo_lhs += alpha * op(P_rhs1) * op(M_rhs) * op(P_rhs2).
virtual bool Mp_StPtMtP (value_type alpha, const GenPermMatrixSlice &P_rhs1, BLAS_Cpp::Transp P_rhs1_trans, const MatrixOp &mwo_rhs, BLAS_Cpp::Transp M_trans, const GenPermMatrixSlice &P_rhs2, BLAS_Cpp::Transp P_rhs2_trans)
 M_lhs += alpha * op(P_rhs1) * op(mwo_rhs) * op(P_rhs2).

Level-2 BLAS



virtual void Vp_StMtV (VectorMutable *v_lhs, value_type alpha, BLAS_Cpp::Transp trans_rhs1, const Vector &v_rhs2, value_type beta) const =0
 v_lhs = alpha * op(M_rhs1) * v_rhs2 + beta * v_lhs (BLAS xGEMV)
virtual void Vp_StMtV (VectorMutable *v_lhs, value_type alpha, BLAS_Cpp::Transp trans_rhs1, const SpVectorSlice &sv_rhs2, value_type beta) const
 v_lhs = alpha * op(M_rhs1) * sv_rhs2 + beta * v_lhs (BLAS xGEMV)
virtual void Vp_StPtMtV (VectorMutable *v_lhs, value_type alpha, const GenPermMatrixSlice &P_rhs1, BLAS_Cpp::Transp P_rhs1_trans, BLAS_Cpp::Transp M_rhs2_trans, const Vector &v_rhs3, value_type beta) const
 v_lhs = alpha * op(P_rhs1) * op(M_rhs2) * v_rhs3 + beta * v_rhs
virtual void Vp_StPtMtV (VectorMutable *v_lhs, value_type alpha, const GenPermMatrixSlice &P_rhs1, BLAS_Cpp::Transp P_rhs1_trans, BLAS_Cpp::Transp M_rhs2_trans, const SpVectorSlice &sv_rhs3, value_type beta) const
 v_lhs = alpha * op(P_rhs1) * op(M_rhs2) * sv_rhs3 + beta * v_rhs
virtual value_type transVtMtV (const Vector &v_rhs1, BLAS_Cpp::Transp trans_rhs2, const Vector &v_rhs3) const
 result = v_rhs1' * op(M_rhs2) * v_rhs3
virtual value_type transVtMtV (const SpVectorSlice &sv_rhs1, BLAS_Cpp::Transp trans_rhs2, const SpVectorSlice &sv_rhs3) const
 result = sv_rhs1' * op(M_rhs2) * sv_rhs3
virtual void syr2k (BLAS_Cpp::Transp M_trans, value_type alpha, const GenPermMatrixSlice &P1, BLAS_Cpp::Transp P1_trans, const GenPermMatrixSlice &P2, BLAS_Cpp::Transp P2_trans, value_type beta, MatrixSymOp *symwo_lhs) const
 Perform a specialized rank-2k update of a dense symmetric matrix of the form:

Level-3 BLAS



virtual bool Mp_StMtM (MatrixOp *mwo_lhs, value_type alpha, BLAS_Cpp::Transp trans_rhs1, const MatrixOp &mwo_rhs2, BLAS_Cpp::Transp trans_rhs2, value_type beta) const
 mwo_lhs = alpha * op(M_rhs1) * op(mwo_rhs2) + beta * mwo_lhs (left) (xGEMM).
virtual bool Mp_StMtM (MatrixOp *mwo_lhs, value_type alpha, const MatrixOp &mwo_rhs1, BLAS_Cpp::Transp trans_rhs1, BLAS_Cpp::Transp trans_rhs2, value_type beta) const
 mwo_lhs = alpha * op(mwo_rhs1) * op(M_rhs2) + beta * mwo_lhs (right) (xGEMM)
virtual bool Mp_StMtM (value_type alpha, const MatrixOp &mwo_rhs1, BLAS_Cpp::Transp trans_rhs1, const MatrixOp &mwo_rhs2, BLAS_Cpp::Transp trans_rhs2, value_type beta)
 M_lhs = alpha * op(mwo_rhs1) * op(mwo_rhs2) + beta * mwo_lhs (left) (xGEMM).
virtual bool syrk (BLAS_Cpp::Transp M_trans, value_type alpha, value_type beta, MatrixSymOp *sym_lhs) const
 Perform a rank-k update of a symmetric matrix of the form:
virtual bool syrk (const MatrixOp &mwo_rhs, BLAS_Cpp::Transp M_trans, value_type alpha, value_type beta)
 Perform a rank-k update of a symmetric matrix of the form:

Detailed Description

Base class for all matrices that support basic matrix operations.

These basic operations are:

Level-1 BLAS

mwo_lhs += alpha * op(M_rhs) (BLAS xAXPY)
mwo_lhs += alpha * op(M_rhs) * op(P_rhs)
mwo_lhs += alpha * op(P_rhs) * op(M_rhs)
mwo_lhs += alpha * op(P1_rhs) * op(M_rhs) * op(P2_rhs)

M_lhs += alpha * op(mwo_rhs) (BLAS xAXPY)
M_lhs += alpha * op(mwo_rhs) * op(P_rhs)
M_lhs += alpha * op(P_rhs) * op(mwo_rhs)
M_lhs += alpha * op(P1_rhs) * op(mwo_rhs) * op(P2_rhs)

Level-2 BLAS

v_lhs = alpha * op(M_rhs1) * v_rhs2 + beta * v_lhs (BLAS xGEMV)
v_lhs = alpha * op(M_rhs1) * sv_rhs2 + beta * v_lhs (BLAS xGEMV)
v_lhs = alpha * op(P_rhs1) * op(M_rhs2) * v_rhs3 + beta * v_lhs
v_lhs = alpha * op(P_rhs1) * op(M_rhs2) * sv_rhs3 + beta * v_lhs
result = v_rhs1' * op(M_rhs2) * v_rhs3
result = sv_rhs1' * op(M_rhs2) * sv_rhs3

Level-3 BLAS

mwo_lhs = alpha * op(M_rhs1) * op(mwo_rhs2) + beta * mwo_lhs (right) (xGEMM)
mwo_lhs = alpha * op(mwo_rhs1) * op(M_rhs2) + beta * mwo_lhs (left) (xGEMM)
M_lhs = alpha * op(mwo_rhs1) * op(mwo_rhs2) + beta * M_lhs (xGEMM)

All of the Level-1, Level-2 and Level-3 BLAS operations have default implementations based on the Level-2 BLAS operation:

v_lhs = alpha * op(M_rhs1) * v_rhs2 + beta * v_lhs (BLAS xGEMV)

The only methods that have to be overridden are space_cols(), space_rows() and the single Vp_StMtV() method shown above. This is to allow fast prototyping of matrix subclasses and for postponement of writting specialized methods of other time critical operations until later if they are needed.

The vector space objects returned by the methods space_cols() and space_rows() are specifically bound to this matrix object. The vector space objects returned should only be considered to be transient and may become invalid if this is modified in some significant way (but not through this MatrixOp interface obviously).

Most of the Level-1 through Level-3 BLAS methods should not be called directly by clients, but instead be called through the provided non-member functions. The Level-1 and Level-3 matrix methods of this class have a special protocal in order to deal with the multiple dispatch problem. In essence, a poor man's multiple dispatch is used to allow each of the participating matrix objects a chance to implement an operation. In each case, a non-member function must be called by the client which calls the virtual methods on the matrix arguments one at a time. All of the Level-1 and Level-3 matrix methods are implemented for the case where the lhs matrix supports the MultiVectorMutable interface. These matrix operations are then implemented in terms of AbstractLinAlgPack::Vp_StMtV(...) which must be implemented for every matrix subclass. Therefore, any combination of rhs matrices can always be used in any matrix operation as long as a compatible (i.e. vector spaces match up) MultiVectorMutable object is used as the lhs matrix argument.

Note, this behavior is only implemented by the *nonmember* functions AbstractLinAlgPack::Mp_StM(...) or AbstractLinAlgPack::Mp_StMtM(...). All of the default virtual implementations of Mp_StM(...) and Mp_StMtM(...) return false.

This form of multiple dispatach is not ideal in the sense that the first matrix argument that *can* implement the method will do so instead of perhaps the *best* implementation that could be provided by another matrix argument. Therefore, a matrix subclass should only override one of these matrix methods if it can provide a significantly better implementation than the default. If a client needs exact control of the implementation of a matrix operation, then they should consider using a ``Strategy'' object.

ToDo: Add more detailed documentation for the default Level-1 and Level-3 BLAS methods.

Definition at line 116 of file AbstractLinAlgPack_MatrixOp.hpp.


Member Enumeration Documentation

Type of matrix norm.

Enumerator:
MAT_NORM_INF 

The induced infinity norm ||M||inf, i.e. max abs row sum.

MAT_NORM_2 

The induced two (i.e. Euclidean norm) norm ||M||2.

MAT_NORM_1 

The induced one norm ||M||1, i.e. max abs col sum.

MAT_NORM_FORB 

The Forbenious norm, i.e. max abs element.

Definition at line 231 of file AbstractLinAlgPack_MatrixOp.hpp.


Member Function Documentation

void AbstractLinAlgPack::MatrixOp::zero_out (  )  [virtual]

M_lhs = 0 : Zero out the matrix.

The default implementation throws an exception. This is not the best design but it meets some needs. Any matrix implementation could implement this method and mimic the behavior (i.e. see the matrix subclass MatrixZero). However, only matrices that are going to be on the lhs (non-const) of a Level-1 or Level-3 BLAS operation need every implement this method.

Reimplemented in AbstractLinAlgPack::MatrixOpSubView, AbstractLinAlgPack::MultiVectorMutable, AbstractLinAlgPack::MatrixZero, AbstractLinAlgPack::MultiVectorMutableCols, and AbstractLinAlgPack::MultiVectorMutableDense.

Definition at line 44 of file AbstractLinAlgPack_MatrixOp.cpp.

void AbstractLinAlgPack::MatrixOp::Mt_S ( value_type  alpha  )  [virtual]

M_lhs *= alpha : Multiply a matrix by a scalar.

The default implementation throws an exception. This is not the best design but it meets some needs. Any matrix implementation could implement this method and mimic the behavior (i.e. simply implement the matrix M as (alpha * M). This method is only called in a few specialized situations.

Reimplemented in AbstractLinAlgPack::MatrixOpSubView, AbstractLinAlgPack::MultiVectorMutable, AbstractLinAlgPack::MatrixZero, AbstractLinAlgPack::MultiVectorMutableCols, and AbstractLinAlgPack::MultiVectorMutableDense.

Definition at line 52 of file AbstractLinAlgPack_MatrixOp.cpp.

MatrixOp & AbstractLinAlgPack::MatrixOp::operator= ( const MatrixOp mwo_rhs  )  [virtual]
MatrixOp::mat_mut_ptr_t AbstractLinAlgPack::MatrixOp::clone (  )  [virtual]

Clone the non-const matrix object (if supported).

The primary purpose for this method is to allow a client to capture the current state of a matrix object and be guaranteed that some other client will not alter its behavior. A smart implementation will use reference counting and lazy evaluation internally and will not actually copy any large amount of data unless it has to.

The default implementation returns NULL which is perfectly acceptable. A matrix object is not required to return a non-NULL value but almost every good matrix implementation will.

Reimplemented in AbstractLinAlgPack::MatrixOpNonsing, AbstractLinAlgPack::MatrixSymOp, AbstractLinAlgPack::MatrixSymOpNonsing, AbstractLinAlgPack::MultiVectorMutable, AbstractLinAlgPack::MatrixSymOpNonsingSerial, AbstractLinAlgPack::MultiVectorMutableCols, AbstractLinAlgPack::MatrixOpNonsingThyra, AbstractLinAlgPack::MatrixOpThyra, and AbstractLinAlgPack::MultiVectorMutableThyra.

Definition at line 89 of file AbstractLinAlgPack_MatrixOp.cpp.

MatrixOp::mat_ptr_t AbstractLinAlgPack::MatrixOp::clone (  )  const [virtual]

Clone the const matrix object (if supported).

The behavior of this method is the same as for the non-const version above except it returns a smart pointer to a const matrix object.

Reimplemented in AbstractLinAlgPack::MatrixOpNonsing, AbstractLinAlgPack::MatrixSymOp, AbstractLinAlgPack::MatrixSymOpNonsing, AbstractLinAlgPack::MultiVector, AbstractLinAlgPack::MatrixSymOpNonsingSerial, and AbstractLinAlgPack::MultiVectorMutableCols.

Definition at line 95 of file AbstractLinAlgPack_MatrixOp.cpp.

std::ostream & AbstractLinAlgPack::MatrixOp::output ( std::ostream &  out  )  const [virtual]
const MatrixOp::MatNorm AbstractLinAlgPack::MatrixOp::calc_norm ( EMatNormType  requested_norm_type = MAT_NORM_1,
bool  allow_replacement = false 
) const

Compute a norm of this matrix.

Parameters:
requested_norm_type [in] Determines the requested type of norm to be computed.
allow_replacement [in] Determines if the requested norm in specified in norm_type can be replaced with another norm that can be computed by the matrix.
Returns:
If a norm is computed, then return.value gives the value of the norm of type return.type.

Postconditions:

  • If allow_replacement==true, the matrix object must return a computted norm who's type is given in return.type.
  • If allow_replacement==false and the underlying matrix object can not compute the norm requested in norm_type, then a MethodNotImplemented exception will be thrown. If the matrix object can compute this norm, then return.type will be equal to requested_norm_type.

The default implementation of this method uses Algorithm 2.5 in "Applied Numerical Linear Algebra" by James Demmel (1997) to estimate ||M||1 or ||M||inf. The algorithm uses some of the refinements in the referenced algorithm by Highman. This algorithm only requires mat-vecs and transposed mat-vecs so every matrix object can implement this method. The main purpose of this default implementation is to allow a default implementation of the estimation of the ||.||1 or ||.||inf normed condition number in the class MatrixOpNonsing. The default arguments for this function will compute a norm and will not thrown an exception. The default implementation will throw an exception for any other norm type than requested_norm_type == MAT_NORM_1 or requested_norm_type = MAT_NORM_INF.

Definition at line 103 of file AbstractLinAlgPack_MatrixOp.cpp.

MatrixOp::mat_ptr_t AbstractLinAlgPack::MatrixOp::sub_view ( const Range1D row_rng,
const Range1D col_rng 
) const [virtual]

Create a transient constant sub-matrix view of this matrix (if supported).

This view is to be used immediatly and then discarded.

This method can only be expected to return return.get() != NULL if this->space_cols().sub_space(row_rng) != NULL and this->space_rows().sub_space(col_rng) != NULL.

It is allows for a matrix implementation to return return.get() == NULL for any arbitrary subview.

The default implementation uses the matrix subclass MatrixOpSubView and therefore, can return any arbitrary subview. More specialized implementations may want to restrict the subview that can be created somewhat.

Reimplemented in AbstractLinAlgPack::MatrixOpNonsingAggr, AbstractLinAlgPack::MatrixOpSubView, AbstractLinAlgPack::MatrixPermAggr, AbstractLinAlgPack::MultiVector, and AbstractLinAlgPack::MatrixComposite.

Definition at line 160 of file AbstractLinAlgPack_MatrixOp.cpp.

MatrixOp::mat_ptr_t AbstractLinAlgPack::MatrixOp::sub_view ( const index_type rl,
const index_type ru,
const index_type cl,
const index_type cu 
) const [inline]

Inlined implementation calls this->sub_view(Range1D(rl,ru),Range1D(cl,cu)).

Definition at line 962 of file AbstractLinAlgPack_MatrixOp.hpp.

MatrixOp::mat_ptr_t AbstractLinAlgPack::MatrixOp::perm_view ( const Permutation P_row,
const index_type  row_part[],
int  num_row_part,
const Permutation P_col,
const index_type  col_part[],
int  num_col_part 
) const [virtual]

Create a permuted view: M_perm = P_row' * M * P_col.

Parameters:
P_row [in] Row permutation. If P_row == NULL then the indentity permutation is used.
row_part [in] Array (length num_row_part+1) storing the row indexes that may be passed to return->sub_view(r1,r2,...). If row_part == NULL then the assumed array is { 1, this->rows() }.
num_row_part [in] Length of the array row_part. If row_part == NULL then this argument is ignored.
P_col [in] Column permutation. If P_col == NULL then the indentity permutation is used.
col_part [in] Array (length num_col_part+1) storing the column indexes that may be passed to return->sub_view(...,c1,c2). If col_part == NULL then the assumed array is { 1, this->cols() }.
num_col_part [in] Length of the array col_part. If col_part == NULL then this argument is ignored.

Preconditions:

Postconditions:

  • The subviews return->sub_view(R,C) should be able to be created efficiently where R = [row_part[kr-1],row_part[kr]-1], for kr = 1...num_row_part and C = [col_part[kc-1],col_part[kc]-1], for kc = 1...num_col_part.

The default implementation returns a MatrixPermAggr object.

Definition at line 183 of file AbstractLinAlgPack_MatrixOp.cpp.

MatrixOp::mat_ptr_t AbstractLinAlgPack::MatrixOp::perm_view_update ( const Permutation P_row,
const index_type  row_part[],
int  num_row_part,
const Permutation P_col,
const index_type  col_part[],
int  num_col_part,
const mat_ptr_t &  perm_view 
) const [virtual]

Reinitialize a permuted view: M_perm = P_row' * M * P_col.

Parameters:
P_row [in] Same as input to perm_view().
row_part [in] Same as input to perm_view().
num_row_part [in] Same as input to perm_view().
P_col [in] Same as input to perm_view().
col_part [in] Same as input to perm_view().
num_col_part [in] Same as input to perm_view().
perm_view [in] Smart pointer to a permuted view returned from this->perm_view().

Preconditions:

The default implementation simply returns this->perm_view()

Definition at line 203 of file AbstractLinAlgPack_MatrixOp.cpp.

bool AbstractLinAlgPack::MatrixOp::Mp_StM ( MatrixOp mwo_lhs,
value_type  alpha,
BLAS_Cpp::Transp  trans_rhs 
) const [protected, virtual]

mwo_lhs += alpha * op(M_rhs) (BLAS xAXPY).

The default implementation does nothing returns false.

A client can not call this method call this method directly. Instead, use AbstractLinAlgPack::Mp_StM().

Reimplemented in AbstractLinAlgPack::MatrixOpNonsingAggr, AbstractLinAlgPack::MatrixOpSubView, AbstractLinAlgPack::MatrixPermAggr, AbstractLinAlgPack::MultiVectorMutable, AbstractLinAlgPack::MatrixSymDiagStd, AbstractLinAlgPack::MatrixZero, AbstractLinAlgPack::MatrixOpSerial, and AbstractLinAlgPack::MultiVectorMutableDense.

Definition at line 220 of file AbstractLinAlgPack_MatrixOp.cpp.

bool AbstractLinAlgPack::MatrixOp::Mp_StM ( value_type  alpha,
const MatrixOp M_rhs,
BLAS_Cpp::Transp  trans_rhs 
) [protected, virtual]

M_lhs += alpha * op(mwo_rhs) (BLAS xAXPY).

The default implementation does nothing and returns false.

A client can not call this method call this method directly. Instead, use AbstractLinAlgPack::Mp_StM().

Reimplemented in AbstractLinAlgPack::MatrixOpSubView, AbstractLinAlgPack::MultiVectorMutable, and AbstractLinAlgPack::MultiVectorMutableDense.

Definition at line 227 of file AbstractLinAlgPack_MatrixOp.cpp.

bool AbstractLinAlgPack::MatrixOp::Mp_StMtP ( MatrixOp mwo_lhs,
value_type  alpha,
BLAS_Cpp::Transp  M_trans,
const GenPermMatrixSlice P_rhs,
BLAS_Cpp::Transp  P_rhs_trans 
) const [protected, virtual]

mwo_lhs += alpha * op(M_rhs) * op(P_rhs).

The default implementation does nothing and returns false.

A client can not call this method call this method directly. Instead, use AbstractLinAlgPack::Mp_StMtP().

Reimplemented in AbstractLinAlgPack::MatrixOpNonsingAggr, AbstractLinAlgPack::MatrixOpSubView, AbstractLinAlgPack::MatrixPermAggr, AbstractLinAlgPack::MatrixZero, and AbstractLinAlgPack::MatrixOpSerial.

Definition at line 233 of file AbstractLinAlgPack_MatrixOp.cpp.

bool AbstractLinAlgPack::MatrixOp::Mp_StMtP ( value_type  alpha,
const MatrixOp mwo_rhs,
BLAS_Cpp::Transp  M_trans,
const GenPermMatrixSlice P_rhs,
BLAS_Cpp::Transp  P_rhs_trans 
) [protected, virtual]

M_lhs += alpha * op(mwo_rhs) * op(P_rhs).

The default implementation does nothing and returns false.

A client can not call this method call this method directly. Instead, use AbstractLinAlgPack::Mp_StMtP().

Reimplemented in AbstractLinAlgPack::MatrixOpSubView.

Definition at line 242 of file AbstractLinAlgPack_MatrixOp.cpp.

bool AbstractLinAlgPack::MatrixOp::Mp_StPtM ( MatrixOp mwo_lhs,
value_type  alpha,
const GenPermMatrixSlice P_rhs,
BLAS_Cpp::Transp  P_rhs_trans,
BLAS_Cpp::Transp  M_trans 
) const [protected, virtual]

mwo_lhs += alpha * op(P_rhs) * op(M_rhs).

The default implementation does nothing and returns false.

A client can not call this method call this method directly. Instead, use AbstractLinAlgPack::Mp_StPtM().

Reimplemented in AbstractLinAlgPack::MatrixOpNonsingAggr, AbstractLinAlgPack::MatrixOpSubView, AbstractLinAlgPack::MatrixPermAggr, AbstractLinAlgPack::MatrixZero, and AbstractLinAlgPack::MatrixOpSerial.

Definition at line 251 of file AbstractLinAlgPack_MatrixOp.cpp.

bool AbstractLinAlgPack::MatrixOp::Mp_StPtM ( value_type  alpha,
const GenPermMatrixSlice P_rhs,
BLAS_Cpp::Transp  P_rhs_trans,
const MatrixOp mwo_rhs,
BLAS_Cpp::Transp  M_trans 
) [protected, virtual]

M_lhs += alpha * op(P_rhs) * op(mwo_rhs).

The default implementation does nothing and returns false.

A client can not call this method call this method directly. Instead, use AbstractLinAlgPack::Mp_StPtM().

Reimplemented in AbstractLinAlgPack::MatrixOpSubView.

Definition at line 260 of file AbstractLinAlgPack_MatrixOp.cpp.

bool AbstractLinAlgPack::MatrixOp::Mp_StPtMtP ( MatrixOp mwo_lhs,
value_type  alpha,
const GenPermMatrixSlice P_rhs1,
BLAS_Cpp::Transp  P_rhs1_trans,
BLAS_Cpp::Transp  M_trans,
const GenPermMatrixSlice P_rhs2,
BLAS_Cpp::Transp  P_rhs2_trans 
) const [protected, virtual]

mwo_lhs += alpha * op(P_rhs1) * op(M_rhs) * op(P_rhs2).

The default implementation does nothing and returns false.

A client can not call this method call this method directly. Instead, use AbstractLinAlgPack::Mp_StPtMtP().

Reimplemented in AbstractLinAlgPack::MatrixOpNonsingAggr, AbstractLinAlgPack::MatrixOpSubView, AbstractLinAlgPack::MatrixPermAggr, AbstractLinAlgPack::MatrixZero, and AbstractLinAlgPack::MatrixOpSerial.

Definition at line 269 of file AbstractLinAlgPack_MatrixOp.cpp.

bool AbstractLinAlgPack::MatrixOp::Mp_StPtMtP ( value_type  alpha,
const GenPermMatrixSlice P_rhs1,
BLAS_Cpp::Transp  P_rhs1_trans,
const MatrixOp mwo_rhs,
BLAS_Cpp::Transp  M_trans,
const GenPermMatrixSlice P_rhs2,
BLAS_Cpp::Transp  P_rhs2_trans 
) [protected, virtual]

M_lhs += alpha * op(P_rhs1) * op(mwo_rhs) * op(P_rhs2).

The default implementation does nothing and returns false.

A client can not call this method call this method directly. Instead, use AbstractLinAlgPack::Mp_StPtMtP().

Reimplemented in AbstractLinAlgPack::MatrixOpSubView.

Definition at line 279 of file AbstractLinAlgPack_MatrixOp.cpp.

virtual void AbstractLinAlgPack::MatrixOp::Vp_StMtV ( VectorMutable v_lhs,
value_type  alpha,
BLAS_Cpp::Transp  trans_rhs1,
const Vector v_rhs2,
value_type  beta 
) const [protected, pure virtual]
void AbstractLinAlgPack::MatrixOp::Vp_StMtV ( VectorMutable v_lhs,
value_type  alpha,
BLAS_Cpp::Transp  trans_rhs1,
const SpVectorSlice sv_rhs2,
value_type  beta 
) const [protected, virtual]
void AbstractLinAlgPack::MatrixOp::Vp_StPtMtV ( VectorMutable v_lhs,
value_type  alpha,
const GenPermMatrixSlice P_rhs1,
BLAS_Cpp::Transp  P_rhs1_trans,
BLAS_Cpp::Transp  M_rhs2_trans,
const Vector v_rhs3,
value_type  beta 
) const [protected, virtual]
void AbstractLinAlgPack::MatrixOp::Vp_StPtMtV ( VectorMutable v_lhs,
value_type  alpha,
const GenPermMatrixSlice P_rhs1,
BLAS_Cpp::Transp  P_rhs1_trans,
BLAS_Cpp::Transp  M_rhs2_trans,
const SpVectorSlice sv_rhs3,
value_type  beta 
) const [protected, virtual]
value_type AbstractLinAlgPack::MatrixOp::transVtMtV ( const Vector v_rhs1,
BLAS_Cpp::Transp  trans_rhs2,
const Vector v_rhs3 
) const [protected, virtual]
value_type AbstractLinAlgPack::MatrixOp::transVtMtV ( const SpVectorSlice sv_rhs1,
BLAS_Cpp::Transp  trans_rhs2,
const SpVectorSlice sv_rhs3 
) const [protected, virtual]
void AbstractLinAlgPack::MatrixOp::syr2k ( BLAS_Cpp::Transp  M_trans,
value_type  alpha,
const GenPermMatrixSlice P1,
BLAS_Cpp::Transp  P1_trans,
const GenPermMatrixSlice P2,
BLAS_Cpp::Transp  P2_trans,
value_type  beta,
MatrixSymOp symwo_lhs 
) const [protected, virtual]

Perform a specialized rank-2k update of a dense symmetric matrix of the form:

symwo_lhs += alpha*op(P1')*op(M)*op(P2) + alpha*op(P2')*op(M')*op(P1) + beta*symwo_lhs

The reason that this operation is being classified as a level-2 operation is that the total flops should be of O(n^2) and not O(n^2*k).

The default implementation is based on Mp_StMtP(...) and Mp_StPtM(...). Of course in situations where this default implemention is inefficient the subclass should override this method.

Reimplemented in AbstractLinAlgPack::MatrixOpNonsingAggr, AbstractLinAlgPack::MatrixOpSubView, AbstractLinAlgPack::MatrixPermAggr, AbstractLinAlgPack::MatrixZero, and AbstractLinAlgPack::MatrixOpSerial.

Definition at line 356 of file AbstractLinAlgPack_MatrixOp.cpp.

bool AbstractLinAlgPack::MatrixOp::Mp_StMtM ( MatrixOp mwo_lhs,
value_type  alpha,
BLAS_Cpp::Transp  trans_rhs1,
const MatrixOp mwo_rhs2,
BLAS_Cpp::Transp  trans_rhs2,
value_type  beta 
) const [protected, virtual]

mwo_lhs = alpha * op(M_rhs1) * op(mwo_rhs2) + beta * mwo_lhs (left) (xGEMM).

The default implementation does nothing and returns false.

Warning! A client should never call this method call this method directly. Instead, use AbstractLinAlgPack::Mp_StMtM().

Reimplemented in AbstractLinAlgPack::MatrixOpNonsingAggr, AbstractLinAlgPack::MatrixOpSubView, AbstractLinAlgPack::MatrixPermAggr, AbstractLinAlgPack::MultiVector, AbstractLinAlgPack::MatrixZero, AbstractLinAlgPack::MatrixOpSerial, AbstractLinAlgPack::MultiVectorMutableDense, AbstractLinAlgPack::MatrixOpThyra, and AbstractLinAlgPack::MultiVectorMutableThyra.

Definition at line 367 of file AbstractLinAlgPack_MatrixOp.cpp.

bool AbstractLinAlgPack::MatrixOp::Mp_StMtM ( MatrixOp mwo_lhs,
value_type  alpha,
const MatrixOp mwo_rhs1,
BLAS_Cpp::Transp  trans_rhs1,
BLAS_Cpp::Transp  trans_rhs2,
value_type  beta 
) const [protected, virtual]

mwo_lhs = alpha * op(mwo_rhs1) * op(M_rhs2) + beta * mwo_lhs (right) (xGEMM)

The default implementation does nothing and returns false.

Warning! A client should never call this method call this method directly. Instead, use AbstractLinAlgPack::Mp_StMtM().

Reimplemented in AbstractLinAlgPack::MatrixOpNonsingAggr, AbstractLinAlgPack::MatrixOpSubView, AbstractLinAlgPack::MatrixPermAggr, AbstractLinAlgPack::MultiVector, AbstractLinAlgPack::MatrixZero, and AbstractLinAlgPack::MultiVectorMutableDense.

Definition at line 375 of file AbstractLinAlgPack_MatrixOp.cpp.

bool AbstractLinAlgPack::MatrixOp::Mp_StMtM ( value_type  alpha,
const MatrixOp mwo_rhs1,
BLAS_Cpp::Transp  trans_rhs1,
const MatrixOp mwo_rhs2,
BLAS_Cpp::Transp  trans_rhs2,
value_type  beta 
) [protected, virtual]

M_lhs = alpha * op(mwo_rhs1) * op(mwo_rhs2) + beta * mwo_lhs (left) (xGEMM).

The default implementation does nothing and returns false.

Warning! A client should never call this method call this method directly. Instead, use AbstractLinAlgPack::Mp_StMtM().

Reimplemented in AbstractLinAlgPack::MatrixOpSubView.

Definition at line 383 of file AbstractLinAlgPack_MatrixOp.cpp.

bool AbstractLinAlgPack::MatrixOp::syrk ( BLAS_Cpp::Transp  M_trans,
value_type  alpha,
value_type  beta,
MatrixSymOp sym_lhs 
) const [protected, virtual]

Perform a rank-k update of a symmetric matrix of the form:

symwo_lhs += alpha*op(M)*op(M') + beta*symwo_lhs

where this is the rhs matrix argument.

Never call this method directly. Instead use the nonmember function AbstractLinAlgPack::syrk().

The default implementation returns false and does nothing.

Reimplemented in AbstractLinAlgPack::MatrixOpNonsingAggr, AbstractLinAlgPack::MatrixOpSubView, AbstractLinAlgPack::MatrixPermAggr, AbstractLinAlgPack::MatrixSymDiagStd, AbstractLinAlgPack::MatrixZero, AbstractLinAlgPack::MatrixOpSerial, AbstractLinAlgPack::MultiVectorMutableCols, and AbstractLinAlgPack::MultiVectorMutableDense.

Definition at line 392 of file AbstractLinAlgPack_MatrixOp.cpp.

bool AbstractLinAlgPack::MatrixOp::syrk ( const MatrixOp mwo_rhs,
BLAS_Cpp::Transp  M_trans,
value_type  alpha,
value_type  beta 
) [protected, virtual]

Perform a rank-k update of a symmetric matrix of the form:

M += alpha*op(mwo_rhs)*op(mwo_rhs') + beta*M

where this is the lhs matrix argument.

Never call this method directly. Instead use the nonmember function AbstractLinAlgPack::syrk().

The default implementation returns false and does nothing.

Definition at line 402 of file AbstractLinAlgPack_MatrixOp.cpp.


Friends And Related Function Documentation

void Mt_S ( MatrixOp mwo_lhs,
value_type  alpha 
) [friend]

mwo_lhs *= alpha.

If alpha == 0.0 then mwo_lhs->zero_out() will be called, otherwise mwo_lhs->Mt_S(alpha) will be called. If alpha == 1.0 then nothing is done.

void Mp_StM ( MatrixOp mwo_lhs,
value_type  alpha,
const MatrixOp M_rhs,
BLAS_Cpp::Transp  trans_rhs 
) [friend]

mwo_lhs += alpha * op(M_rhs) (BLAS xAXPY).

Entry point for (poor man's) multiple dispatch.

This method first calls M_rhs->Mp_StM(mwo_lhs,alpha,trans_rhs) to give the rhs argument a chance to implement the operation. If M_rhs->Mp_StM(...) returns false, then mwo_lhs->Mp_StM(alpha,*this,trans_rhs) is called to give the lhs matrix argument a chance to implement the method. If mwo_lhs->Mp_StM(...) returns false, then an attempt to perform a dynamic cast the lhs matrix argument to MultiVectorMutable is attempted. If this cast failes, then an exception is thrown.

void Mp_StMtP ( MatrixOp mwo_lhs,
value_type  alpha,
const MatrixOp M_rhs,
BLAS_Cpp::Transp  M_trans,
const GenPermMatrixSlice P_rhs,
BLAS_Cpp::Transp  P_rhs_trans 
) [friend]

Entry point for (poor man's) multiple dispatch.

ToDo: Finish documentation!

void Mp_StPtM ( MatrixOp mwo_lhs,
value_type  alpha,
const GenPermMatrixSlice P_rhs,
BLAS_Cpp::Transp  P_rhs_trans,
const MatrixOp M_rhs,
BLAS_Cpp::Transp  M_trans 
) [friend]

Entry point for (poor man's) multiple dispatch.

ToDo: Finish documentation!

void Mp_StPtMtP ( MatrixOp mwo_lhs,
value_type  alpha,
const GenPermMatrixSlice P_rhs1,
BLAS_Cpp::Transp  P_rhs1_trans,
const MatrixOp M_rhs,
BLAS_Cpp::Transp  trans_rhs,
const GenPermMatrixSlice P_rhs2,
BLAS_Cpp::Transp  P_rhs2_trans 
) [friend]

Entry point for (poor man's) multiple dispatch.

ToDo: Finish documentation!

void Vp_StMtV ( VectorMutable v_lhs,
value_type  alpha,
const MatrixOp M_rhs1,
BLAS_Cpp::Transp  trans_rhs1,
const Vector v_rhs2,
value_type  beta = 1.0 
) [friend]

Definition at line 844 of file AbstractLinAlgPack_MatrixOp.hpp.

void Vp_StMtV ( VectorMutable v_lhs,
value_type  alpha,
const MatrixOp M_rhs1,
BLAS_Cpp::Transp  trans_rhs1,
const SpVectorSlice sv_rhs2,
value_type  beta = 1.0 
) [friend]

Definition at line 853 of file AbstractLinAlgPack_MatrixOp.hpp.

void Vp_StPtMtV ( VectorMutable v_lhs,
value_type  alpha,
const GenPermMatrixSlice P_rhs1,
BLAS_Cpp::Transp  P_rhs1_trans,
const MatrixOp M_rhs2,
BLAS_Cpp::Transp  M_rhs2_trans,
const Vector v_rhs3,
value_type  beta = 1.0 
) [friend]

Definition at line 862 of file AbstractLinAlgPack_MatrixOp.hpp.

void Vp_StPtMtV ( VectorMutable v_lhs,
value_type  alpha,
const GenPermMatrixSlice P_rhs1,
BLAS_Cpp::Transp  P_rhs1_trans,
const MatrixOp M_rhs2,
BLAS_Cpp::Transp  M_rhs2_trans,
const SpVectorSlice sv_rhs3,
value_type  beta = 1.0 
) [friend]

Definition at line 873 of file AbstractLinAlgPack_MatrixOp.hpp.

value_type transVtMtV ( const Vector v_rhs1,
const MatrixOp M_rhs2,
BLAS_Cpp::Transp  trans_rhs2,
const Vector v_rhs3 
) [friend]

Definition at line 884 of file AbstractLinAlgPack_MatrixOp.hpp.

value_type transVtMtV ( const SpVectorSlice sv_rhs1,
const MatrixOp M_rhs2,
BLAS_Cpp::Transp  trans_rhs2,
const SpVectorSlice sv_rhs3 
) [friend]

Definition at line 893 of file AbstractLinAlgPack_MatrixOp.hpp.

void syr2k ( const MatrixOp M,
BLAS_Cpp::Transp  M_trans,
value_type  alpha,
const GenPermMatrixSlice P1,
BLAS_Cpp::Transp  P1_trans,
const GenPermMatrixSlice P2,
BLAS_Cpp::Transp  P2_trans,
value_type  beta,
MatrixSymOp symwo_lhs 
) [friend]

Definition at line 902 of file AbstractLinAlgPack_MatrixOp.hpp.

void Mp_StMtM ( MatrixOp mwo_lhs,
value_type  alpha,
const MatrixOp mwo_rhs1,
BLAS_Cpp::Transp  trans_rhs1,
const MatrixOp mwo_rhs2,
BLAS_Cpp::Transp  trans_rhs2,
value_type  beta 
) [friend]

This method first calls mwo_rhs1.Mp_StMtM(...) to perform the opeation. If mwo_rhs1.Mp_StMtM(...) returns false, then mwo_rhs2.Mp_StMtM(...) is called. If mwo_rhs2.Mp_StMtM(...) returns false, then mwo_lhs.Mp_StMtM(...) is called.

As a last resort, the function attempts to cast dynamic_cast<MultiVectorMutable*>(mwo_lhs). If this dynamic cast fails, the this function throws an exception. Otherwise, the operation is implemented in terms of Vp_StMtV().

void syrk ( const MatrixOp mwo_rhs,
BLAS_Cpp::Transp  M_trans,
value_type  alpha,
value_type  beta,
MatrixSymOp sym_lhs 
) [friend]

symwo_lhs += alpha*op(mwo_rhs)*op(mwo_rhs') + beta*symwo_lhs

The default implementation returns false and does nothing.


The documentation for this class was generated from the following files:
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines
Generated on Wed Apr 13 10:17:27 2011 for MOOCHO (Single Doxygen Collection) by  doxygen 1.6.3