AbstractLinAlgPack Namespace Reference


Classes

class  BasisSystem
 Interface for the creation and maintainance of a basis matrix for a decomposition of linearlized constriants. More...
class  BasisSystemFactory
 Interface for a factory object that will create BasisSystem objects. More...
class  BasisSystemPerm
 Interface for setting and selecting a basis from the Jacobian from a set of equations. More...
struct  compare_element_indexes_less
 ele1.index() < ele2.index() More...
struct  compare_element_indexes_equal_to
 ele.index() == i More...
class  EtaVector
 Create an eta vector (scaled by alpha = default 1). More...
class  GenPermMatrixSlice
 Concrete matrix type to represent general permutation (mapping) matrices. More...
class  InnerProduct
 Abstract interface for inner products. More...
class  InnerProductDot
 Implements the inner product as the dot product. More...
class  MatrixBase
 Base class for all polymorphic matrices. More...
class  MatrixNonsing
 Abstract base class for all nonsingular polymorphic matrices that can solve for linear system with but it may not be convienent to compute matrix vector products {abstract}. More...
class  MatrixOp
 Base class for all matrices that support basic matrix operations. More...
class  MatrixOpNonsing
 Abstract base class for all nonsingular polymorphic matrices that can be used to compute matrix-vector products and solve for linear systems efficiently. More...
class  MatrixOpNonsingAggr
 Aggregate matrix class pulling together a MatrixOp object and a MatrixNonsing object into a unified matrix object. More...
class  MatrixOpSubView
 Standard subclass for representing a sub, possibly transposed, view of a matrix. More...
class  MatrixPermAggr
 Aggregate matrix class for a matrix and its permuted view. More...
class  MatrixSymDiag
 Interface to all diagonal matrices {abstract}. More...
class  MatrixSymInitDiag
 Mix-in Interface for setting a matrix to a diagonal {abstract}. More...
class  MatrixSymNonsing
 Abstract base class for all polymorphic symmetrix nonsingular matrices that can be used to solve for linear systems relatively efficently. More...
class  MatrixSymOp
 Interface adding operations specific for a symmetric matrix {abstract}. More...
class  MatrixSymOpNonsing
 Abstract base class for all polymorphic symmetrix nonsingular matrices that can be used to compute matrix-vector products and solve for linear systems relatively efficently. More...
class  MatrixSymSecant
 Mix-in interface for all polymorphic symmetric matrices that support secant updating. More...
class  MultiVector
 Interface for a collection of non-mutable vectors (multi-vector, matrix). More...
class  MultiVectorMutable
 Interface for a collection of mutable vectors (multi-vector, matrix). More...
class  Permutation
 Abstract interface to permutation matrices. More...
class  SparseElement
 Sparse storage element type. More...
class  SparseVector
 Sparse Vector class template. More...
class  SparseVectorSlice
 Sparse Vector Slice class template. More...
class  Vector
 Abstract interface for immutable, finite dimensional, coordinate vectors {abstract}. More...
class  VectorApplyOpSerialBase
 This is a base class that is meant to be inherited by Vector subclasses that wish to call TSFCore::apply_op_serial() when vectors are in core. More...
class  VectorMutable
 Abstract interface for mutable coordinate vectors {abstract}. More...
class  VectorMutableSubView
 Concrete subclass for a sub-view of a VectorMutable object. More...
class  VectorSpace
 Abstract interface for objects that represent a space for mutable coordinate vectors. More...
class  VectorSpaceFactory
 Abstract interface for objects that can create vector spaces of a specified dimension. More...
class  VectorSpaceSubSpace
 Concrete subclass for a default sub-space of a vector. More...
class  VectorSubView
 Concrete subclass for a default sub-view implementation for a Vector object. More...
class  NaNInfException
  More...
class  BasisSystemComposite
 Simple BasisSystem subclass the case where the client sets up seperate C and N matrices. More...
class  BasisSystemTester
 Testing class for BasisSystem interface. More...
class  BasisSystemTesterSetOptions
 Set options for BasisSystemTester from an OptionsFromStream object. More...
class  MatrixComposite
 Matrix class for matrices composed out of a set of other matrices and vectors. More...
class  MatrixOpNonsingTester
 Testing class for MatrixOpNonsing interface. More...
class  MatrixSymDiagStd
 Simple diagonal matrix class. More...
class  MatrixSymIdent
 Matrix subclass for a scaled identity matrix. More...
class  MatrixZero
 Implementation of a matrix with all zeros. More...
class  VectorMutableBlocked
 Concrete subclass for a blocked vector. More...
class  VectorSpaceBlocked
 VectorSpace subclass for the composite of one or more VectorSpace objects. More...
class  VectorSpaceTester
 Testing class for VectorSpace, Vector and VectorMutable. More...
class  VectorSpaceTesterSetOptions
 Set options for VectorSpaceTester from an OptionsFromStream object. More...
class  PreConditionException
 Base class for precondition exceptions. More...
class  PostConditionException
 Base class for postcondition exceptions. More...
class  InputException
 Base class for input exceptions (Preconditions). More...
class  SetupException
 Base class for invalid setup for a class object when an exception is thrown. More...
class  COOMatrix
 Sparse Coordinate Matrix abstraction storage class. More...
class  COOMatrixPartitionedView
 COO Matrix partitioning view class. More...
class  COOMatrixPartitionViewSubclass
 Implementation of MatrixOp abstract interface for COOMatrixWithPartitionedView::partition_type. More...
class  COOMatrixWithPartitionedView
 Aggregation of a COO matrix and a partitioned view of it. More...
class  MatrixCOORTmplItfc
 Templated class that supports the COOMatrixTemplateInterface template interface. More...
class  MatrixCOORTmplItfcItrEleView
 Templated class for objects that support the SparseCOOElementTemplatInterface specification. More...
class  MatrixCOORTmplItfcItr
 Templated class for iterator returning objects that support the SparseCOOElementTemplatInterface specification. More...
class  MatrixSparseCOORSerial
 Coordinate matrix subclass. More...
class  MatrixSymDiagSparseStd
 Concrete subclass for a serial symmetric diagonal matrix with many zeros on the diagonal. More...
class  MatrixWithOpConcreteEncap
 This template class defines the storage for a concrete matrix class that operations are based on. More...
class  SortByDescendingAbsValue
 Function object class for sorting a sparse vectors in descending order by abs(v(i)). More...
class  sparse_bounds_itr
 Iterate through a set of sparse bounds. More...
class  SparseCOOPtrElement
 Sparse pointer element type for a COO matrix (val, ivect, jvect). More...
class  SparsePtrElement
 Sparse pointer element type. More...
class  TransSparseCOOElementViewIter
 Templateded iterator for iterating through a set of COO Matix elements but viewing them in transpose. More...
class  VectorDenseEncap
 Extract a constant DenseLinAlgPack::DVectorSlice view of a Vector object. More...
class  VectorDenseMutableEncap
 Extract a non-const DenseLinAlgPack::DVectorSlice view of a VectorMutable object. More...
class  MatrixConvertToSparse
 Mix-in interface for extracing explicit elements from a sparse matrix in one of several Fortran compatible formats. More...
class  MatrixConvertToSparseEncap
 Sparse conversion subclass based on views of a MatrixExtractSparseElements object. More...
class  MatrixExtractInvCholFactor
 Mix-in Interface for extracting the inverse cholesky factor of a dense symmetric positive definite matrix. More...
class  MatrixExtractSparseElements
 Interface for extracting nonzero elements from a banded subregion of a permuted sparse matrix in one of several Fortran compatible formats. More...
class  MatrixLoadSparseElements
 Mix-in interface for loading nonzero elements into a sparse matrix data structure. More...
class  MatrixNonsingSerial
 Abstract base class for all AbstractLinAlgPack::MatrixNonsing objects implemented in shared memory space. More...
class  MatrixOpGetGMS
 Abstract interface that allows the extraction of a const DMatrixSlice view of an abstract matrix. More...
class  MatrixDenseEncap
 Helper class type that simplifies the usage of the MatrixOpGetGMS interface for clients. More...
class  MatrixOpGetGMSMutable
 Abstract interface that allows the extraction of a non-const DMatrixSlice view of an abstract matrix. More...
class  MatrixDenseMutableEncap
 Helper class type that simplifies the usage of the MatrixOpGetGMSMutable interface for clients. More...
class  MatrixOpGetGMSTri
 Mix-in interface that allows the extraction of a const DenseLinAlgPack::DMatrixSliceTri view of an non-singular abstract matrix. More...
class  MatrixDenseTriEncap
 Helper class type that simplifies the usage of the MatrixOpGetGMSTri interface for clients. More...
class  MatrixOpNonsingSerial
 Abstract base class for all serial nonsingular polymorphic matrices that can be used to compute matrix-vector products and solve for linear systems efficiently. More...
class  MatrixOpSerial
 Base class for all matrices implemented in a shared memory address space. More...
class  MatrixSymAddDelUpdateable
 Mix-in Interface for updating a serial symmetric matrix by adding and deleting rows and columns. More...
class  MatrixSymDenseInitialize
 Mix-in Interface for initializing a matrix with a dense symmetric matrix. More...
class  MatrixSymDiagSparse
 Abstract base class for all serial symmetric diagonal matrices with significant zeros along the diagonal. More...
class  MatrixSymNonsingSerial
 Abstract base class for all serial polymorphic symmetrix nonsingular matrices that can be used to solve for linear systems relatively efficiently. More...
class  MatrixSymOpGetGMSSym
 Abstract interface that allows the extraction of a const DenseLinAlgPack::DMatrixSliceSym view of an abstract matrix. More...
class  MatrixDenseSymEncap
 Helper class type that simplifies the usage of the MatrixSymOpGetGMSSym interface for clients. More...
class  MatrixSymOpGetGMSSymMutable
 Abstract interface that allows the extraction of a non-const DenseLinAlgPack::DMatrixSliceSym view of a symmetry abstract matrix. More...
class  MatrixDenseSymMutableEncap
 Helper class type that simplifies the usage of the MatrixSymOpGetGMSSymMutable interface for clients. More...
class  MatrixSymOpNonsingSerial
 Abstract base class for all serial polymorphic symmetric nonsingular matrices that can be used to compute matrix-vector products and solve for linear systems relatively efficiently. More...
class  MatrixSymOpSerial
 Abstract base class for all AbstractLinAlgPack::MatrixSymOp objects implemented in shared memory space. More...
class  MultiVectorMutableCols
 Default subclass for MultiVectorMutable implemented using columns of separate abstract vectors. More...
class  MultiVectorMutableDense
 MultiVectorMutable "Adapter" subclass for DenseLinAlgPack::DMatrixSlice or DenseLinAlgPack::DMatrix object. More...
class  VectorMutableDense
 DVector "Adaptor" subclass for DenseLinAlgPack::DVectorSlice or DenseLinAlgPack::DVector objects. More...
class  VectorSpaceFactorySerial
 Abstract interface for objects that can create vector spaces of a specified dimension. More...
class  VectorSpaceSerial
 Subclass for serial vector space objects that create VectorMutableDense vector and MultiVectorMutableDense multi-vector objects. More...
class  BasisSystemFactoryStd
 Default implementation for BasisSystemPermDirectSparse obejcts using DirectSparseSolver object. More...
class  BasisSystemPermDirectSparse
 Permutatble basis system subclass that uses a direct sparse solver. More...
class  DirectSparseSolver
 Abstract interface to serial direct sparse linear solvers. More...
class  DirectSparseSolverDense
 Concreate sparse solver subclass that uses the dense LAPACK routines. More...
class  DirectSparseSolverImp
 Implementation node class for DirectSparseSolver that takes care of the memory management details. More...
class  DirectSparseSolverMA28
 Concreate sparse solver subclass that uses MA28. More...
class  DirectSparseSolverMA28SetOptions
 Set options for DirectSparseSolverMA28 from OptionsFromStream object. More...
class  MatrixScaling_Strategy
 Abstract interface for sparse matrix scaling strategies. More...

Namespaces

namespace  GenPermMatrixSliceIteratorPack
namespace  SparseVectorUtilityPack
namespace  COOMatrixPartitionedViewUtilityPack
namespace  UtilityPack

Main interface library

typedef SparseVector< SparseElement<
index_type, value_type >,
std::allocator< SparseElement<
index_type, value_type > > > 
SpVector
typedef SparseVectorSlice<
SparseElement< index_type,
value_type > > 
SpVectorSlice

Level 1 BLAS

void Vp_V_assert_compatibility (VectorMutable *v_lhs, const Vector &v_rhs)
 v_lhs += op v_rhs
void Vp_V_assert_compatibility (VectorMutable *v_lhs, const SpVectorSlice &sv_rhs)
 v_lhs += op sv_rhs
void VopV_assert_compatibility (const Vector &v_rhs1, const Vector &v_rhs2)
 v_rhs1 op v_rhs2
void VopV_assert_compatibility (const Vector &v_rhs1, const SpVectorSlice &sv_rhs2)
 v_rhs1 op sv_rhs2
void VopV_assert_compatibility (const SpVectorSlice &sv_rhs1, const Vector &v_rhs2)
 sv_rhs1 op v_rhs2
void Mp_M_assert_compatibility (MatrixOp *m_lhs, BLAS_Cpp::Transp trans_lhs, const MatrixOp &m_rhs, BLAS_Cpp::Transp trans_rhs)
 op(m_lhs) += op op(m_rhs)
void MopM_assert_compatibility (const MatrixOp &m_rhs1, BLAS_Cpp::Transp trans_rhs1, const MatrixOp &m_rhs2, BLAS_Cpp::Transp trans_rhs2)
 op(m_rhs1) op op(m_rhs2)

Level 2 BLAS

void MtV_assert_compatibility (const MatrixOp &m_rhs1, BLAS_Cpp::Transp trans_rhs1, const Vector &v_rhs2)
 op(m_rhs1) * v_rhs2
void MtV_assert_compatibility (const MatrixOp &m_rhs1, BLAS_Cpp::Transp trans_rhs1, const SpVectorSlice &sv_rhs2)
 op(m_rhs1) * sv_rhs2
void Vp_MtV_assert_compatibility (VectorMutable *v_lhs, const MatrixOp &m_rhs1, BLAS_Cpp::Transp trans_rhs1, const Vector &v_rhs2)
 v_lhs += op(m_rhs1) * v_rhs2
void Vp_MtV_assert_compatibility (VectorMutable *v_lhs, const MatrixOp &m_rhs1, BLAS_Cpp::Transp trans_rhs1, const SpVectorSlice &sv_rhs2)
 v_lhs += op(m_rhs1) * sv_rhs2

Level 3 BLAS

void MtM_assert_compatibility (const MatrixOp &m_rhs1, BLAS_Cpp::Transp trans_rhs1, const MatrixOp &m_rhs2, BLAS_Cpp::Transp trans_rhs2)
 op(m_lhs) += op(m_rhs1)
void Mp_MtM_assert_compatibility (MatrixOp *m_lhs, BLAS_Cpp::Transp trans_lhs, const MatrixOp &m_rhs1, BLAS_Cpp::Transp trans_rhs1, const MatrixOp &m_rhs2, BLAS_Cpp::Transp trans_rhs2)
 op(m_lhs) += op(m_rhs1) * op(m_rhs2)

Level-2 BLAS

void V_InvMtV (VectorMutable *v_lhs, const MatrixNonsing &M_rhs1, BLAS_Cpp::Transp trans_rhs1, const Vector &v_rhs2)
 
void V_InvMtV (VectorMutable *v_lhs, const MatrixNonsing &M_rhs1, BLAS_Cpp::Transp trans_rhs1, const SpVectorSlice &sv_rhs2)
 
value_type transVtInvMtV (const Vector &v_rhs1, const MatrixNonsing &M_rhs2, BLAS_Cpp::Transp trans_rhs2, const Vector &v_rhs3)
 
value_type transVtInvMtV (const SpVectorSlice &sv_rhs1, const MatrixNonsing &M_rhs2, BLAS_Cpp::Transp trans_rhs2, const SpVectorSlice &sv_rhs3)
 

Level-3 BLAS

void M_StInvMtM (MatrixOp *m_lhs, value_type alpha, const MatrixNonsing &M_rhs1, BLAS_Cpp::Transp trans_rhs1, const MatrixOp &mwo_rhs2, BLAS_Cpp::Transp trans_rhs2)
 
void M_StMtInvM (MatrixOp *m_lhs, value_type alpha, const MatrixOp &mwo_rhs1, BLAS_Cpp::Transp trans_rhs1, const MatrixNonsing &M_rhs2, BLAS_Cpp::Transp trans_rhs2)
 

Level-1 BLAS

void Mt_S (MatrixOp *m_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)
 mwo_lhs += alpha * op(M_rhs) * op(P_rhs).
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)
 mwo_lhs += alpha * op(P) * op(M_rhs).
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)
 mwo_lhs += alpha * op(P_rhs1) * op(M_rhs) * op(P_rhs2).

Level-3 BLAS

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=1.0)
 mwo_lhs = alpha * op(mwo_rhs1) * op(mwo_rhs2) + beta * mwo_lhs (right) (xGEMM).
void syrk (const MatrixOp &mwo_rhs,BLAS_Cpp::Transp M_trans,value_type alpha,value_type beta,MatrixSymOp *sym_lhs)
 Perform a rank-k update of a symmetric matrix of the form:.

Level-2 BLAS

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)
 
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)
 
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)
 
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)
 
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)
 

Nonmember untility functions

template<class T_Element>
SparseVectorSlice< T_Element > create_slice (const SparseVectorUtilityPack::SpVecIndexLookup< T_Element > &index_lookup, size_type size, Range1D rng)
 Return a sparse vector slice.

Functions to be used in BFGS updating.

bool BFGS_sTy_suff_p_d (const Vector &s,const Vector &y,const value_type *sTy=NULL,std::ostream *out=NULL,const char func_name[]=NULL)
 Check that s'*y is sufficiently positive and print the result if it is not.

{\bf Conversion to Fortran compatable sparse compressed column

operations for COOMatrixTemplateInterface (Level 2,3 BLAS)}.

See the ConvertToCSC class.

template<class T_COOM>
size_type COOM_num_in_column (const T_COOM &m, BLAS_Cpp::Transp trans, size_type col_offset, const IVector::value_type *col_perm, size_type *num_in_col)
 
template<class T_COOM>
void COOM_insert_nonzeros (const T_COOM &m, BLAS_Cpp::Transp trans, value_type alpha, size_type row_offset, size_type col_offset, const IVector::value_type *row_perm, const IVector::value_type *col_perm, size_type *next_nz_in_col, FortranTypes::f_dbl_prec *D_val, FortranTypes::f_int *D_row_i)
 
template<class T_COOM>
value_type COOM_insert_scaled_nonzeros (const T_COOM &m, BLAS_Cpp::Transp trans, value_type scaled_max_ele, size_type row_offset, size_type col_offset, const IVector::value_type *row_perm, const IVector::value_type *col_perm, size_type *next_nz_in_col, FortranTypes::f_dbl_prec *D_val, FortranTypes::f_int *D_row_i)
 

COO matrix output stream function.

This is a functions that are used to output a templated COO matrix object to a char based output stream. The COOMatrixTemplateInterface specification is used.

The output format is diferent depending on whether the bits SparseLinAlgPackIO::ignore_dim_bit#, LinAlgPackIO::no_insert_newlines_bit# , and SparseLinAlgPackIO::ignore_nz_bit# are set. The default output format is:

rows cols nz#\ # val1:i1:j1 val2:i2:j2 ... valnz:inz:jnz#\

Each of the elements (val:i:j) are are put into columns according to the width set in the output stream os# and other formating commands when it is called. Even if the set width is 0 or less than the number of char's for the element a space ' ' will be inserted between them. The elements are formated according to the format in the stream os#.

If exta_flags & SparseLinAlgPackIO::ignore_dim_bit# == 0# then rows# and cols# will not be output.

If exta_flags & SparseLinAlgPackIO::ignore_nz_bit# == 0# then nz# will not be output.

If exta_flags & LinAlgPackIO::no_insert_newlines_bit == 0# then a newline charactor will not be inserted after the last element, otherwise (by default) it will be.

If coom.nz() == 0# then no elements will be output.

If any of the output operations fails then a std::ios_base::failure# exception is thrown.

template<class T_COOM>
std::ostream & output_COOM (std::ostream &os, const T_COOM &coom, SparseLinAlgPackIO::fmtflags extra_flags)

{\bf Level-1 BLAS matrix-matrix element-wise operations}.

template<class T_Indice, class T_Value>
void Mp_StM (DMatrixSlice *gms_lhs, value_type alpha, const COOMatrixPartitionedViewUtilityPack::Partition< T_Indice, T_Value > &coom_rhs, BLAS_Cpp::Transp trans_rhs)
 gms_lhs += alpha * op(coom_rhs) (time = O(coom_rhs.nz()), space = O(1)).

{\bf Level-2 BLAS (vector-matrtix) Liner Algebra Operations}.

These are functions that implement linear algebra operations that have DVector or DVectorSlice objects as lhs operands and a mixture of matrix and DVectorSlice rhs operands.

template<class T_Indice, class T_Value>
void Vp_StMtV (DVectorSlice *vs_lhs, value_type alpha, const COOMatrixPartitionedViewUtilityPack::Partition< T_Indice, T_Value > &coom_rhs1, BLAS_Cpp::Transp trans_rhs1, const DVectorSlice &vs_rhs2)
 vs_lhs += alpha * op(coom_rhs1) * vs_rhs2 (BLAS xGEMV) (time = O(coom_rhs.nz()), space = O(1)).
template<class T_Indice, class T_Value>
void Vp_StMtV (DVectorSlice *vs_lhs, value_type alpha, const COOMatrixPartitionedViewUtilityPack::Partition< T_Indice, T_Value > &coom_rhs1, BLAS_Cpp::Transp trans_rhs1, const DVectorSlice &vs_rhs2, value_type beta)
 vs_lhs += alpha * op(coom_rhs1) * vs_rhs2 (BLAS xGEMV) (time = O(coom_rhs.nz()), space = O(1)).

{\bf Level-3 BLAS (matrix-matrix) Linear Algebra Operations}.

template<class T_Indice, class T_Value>
void Mp_StMtM (DMatrixSlice *gms_lhs, value_type alpha, const COOMatrixPartitionedViewUtilityPack::Partition< T_Indice, T_Value > &coom_rhs1, BLAS_Cpp::Transp trans_rhs1, const DMatrixSlice &gms_rhs2, BLAS_Cpp::Transp trans_rhs2)
 gms_lhs += alpha * op(coom_rhs1) * op(gms_rhs2) (right) (BLAS xGEMM).
template<class T_Indice, class T_Value>
void Mp_StMtM (DMatrixSlice *gms_lhs, value_type alpha, const DMatrixSlice &gms_rhs1, BLAS_Cpp::Transp trans_rhs1, const COOMatrixPartitionedViewUtilityPack::Partition< T_Indice, T_Value > &coom_rhs2, BLAS_Cpp::Transp trans_rhs2)
 gms_lhs += alpha * op(gms_rhs1) * op(coom_rhs2) (left) (BLAS xGEMM).
template<class T_Indice, class T_Value, class M2>
void Mp_StMtM (DMatrixSlice *gms_lhs, value_type alpha, const COOMatrixPartitionedViewUtilityPack::Partition< T_Indice, T_Value > &coom_rhs1, BLAS_Cpp::Transp trans_rhs1, const M2 &M2_rhs2, BLAS_Cpp::Transp trans_rhs2, value_type beta)
 gms_lhs = alpha * op(coom_rhs1) * op(M2_rhs2) + beta * gms_lhs (right).
template<class M1, class T_Indice, class T_Value>
void Mp_StMtM (DMatrixSlice *gms_lhs, value_type alpha, const M1 &M1_rhs1, BLAS_Cpp::Transp trans_rhs1, const COOMatrixPartitionedViewUtilityPack::Partition< T_Indice, T_Value > &coom_rhs2, BLAS_Cpp::Transp trans_rhs2, value_type beta)
 gms_lhs = alpha * op(M1_rhs1) * op(coom_rhs2) + beta * gms_lhs (right).

{\bf Level-1 BLAS matrix-matrix element-wise operations}.

template<class T_Indice, class T_Value>
void Mp_StM (DMatrixSlice *gms_lhs, value_type alpha, const COOMatrixPartitionedViewUtilityPack::TransposedPartition< T_Indice, T_Value > &coom_rhs, BLAS_Cpp::Transp trans_rhs)
 gms_lhs += alpha * op(coom_rhs) (time = O(coom_rhs.nz()), space = O(1)).

{\bf Level-2 BLAS (vector-matrtix) Liner Algebra Operations}.

These are functions that implement linear algebra operations that have DVector or DVectorSlice objects as lhs operands and a mixture of matrix and DVectorSlice rhs operands.

template<class T_Indice, class T_Value>
void Vp_StMtV (DVectorSlice *vs_lhs, value_type alpha, const COOMatrixPartitionedViewUtilityPack::TransposedPartition< T_Indice, T_Value > &coom_rhs1, BLAS_Cpp::Transp trans_rhs1, const DVectorSlice &vs_rhs2)
 vs_lhs += alpha * op(coom_rhs1) * vs_rhs2 (BLAS xGEMV) (time = O(coom_rhs.nz()), space = O(1)).
template<class T_Indice, class T_Value>
void Vp_StMtV (DVectorSlice *vs_lhs, value_type alpha, const COOMatrixPartitionedViewUtilityPack::TransposedPartition< T_Indice, T_Value > &coom_rhs1, BLAS_Cpp::Transp trans_rhs1, const DVectorSlice &vs_rhs2, value_type beta)
 vs_lhs += alpha * op(coom_rhs1) * vs_rhs2 (BLAS xGEMV) (time = O(coom_rhs.nz()), space = O(1)).

{\bf Level-3 BLAS (matrix-matrix) Linear Algebra Operations}.

template<class T_Indice, class T_Value>
void Mp_StMtM (DMatrixSlice *gms_lhs, value_type alpha, const COOMatrixPartitionedViewUtilityPack::TransposedPartition< T_Indice, T_Value > &coom_rhs1, BLAS_Cpp::Transp trans_rhs1, const DMatrixSlice &gms_rhs2, BLAS_Cpp::Transp trans_rhs2)
 gms_lhs += alpha * op(coom_rhs1) * op(gms_rhs2) (right) (BLAS xGEMM).
template<class T_Indice, class T_Value>
void Mp_StMtM (DMatrixSlice *gms_lhs, value_type alpha, const DMatrixSlice &gms_rhs1, BLAS_Cpp::Transp trans_rhs1, const COOMatrixPartitionedViewUtilityPack::TransposedPartition< T_Indice, T_Value > &coom_rhs2, BLAS_Cpp::Transp trans_rhs2)
 gms_lhs += alpha * op(gms_rhs1) * op(coom_rhs2) (left) (BLAS xGEMM).
template<class T_Indice, class T_Value, class M2>
void Mp_StMtM (DMatrixSlice *gms_lhs, value_type alpha, const COOMatrixPartitionedViewUtilityPack::TransposedPartition< T_Indice, T_Value > &coom_rhs1, BLAS_Cpp::Transp trans_rhs1, const M2 &M2_rhs2, BLAS_Cpp::Transp trans_rhs2, value_type beta)
 gms_lhs = alpha * op(coom_rhs1) * op(M2_rhs2) + beta * gms_lhs (right).
template<class M1, class T_Indice, class T_Value>
void Mp_StMtM (DMatrixSlice *gms_lhs, value_type alpha, const M1 &M1_rhs1, BLAS_Cpp::Transp trans_rhs1, const COOMatrixPartitionedViewUtilityPack::TransposedPartition< T_Indice, T_Value > &coom_rhs2, BLAS_Cpp::Transp trans_rhs2, value_type beta)
 gms_lhs = alpha * op(M1_rhs1) * op(coom_rhs2) + beta * gms_lhs (right).

{\bf Templated Matrix-DVector Operations}.

These are the declarations (AbstractLinAlgPack_MatrixVectorTemplateOp.hpp) for template functions for performing selected matrix-vector and matrix-matrix operations. The templated matrix type must have the following interface: {itemize} T_Matrix::size_type# - Member type for the type returned by rows# and cols# T_Matrix::row_type# - Member type for the type returned by row(i)# T_Matrix::col_type# - Member type for the type returned by col(j)# T_Matrix::size_type T_Matrix::rows() const# T_Matrix::size_type T_Matrix::cols() const# const T_Matrix::row_type& T_Matrix::row(size_type i) const# \
  • Returns a reference to the ith row (1,2,...,T_Matrix::rows()#). const T_Matrix::col_type& T_Matrix::col(size_type j) const# \
  • Returns a reference to the ith row (1,2,...,T_Rect_Matrix::rows()#). {itemize}

In addition, the following operations (UML notation) must be accessible for the types T_Matrix::row_type# and T_Matrix::col_type# when these template functions are instantiated:

assign(v_lhs:DVector&,v_rhs:T_Matrix::const row_type&) assign(vs_lhs:DVectorSlice&,v_rhs:const T_Matrix::row_type&) dot(vs_rhs1:const DVectorSlice&, vs_rhs2: const T_Matrix::row_type&):value_type dot(vs_rhs1:const DVectorSlice&, vs_rhs2: const T_Matrix::col_type&):value_type

template<class T_Matrix>
void assign (DMatrix &gm_lhs, const T_Matrix &gm_rhs, BLAS_Cpp::Transp trans_rhs)
 gm_lhs = T_M (templated matrix type T_M)
template<class T_Matrix>
void assign (DMatrixSlice &gms_lhs, const T_Matrix &gm_rhs, BLAS_Cpp::Transp trans_rhs)
 gms_lhs = T_M (templated matrix type T_M)
template<class T_Matrix>
void V_MtV (DVector &v_lhs, const T_Matrix &gm_rhs1, BLAS_Cpp::Transp trans_rhs1, const DVectorSlice &vs_rhs2)
 v_lhs = T_M * vs_lhs (templated matrix type T_M)
template<class T_Matrix>
void V_MtV (DVectorSlice &v_lhs, const T_Matrix &gm_rhs1, BLAS_Cpp::Transp trans_rhs1, const DVectorSlice &vs_rhs2)
 vs_lhs = T_M * vs_lhs (templated matrix type T_M)

Template operations for sparse vectors.

These functions implement level 1 and 2 BLAS like linear algebra operations on unsorted sparse vectors. These templated sparse vector objects give information about the sparse vector (size, nonzeros etc.) and give access to the sparse elements as iterators. The iterators yield sparse elements that give the elements indice in the full vector and its value.

The specification for these interfaces is as follows:

{verbatim} class SparseElementTemplateInterface { public: typedef .... value_type; typedef .... indice_type;

value_type& value(); value_type value() const; indice_type indice() const; };

class SparseVectorTemplateInterface { public: typedef ... difference_type; typedef ... element_type; // SparseElementTemplateInterface compliant typedef ... iterator; // *(iter) yields a element_type typedef ... const_iterator; // *(iter) yields a const element_type typedef ... reverse_iterator; // *(iter) yields a element_type typedef ... const_reverse_iterator; // *(iter) yields a const element_type

Information size_type size() const; // size of the full vector size_type nz() const; // number of nonzero elements difference_type offset() const; // ith real real indice = begin()[i-1] + offset() bool is_sorted() const; // true if elements are sorted by indice

iterate forward (sorted) through elemlents iterator begin(); const_iterator begin() const; iterator end(); const_iterator end() const;

iterate backward (sorted) through elemlents reverse_iterator rbegin(); const_reverse_iterator rbegin() const; reverse_iterator rend(); const_reverse_iterator rend() const; }; /end{verbatim}

In all of these functions where we have some operation that yields a dense vector being added to another function such as:

v_lhs = operation + vs_rhs2

it is allowed that v_lhs.overlap(vs_rhs2) == SAME_MEM. In this case no unnecesary operations will be performed. Also, it is up the the user to ensure that there is not an alias problem where if v_lhs is the same as vs_rhs2 and vs_rhs2 is also used in the operation. This has undefined results. If a future version of the library this may be handeled but for now it is not.

These operations use the same nameing convensions as those for DVector and DVectorSlice in DenseLinAlgPack with the acception that the sparse vectors are given the tag SV# instead of V# so as to not destroy the intended behavior of the operations in DenseLinAlgPack and the implicit conversion of a DVector to a DVectorSlice.

It should be noted that these operations will be more efficient for large dense vectors and sparse vectors with many nonzero elements if the sparse elements are sorted by indice. This is because in many operations the elements of the dense vectors are accessed using random access and this could cause virtual page thrashing if the nonzero sparse elements are not sorted.

template<class T_SpVec>
value_type dot_V_SV (const DVectorSlice &vs_rhs1, const T_SpVec &sv_rhs2)
 result = dot(vs_rhs1,sv_rhs2) (BLAS xDOT)
template<class T_SpVec>
value_type dot_SV_V (const T_SpVec &sv_rhs1, const DVectorSlice &vs_rhs2)
 result = dot(sv_rhs1,vs_rhs2) (BLAS xDOT)
template<class T_SpVec>
value_type norm_1_SV (const T_SpVec &sv_rhs)
 result = ||sv_rhs||1 (BLAS xASUM)
template<class T_SpVec>
value_type norm_2_SV (const T_SpVec &sv_rhs)
 result = ||sv_rhs||2 (BLAS xNRM2)
template<class T_SpVec>
value_type norm_inf_SV (const T_SpVec &sv_rhs)
 result = ||sv_rhs||inf (BLAS IxAMAX)
template<class T_SpVec>
value_type max_SV (const T_SpVec &sv_rhs)
 result = max(sv_rhs)
template<class T_SpVec>
value_type min_SV (const T_SpVec &sv_rhs)
 result = min(sv_rhs)
template<class T_SpVec>
void Vt_S (T_SpVec *sv_lhs, value_type alpha)
 sv_lhs *= alpha (BLAS xSCAL)
template<class T_SpVec>
void Vp_StSV (DVectorSlice *vs_lhs, value_type alpha, const T_SpVec &sv_rhs)
 vs_lhs += alpha * sv_rhs (BLAS xAXPY)
template<class T_SpVec>
void Vp_StMtSV (DVectorSlice *vs_lhs, value_type alpha, const DMatrixSlice &gms_rhs1, BLAS_Cpp::Transp trans_rhs1, const T_SpVec &sv_rhs2)
 vs_lhs += alpha * op(gms_rhs1) * sv_rhs2 (BLAS xGEMV)
template<class T_SpVec>
void Vp_StMtSV (DVectorSlice *vs_lhs, value_type alpha, const DMatrixSliceTri &tri_rhs1, BLAS_Cpp::Transp trans_rhs1, const T_SpVec &sv_rhs2)
 vs_lhs += alpha * op(tri_gms_rhs1) * sv_rhs2 (BLAS xTRMV)
template<class T_SpVec>
void Vp_StMtSV (DVectorSlice *vs_lhs, value_type alpha, const DMatrixSliceSym &sym_rhs1, BLAS_Cpp::Transp trans_rhs1, const T_SpVec &sv_rhs2)
 vs_lhs += alpha * op(sym_gms_rhs1) * sv_rhs2 (BLAS xSYMV)

Inline functions to call linear algebra operations for SparseVectoSlice<> objects.

These inline functions use the same exact syntax as the DenseLinAlgPack linear algebra operations. They call the generic templated linear algebra operations for the SparseVectorTemplateInterface interface. With these functions the abreaviation for the sparse vector SV# is replaced with the standard V#. The assignmet operation V_SV# is replaced with the more uniform assign# identifier so as to be compatable with DenseLinAlgPack naming. Also, the suffixes for dot#, norm_1#, and the other level one BLAS operations is dropped.

In order to use SparseVector<> objects with these functions the client must perform an explicit conversion. For example the following code will not compile (can not perform conversion from const SparseVector<> to const SparseVectorSlice<>):

SparseVector<element_type> sv; // ... cout << norm_1(sv);

Instead you must perform an explicit conversion for example by using operator()() as follows:

cout << norm_1(sv());

template<class T_Ele>
value_type dot (const DVectorSlice &vs_rhs1, const SparseVectorSlice< T_Ele > &sv_rhs2)
 result = dot(vs_rhs1,sv_rhs2) (BLAS xDOT)
template<class T_Ele>
value_type dot (const SparseVectorSlice< T_Ele > &sv_rhs1, const DVectorSlice &vs_rhs2)
 result = dot(sv_rhs1,vs_rhs2) (BLAS xDOT)
template<class T_Ele>
value_type norm_1 (const SparseVectorSlice< T_Ele > &sv_rhs)
 result = ||sv_rhs||1 (BLAS xASUM)
template<class T_Ele>
value_type norm_2 (const SparseVectorSlice< T_Ele > &sv_rhs)
 result = ||sv_rhs||2 (BLAS xNRM2)
template<class T_Ele>
value_type norm_inf (const SparseVectorSlice< T_Ele > &sv_rhs)
 result = ||sv_rhs||inf (BLAS IxAMAX)
template<class T_Ele>
value_type max (const SparseVectorSlice< T_Ele > &sv_rhs)
 result = max(sv_rhs)
template<class T_Ele>
value_type min (const SparseVectorSlice< T_Ele > &sv_rhs)
 result = min(sv_rhs)
template<class T_Ele>
void Vp_StV (DVectorSlice *vs_lhs, value_type alpha, const SparseVectorSlice< T_Ele > &sv_rhs)
 vs_lhs += alpha * sv_rhs (BLAS xAXPY)
template<class T_Ele>
void Vp_StMtV (DVectorSlice *vs_lhs, value_type alpha, const DMatrixSlice &gms_rhs1, BLAS_Cpp::Transp trans_rhs1, const SparseVectorSlice< T_Ele > &sv_rhs2)
 vs_lhs += alpha * op(gms_rhs1) * sv_rhs2 (BLAS xGEMV)
template<class T_Ele>
void Vp_StMtV (DVectorSlice *vs_lhs, value_type alpha, const DMatrixSliceTri &tri_gms_rhs1, BLAS_Cpp::Transp trans_rhs1, const SparseVectorSlice< T_Ele > &sv_rhs2)
 vs_lhs += alpha * op(tri_gms_rhs1) * sv_rhs2 (BLAS xTRMV)
template<class T_Ele>
void Vp_StMtV (DVectorSlice *vs_lhs, value_type alpha, const DMatrixSliceSym &sym_gms_rhs1, BLAS_Cpp::Transp trans_rhs1, const SparseVectorSlice< T_Ele > &sv_rhs2)
 vs_lhs += alpha * op(sym_gms_rhs1) * sv_rhs2 (BLAS xSYMV)
template<class M, class T_Ele>
void Vp_StMtSVS (DVectorSlice *vs_lhs, value_type alpha, const M &M_rhs1, BLAS_Cpp::Transp trans_rhs1, const SparseVectorSlice< T_Ele > &sv_rhs2, value_type beta)
 vs_lhs = alpha * op(M_rhs1) * sv_rhs2 + beta * vs_lhs
template<class T_Ele>
void Vp_StMtV (DVectorSlice *vs_lhs, value_type alpha, const DMatrixSlice &gms_rhs1, BLAS_Cpp::Transp trans_rhs1, const SparseVectorSlice< T_Ele > &sv_rhs2, value_type beta)
 vs_lhs = alpha * op(gms_rhs1) * sv_rhs2 + beta * vs_lhs
template<class T_Ele>
void Vp_StMtV (DVectorSlice *vs_lhs, value_type alpha, const DMatrixSliceTri &tri_gms_rhs1, BLAS_Cpp::Transp trans_rhs1, const SparseVectorSlice< T_Ele > &sv_rhs2, value_type beta)
 vs_lhs = alpha * op(tri_gms_rhs1) * sv_rhs2 + beta * vs_lhs
template<class T_Ele>
void Vp_StMtV (DVectorSlice *vs_lhs, value_type alpha, const DMatrixSliceSym &sym_gms_rhs1, BLAS_Cpp::Transp trans_rhs1, const SparseVectorSlice< T_Ele > &sv_rhs2, value_type beta)
 vs_lhs = alpha * op(sym_gms_rhs1) * sv_rhs2 + beta * vs_lhs

Operations for GenPermMatrixSlice.

ToDo: Finish documentation!

void V_StMtV (SpVector *sv_lhs, value_type alpha, const GenPermMatrixSlice &P_rhs1,BLAS_Cpp::Transp P_rhs1_trans, const DVectorSlice &vs_rhs2)
 sv_lhs = alpha * op(P_rhs1) * vs_rhs2.
void V_StMtV (SpVector *sv_lhs, value_type alpha, const GenPermMatrixSlice &P_rhs1,BLAS_Cpp::Transp P_rhs1_trans, const SpVectorSlice &sv_rhs2)
 sv_lhs = alpha * op(P_rhs1) * sv_rhs2.
void Vp_StMtV (SpVector *sv_lhs, value_type alpha, const GenPermMatrixSlice &P_rhs1,BLAS_Cpp::Transp P_rhs1_trans, const DVectorSlice &vs_rhs2)
 sv_lhs += alpha * op(P_rhs1) * vs_rhs2.
void Vp_StMtV (DVectorSlice *vs_lhs, value_type alpha, const GenPermMatrixSlice &P_rhs1,BLAS_Cpp::Transp P_rhs1_trans, const DVectorSlice &vs_rhs2, value_type beta=1.0)
 vs_lhs = alpha * op(P_rhs1) * vs_rhs2 + beta * vs_lhs
void Vp_StMtV (DVectorSlice *vs_lhs, value_type alpha, const GenPermMatrixSlice &P_rhs1,BLAS_Cpp::Transp P_rhs1_trans, const SpVectorSlice &sv_rhs2, value_type beta=1.0)
 vs_lhs = alpha * op(P_rhs1) * sv_rhs2 + beta * vs_lhs
void intersection (const GenPermMatrixSlice &P1,BLAS_Cpp::Transp P1_trans,const GenPermMatrixSlice &P2,BLAS_Cpp::Transp P2_trans,size_type *Q_nz,const size_type Q_max_nz=0,size_type Q_row_i[]=NULL,size_type Q_col_j[]=NULL,GenPermMatrixSlice *Q=NULL)
 Find the intersection between two GenPermMatrixSlice objects.
void V_MtV (SpVector *sv_lhs, const GenPermMatrixSlice &P_rhs1, BLAS_Cpp::Transp P_rhs1_trans, const DVectorSlice &vs_rhs2)
 sv_lhs = op(P_rhs1) * vs_rhs2
void V_MtV (SpVector *sv_lhs, const GenPermMatrixSlice &P_rhs1, BLAS_Cpp::Transp P_rhs1_trans, const SpVectorSlice &sv_rhs2)
 sv_lhs = op(P_rhs1) * sv_rhs2
void Vp_MtV (SpVector *sv_lhs, const GenPermMatrixSlice &P_rhs1, BLAS_Cpp::Transp P_rhs1_trans, const DVectorSlice &vs_rhs2)
 sv_lhs += op(P_rhs1) * vs_rhs2.

Level-2 BLAS

void V_InvMtV (DVector *v_lhs, const MatrixNonsingSerial &M_rhs1, BLAS_Cpp::Transp trans_rhs1, const DVectorSlice &vs_rhs2)
 v_lhs = inv(op(M_rhs1)) * vs_rhs2
void V_InvMtV (DVectorSlice *vs_lhs, const MatrixNonsingSerial &M_rhs1, BLAS_Cpp::Transp trans_rhs1, const DVectorSlice &vs_rhs2)
 vs_lhs = inv(op(M_rhs1)) * vs_rhs2
void V_InvMtV (DVector *v_lhs, const MatrixNonsingSerial &M_rhs1, BLAS_Cpp::Transp trans_rhs1, const SpVectorSlice &sv_rhs2)
 v_lhs = inv(op(M_rhs1)) * sv_rhs2
void V_InvMtV (DVectorSlice *vs_lhs, const MatrixNonsingSerial &M_rhs1, BLAS_Cpp::Transp trans_rhs1, const SpVectorSlice &sv_rhs2)
 vs_lhs = inv(op(M_rhs1)) * sv_rhs2
value_type transVtInvMtV (const DVectorSlice &vs_rhs1, const MatrixNonsingSerial &M_rhs2, BLAS_Cpp::Transp trans_rhs2, const DVectorSlice &sv_rhs3)
 result = vs_rhs1' * inv(op(M_rhs2)) * vs_rhs3
value_type transVtInvMtV (const SpVectorSlice &sv_rhs1, const MatrixNonsingSerial &M_rhs2, BLAS_Cpp::Transp trans_rhs2, const SpVectorSlice &sv_rhs3)
 result = sv_rhs1' * inv(op(M_rhs2)) * sv_rhs3

Level-3 BLAS

void M_StInvMtM (DMatrix *gm_lhs, value_type alpha, const MatrixNonsingSerial &M_rhs1, BLAS_Cpp::Transp trans_rhs1, const DMatrixSlice &gms_rhs2, BLAS_Cpp::Transp trans_rhs2)
 gm_lhs = alpha * inv(op(M_rhs1)) * op(gms_rhs2) (right)
void M_StInvMtM (DMatrixSlice *gms_lhs, value_type alpha, const MatrixNonsingSerial &M_rhs1, BLAS_Cpp::Transp trans_rhs1, const DMatrixSlice &gms_rhs2, BLAS_Cpp::Transp trans_rhs2)
 gms_lhs = alpha * inv(op(M_rhs1)) * op(gms_rhs2) (right)
void M_StMtInvM (DMatrix *gm_lhs, value_type alpha, const DMatrixSlice &gms_rhs1, BLAS_Cpp::Transp trans_rhs1, const MatrixNonsingSerial &M_rhs2, BLAS_Cpp::Transp trans_rhs2)
 gm_lhs = alpha * op(gms_rhs1) * inv(op(M_rhs2)) (left)
void M_StMtInvM (DMatrixSlice *gms_lhs, value_type alpha, const DMatrixSlice &gms_rhs1, BLAS_Cpp::Transp trans_rhs1, const MatrixNonsingSerial &M_rhs2, BLAS_Cpp::Transp trans_rhs2)
 gms_lhs = alpha * op(gms_rhs1) * inv(op(M_rhs2)) (left)
void M_StInvMtM (DMatrix *gm_lhs, value_type alpha, const MatrixNonsingSerial &M_rhs1, BLAS_Cpp::Transp trans_rhs1, const MatrixOpSerial &mwo_rhs2, BLAS_Cpp::Transp trans_rhs2)
 gm_lhs = alpha * inv(op(M_rhs1)) * op(mwo_rhs2) (right)
void M_StInvMtM (DMatrixSlice *gms_lhs, value_type alpha, const MatrixNonsingSerial &M_rhs1, BLAS_Cpp::Transp trans_rhs1, const MatrixOpSerial &mwo_rhs2, BLAS_Cpp::Transp trans_rhs2)
 gms_lhs = alpha * inv(op(M_rhs1)) * op(mwo_rhs2) (right)
void M_StMtInvM (DMatrix *gm_lhs, value_type alpha, const MatrixOpSerial &mwo_rhs1, BLAS_Cpp::Transp trans_rhs1, const MatrixNonsingSerial &M_rhs2, BLAS_Cpp::Transp trans_rhs2)
 gm_lhs = alpha * op(mwo_rhs1) * inv(op(M_rhs2)) (left)
void M_StMtInvM (DMatrixSlice *gms_lhs, value_type alpha, const MatrixOpSerial &mwo_rhs1, BLAS_Cpp::Transp trans_rhs1, const MatrixNonsingSerial &M_rhs2, BLAS_Cpp::Transp trans_rhs2)
 gms_lhs = alpha * op(mwo_rhs1) * inv(op(M_rhs2)) (left)

Level-1 BLAS

void Mp_StM (DMatrixSlice *gms_lhs, value_type alpha, const MatrixOpSerial &M_rhs, BLAS_Cpp::Transp trans_rhs)
 gms_lhs += alpha * op(M_rhs) (BLAS xAXPY)
void Mp_StMtP (DMatrixSlice *gms_lhs, value_type alpha, const MatrixOpSerial &M_rhs, BLAS_Cpp::Transp M_trans, const GenPermMatrixSlice &P_rhs, BLAS_Cpp::Transp P_rhs_trans)
 gms_lhs += alpha * op(M_rhs) * op(P_rhs)
void Mp_StPtM (DMatrixSlice *gms_lhs, value_type alpha, const GenPermMatrixSlice &P_rhs, BLAS_Cpp::Transp P_rhs_trans, const MatrixOpSerial &M_rhs, BLAS_Cpp::Transp M_trans)
 gms_lhs += alpha * op(P) * op(M_rhs)
void Mp_StPtMtP (DMatrixSlice *gms_lhs, value_type alpha, const GenPermMatrixSlice &P_rhs1, BLAS_Cpp::Transp P_rhs1_trans, const MatrixOpSerial &M_rhs, BLAS_Cpp::Transp trans_rhs, const GenPermMatrixSlice &P_rhs2, BLAS_Cpp::Transp P_rhs2_trans)
 gms_lhs += alpha * op(P_rhs1) * op(M_rhs) * op(P_rhs2)

Level-2 BLAS

void Vp_StMtV (DVectorSlice *vs_lhs, value_type alpha, const MatrixOpSerial &M_rhs1, BLAS_Cpp::Transp trans_rhs1, const DVectorSlice &vs_rhs2, value_type beta=1.0)
 vs_lhs = alpha * op(M_rhs1) * vs_rhs2 + beta * vs_lhs (BLAS xGEMV)
void Vp_StMtV (DVectorSlice *vs_lhs, value_type alpha, const MatrixOpSerial &M_rhs1, BLAS_Cpp::Transp trans_rhs1, const SpVectorSlice &sv_rhs2, value_type beta=1.0)
 vs_lhs = alpha * op(M_rhs1) * sv_rhs2 + beta * vs_lhs (BLAS xGEMV)
void Vp_StPtMtV (DVectorSlice *vs_lhs, value_type alpha, const GenPermMatrixSlice &P_rhs1, BLAS_Cpp::Transp P_rhs1_trans, const MatrixOpSerial &M_rhs2, BLAS_Cpp::Transp M_rhs2_trans, const DVectorSlice &vs_rhs3, value_type beta=1.0)
 vs_lhs = alpha * op(P_rhs1) * op(M_rhs2) * vs_rhs3 + beta * vs_rhs
void Vp_StPtMtV (DVectorSlice *vs_lhs, value_type alpha, const GenPermMatrixSlice &P_rhs1, BLAS_Cpp::Transp P_rhs1_trans, const MatrixOpSerial &M_rhs2, BLAS_Cpp::Transp M_rhs2_trans, const SpVectorSlice &sv_rhs3, value_type beta=1.0)
 vs_lhs = alpha * op(P_rhs1) * op(M_rhs2) * sv_rhs3 + beta * vs_rhs
value_type transVtMtV (const DVectorSlice &vs_rhs1, const MatrixOpSerial &M_rhs2, BLAS_Cpp::Transp trans_rhs2, const DVectorSlice &vs_rhs3)
 result = vs_rhs1' * op(M_rhs2) * vs_rhs3
value_type transVtMtV (const SpVectorSlice &sv_rhs1, const MatrixOpSerial &M_rhs2, BLAS_Cpp::Transp trans_rhs2, const SpVectorSlice &sv_rhs3)
 result = sv_rhs1' * op(M_rhs2) * sv_rhs3

Level-3 BLAS

void Mp_StMtM (DMatrixSlice *gms_lhs, value_type alpha, const MatrixOpSerial &M_rhs1, BLAS_Cpp::Transp trans_rhs1, const DMatrixSlice &gms_rhs2, BLAS_Cpp::Transp trans_rhs2, value_type beta=1.0)
 gms_lhs = alpha * op(M_rhs1) * op(gms_rhs2) + beta * gms_lhs (right) (xGEMM)
void Mp_StMtM (DMatrixSlice *gms_lhs, value_type alpha, const DMatrixSlice &gms_rhs1, BLAS_Cpp::Transp trans_rhs1, const MatrixOpSerial &M_rhs2, BLAS_Cpp::Transp trans_rhs2, value_type beta=1.0)
 gms_lhs = alpha * op(gms_rhs1) * op(M_rhs2) + beta * gms_lhs (left) (xGEMM)
void Mp_StMtM (DMatrixSlice *gms_lhs, value_type alpha, const MatrixOpSerial &mwo_rhs1, BLAS_Cpp::Transp trans_rhs1, const MatrixOpSerial &gms_rhs2, BLAS_Cpp::Transp trans_rhs2, value_type beta=1.0)
 gms_lhs = alpha * op(mwo_rhs1) * op(mwo_rhs2) + beta * gms_lhs (right) (xGEMM)
void Mp_StMtM (DMatrixSlice *gms_lhs, value_type alpha, const MatrixOpSerial &M_rhs1, BLAS_Cpp::Transp trans_rhs1, const DMatrixSliceSym &sym_rhs2, BLAS_Cpp::Transp trans_rhs2, value_type beta=1.0)
 gms_lhs = alpha * op(M_rhs1) * op(sym_rhs2) + beta * gms_lhs (right) (xSYMM)
void Mp_StMtM (DMatrixSlice *gms_lhs, value_type alpha, const DMatrixSliceSym &sym_rhs1, BLAS_Cpp::Transp trans_rhs1, const MatrixOpSerial &M_rhs2, BLAS_Cpp::Transp trans_rhs2, value_type beta=1.0)
 gms_lhs = alpha * op(sym_rhs1) * op(M_rhs2) + beta * gms_lhs (left) (xSYMM)
void Mp_StMtM (DMatrixSlice *gms_lhs, value_type alpha, const MatrixOpSerial &M_rhs1, BLAS_Cpp::Transp trans_rhs1, const DMatrixSliceTri &tri_rhs2, BLAS_Cpp::Transp trans_rhs2, value_type beta=1.0)
 gms_lhs = alpha * op(M_rhs1) * op(tri_rhs2) + beta * gms_lhs (right) (xTRMM)
void Mp_StMtM (DMatrixSlice *gms_lhs, value_type alpha, const DMatrixSliceTri &tri_rhs1, BLAS_Cpp::Transp trans_rhs1, const MatrixOpSerial &M_rhs2, BLAS_Cpp::Transp trans_rhs2, value_type beta=1.0)
 gms_lhs = alpha * op(tri_rhs1) * op(M_rhs2) + beta * gms_lhs (left) (xTRMM)

Typedefs

typedef RTOp_index_type size_type
typedef RTOp_value_type value_type
typedef RTOp_index_type index_type
typedef DenseLinAlgPack::VectorTmpl<
value_type
DVector
 
typedef DenseLinAlgPack::VectorSliceTmpl<
value_type
DVectorSlice
 
typedef DenseLinAlgPack::DMatrix DMatrix
 
typedef DenseLinAlgPack::DMatrixSlice DMatrixSlice
 
typedef DenseLinAlgPack::DMatrixSliceTriEle DMatrixSliceTriEle
 
typedef DenseLinAlgPack::DMatrixSliceTri DMatrixSliceTri
 
typedef DenseLinAlgPack::DMatrixSliceSym DMatrixSliceSym
 
typedef RangePack::Range1D Range1D
 

Enumerations

enum  EApplyBy { APPLY_BY_ROW, APPLY_BY_COL }
  More...

Functions

void apply_op_validate_input (const char func_name[],const RTOpPack::RTOp &op,const size_t num_vecs, const Vector *vecs[],const size_t num_targ_vecs, VectorMutable *targ_vecs[],RTOpPack::ReductTarget *reduct_obj,const index_type first_ele, const index_type sub_dim, const index_type global_offset)
 Validate the inputs to apply_op().
void apply_op_serial (const RTOpPack::RTOp &op,const size_t num_vecs, const Vector *vecs[],const size_t num_targ_vecs, VectorMutable *targ_vecs[],RTOpPack::ReductTarget *reduct_obj,const index_type first_ele, const index_type sub_dim, const index_type global_offset)
 Implements reduction/transformation operators for any serial vectors using just the public vector interface.
std::ostream & operator<< (std::ostream &out, const GenPermMatrixSlice &P)
 Print the contents of a GenPermMatrixSlice object in machine readable format.
std::ostream & operator<< (std::ostream &o, const MatrixOp &M)
 Output operator for MatrixOp} objects.
void M_StMtInvMtM (MatrixSymOp *sym_gms_lhs, value_type alpha, const MatrixOp &mwo, BLAS_Cpp::Transp mwo_trans, const MatrixSymNonsing &mswof, MatrixSymNonsing::EMatrixDummyArg mwo_rhs)
 sym_gms_lhs = alpha * op(mwo) * inv(mswof) * op(mwo)'
void Mp_StPtMtP (MatrixSymOp *sym_lhs, value_type alpha, MatrixSymOp::EMatRhsPlaceHolder dummy_place_holder, const MatrixSymOp &M, const GenPermMatrixSlice &gpms_rhs, BLAS_Cpp::Transp gpms_rhs_trans, value_type beta=1.0)
 sym_lhs = alpha * op(gpms_rhs') * M * op(gpms_rhs) + beta * sym_lhs.
void Mp_StMtMtM (MatrixSymOp *sym_lhs, value_type alpha, MatrixSymOp::EMatRhsPlaceHolder dummy_place_holder, const MatrixSymOp &M, const MatrixOp &mwo_rhs, BLAS_Cpp::Transp mwo_rhs_trans, value_type beta=1.0)
 sym_lhs = alpha * op(mwo_rhs') * M * op(mwo_rhs) + beta * sym_lhs
void apply_op (EApplyBy apply_by,const RTOpPack::RTOp &primary_op,const size_t num_multi_vecs,const MultiVector *multi_vecs[],const size_t num_targ_multi_vecs,MultiVectorMutable *targ_multi_vecs[],RTOpPack::ReductTarget *reduct_objs[]=NULL,const index_type primary_first_ele=1,const index_type primary_sub_dim=0,const index_type primary_global_offset=0,const index_type secondary_first_ele=1,const index_type secondary_sub_dim=0)
 Apply a reduction/transformation operator column by column and return an array of the reduction objects.
void apply_op (EApplyBy apply_by,const RTOpPack::RTOp &primary_op,const RTOpPack::RTOp &secondary_op,const size_t num_multi_vecs,const MultiVector *multi_vecs[],const size_t num_targ_multi_vecs,MultiVectorMutable *targ_multi_vecs[],RTOpPack::ReductTarget *reduct_obj,const index_type primary_first_ele=1,const index_type primary_sub_dim=0,const index_type primary_global_offset=0,const index_type secondary_first_ele=1,const index_type secondary_sub_dim=0)
 Apply a reduction/transformation operator column by column and reduce the intermediate reduction objects into one reduction object.
std::ostream & operator<< (std::ostream &o, const Permutation &P)
 Output operator for Permutation objects.
std::ostream & operator<< (std::ostream &os, const SpVectorSlice &svs)
 SpVectorSlice output stream operator.
RTOpPack::SparseSubVector sub_vec_view (const SpVectorSlice &sv,const Range1D &rng=Range1D())
 Create an RTOpPack::SparseSubVector view object from a SpVectorSlice object.
void apply_op (const RTOpPack::RTOp &op,const size_t num_vecs,const Vector *vecs[],const size_t num_targ_vecs,VectorMutable *targ_vecs[],RTOpPack::ReductTarget *reduct_obj,const index_type first_ele=1,const index_type sub_dim=0,const index_type global_offset=0)
 Apply a reduction/transformation,operation over a set of vectors: op(op(v[0]...v[nv-1],z[0]...z[nz-1]),(*reduct_obj)) -> z[0]...z[nz-1],(*reduct_obj).
void Vp_StMtV (VectorMutable *y, value_type alpha, const GenPermMatrixSlice &P, BLAS_Cpp::Transp P_trans, const Vector &x, value_type beta=1.0)
 y = alpha * op(P) * x + beta *y
std::ostream & operator<< (std::ostream &o, const Vector &v)
 Output operator for Vector} objects.
AbstractLinAlgPack::value_type sum (const Vector &v_rhs)
 result = sum( v_rhs(i), i = 1,,,dim )
AbstractLinAlgPack::value_type dot (const Vector &v_rhs1, const Vector &v_rhs2)
 result = v_rhs1' * v_rhs2
AbstractLinAlgPack::value_type dot (const Vector &v_rhs1, const SpVectorSlice &sv_rhs2)
 result = v_rhs1' * sv_rhs2
void max_abs_ele (const Vector &v, value_type *max_v_j, index_type *max_j)
 Compute the maximum element in a vector.
void Vp_S (VectorMutable *v_lhs, const value_type &alpha)
 v_lhs += alpha
void Vt_S (VectorMutable *v_lhs, const value_type &alpha)
 v_lhs *= alpha
void Vp_StV (VectorMutable *v_lhs, const value_type &alpha, const Vector &v_rhs)
 v_lhs = alpha * v_rhs + v_lhs
void Vp_StV (VectorMutable *v_lhs, const value_type &alpha, const SpVectorSlice &sv_rhs)
 v_lhs = alpha * sv_rhs + v_lhs
void ele_wise_prod (const value_type &alpha, const Vector &v_rhs1, const Vector &v_rhs2,VectorMutable *v_lhs)
 v_lhs(i) += alpha * v_rhs1(i) * v_rhs2(i), i = 1,,,dim.
void ele_wise_divide (const value_type &alpha, const Vector &v_rhs1, const Vector &v_rhs2,VectorMutable *v_lhs)
 v_lhs(i) = alpha * v_rhs1(i) / v_rhs2(i), i = 1,,,dim.
void seed_random_vector_generator (unsigned int)
 Seed the random number generator.
void random_vector (value_type l, value_type u, VectorMutable *v)
 Generate a random vector with elements uniformly distrubuted elements.
void sign (const Vector &v,VectorMutable *z)
 Compute the sign of each element in an input vector.
value_type dot (const SpVectorSlice &sv_rhs1, const Vector &v_rhs2)
 result = sv_rhs1' * v_rhs2
AbstractLinAlgPack::value_type dot (const SpVectorSlice &sv_rhs1, const Vector &v_rhs2)
 result = sv_rhs1' * v_rhs2
bool assert_print_nan_inf (const value_type &val, char name[], bool throw_excpt, std::ostream *out)
 This function asserts if a value_type scalare is a NaN or Inf and optionally prints out these entires.
bool assert_print_nan_inf (const Vector &v, char name[], bool throw_excpt, std::ostream *out)
 This function asserts if a vector has any NaN or inf entries and optionally prints out these entires.
bool TestMatrixSymSecant (const MatrixOp &B,const Vector &s,const Vector &y,value_type warning_tol,value_type error_tol,bool print_all_warnings,std::ostream *out,bool trase=true)
 Checks the secant condition B*s = y.
AbstractLinAlgPack::value_type max_element (const Vector &v)
 Compute the maximum element in a vector.
std::pair< AbstractLinAlgPack::value_type,
AbstractLinAlgPack::value_type
max_near_feas_step (const Vector &x, const Vector &d,const Vector &xl, const Vector &xu,value_type max_bnd_viol)
 Computes the maximum positive and negative step that can be taken that are within the relaxed bounds.
AbstractLinAlgPack::value_type max_rel_step (const Vector &x, const Vector &d)
 Computes the maximum relative step of x = x + d.
AbstractLinAlgPack::value_type fraction_to_boundary (const value_type tau, const Vector &x, const Vector &d, const Vector &xl, const Vector &xu)
AbstractLinAlgPack::value_type fraction_to_zero_boundary (const value_type tau, const Vector &x, const Vector &d)
AbstractLinAlgPack::size_type num_bounded (const Vector &xl, const Vector &xu,value_type inf_bound)
 Count the number of finitly bounded elements in xl <= x <= xu.
AbstractLinAlgPack::value_type log_bound_barrier (const Vector &x,const Vector &xl,const Vector &xu)
 Computes the log barrier term:.
AbstractLinAlgPack::value_type combined_nu_comp_err (const Vector &v,const Vector &x,const Vector &xl,const Vector &xu)
 Computes an estimate of the complementarity error.
AbstractLinAlgPack::value_type combined_nu_comp_err_lower (const Vector &v,const Vector &x,const Vector &xl)
 Computes an estimate of the complementarity error when only the lower bounds are non-infinite.
AbstractLinAlgPack::value_type combined_nu_comp_err_upper (const Vector &v,const Vector &x,const Vector &xu)
 Computes an estimate of the complementarity error when only the upper bounds are non-infinite.
AbstractLinAlgPack::value_type IP_comp_err_with_mu (const value_type mu,const value_type inf_bound,const Vector &x,const Vector &xl,const Vector &xu,const Vector &vl,const Vector &vu)
 Computes the complementarity error for a primal/dual interior point algorithm using inf norm.
bool max_inequ_viol (const AbstractLinAlgPack::Vector &v,const AbstractLinAlgPack::Vector &vL,const AbstractLinAlgPack::Vector &vU,AbstractLinAlgPack::size_type *max_viol_i,AbstractLinAlgPack::value_type *max_viol,AbstractLinAlgPack::value_type *v_i,int *bnd_type,AbstractLinAlgPack::value_type *vLU_i)
 Compute the maximum violation from a set of inequality constraints vL <= v <= vU.
void force_in_bounds (const Vector &xl, const Vector &xu, VectorMutable *x)
 Force a vector in bounds.
void force_in_bounds_buffer (const value_type rel_push, const value_type abs_push, const Vector &xl, const Vector &xu, VectorMutable *x)
 Force a vector sufficiently within bounds according to a specified absolute and relative buffer.
void inv_of_difference (const value_type alpha,const Vector &v0,const Vector &v1,VectorMutable *z)
 Computes the inverse of the difference between two vectors.
void correct_lower_bound_multipliers (const Vector &xl,const value_type inf_bound_limit,VectorMutable *vl)
 Corrects the lower bound multipliers with infinite bounds.
void correct_upper_bound_multipliers (const Vector &xu,const value_type inf_bound_limit,VectorMutable *vu)
 Corrects the upper bound multipliers with infinite bounds.
void lowerbound_multipliers_step (const value_type mu, const Vector &invXl, const Vector &vl, const Vector &d_k, VectorMutable *dvl)
 Calculates the multiplier step for lower bounds.
void upperbound_multipliers_step (const value_type mu, const Vector &invXu, const Vector &vu, const Vector &d_k, VectorMutable *dvu)
 Calculates the multiplier step for the upper bounds.
void ele_wise_sqrt (VectorMutable *z)
 Calculates the sqrt of each element in the vector Pre Condition: all elements of z must be positive.
void max_vec_scalar (value_type min_ele,VectorMutable *y)
 Take the maximum value of the vector elements and a scalar.
void max_abs_vec_scalar (value_type min_ele,VectorMutable *y)
 Take the maximum value of the absolute vector elements and a scalar.
std::istream & operator>> (std::istream &istrm, COOMatrix &coom)
 Inputstream stream operator for COOMatrix.
std::ostream & operator<< (std::ostream &o, const COOMatrix &coom)
 Output stream operator for COOMatrix.
std::ostream & output (std::ostream &o, const COOMatrix &coom)
 Output stream function for COOMatrix.
template<class T_Indice, class T_Value>
COOMatrixPartitionedViewUtilityPack::TransposedPartition<
T_Indice, T_Value > 
trans (COOMatrixPartitionedViewUtilityPack::Partition< T_Indice, T_Value > &part)
 Create a transposed view of a partition object.
template<class T_COOM>
void Mp_StCOOM (DMatrixSlice *gms_lhs, value_type alpha, const T_COOM &coom_rhs, BLAS_Cpp::Transp trans_rhs)
 gms_lhs += alpha * op(coom_rhs) (time = O(coom_rhs.nz(), space = O(1))
template<class T_COOM>
void Vp_StCOOMtV (DVectorSlice *vs_lhs, value_type alpha, const T_COOM &coom_rhs1, BLAS_Cpp::Transp trans_rhs1, const DVectorSlice &vs_rhs2)
 vs_lhs += alpha * op(coom_rhs1) * vs_rhs2 (BLAS xGEMV) (time = O(coom_rhs.nz(), space = O(1))
template<class T_COOM>
void Mp_StCOOMtM (DMatrixSlice *gms_lhs, value_type alpha, const T_COOM &coom_rhs1, BLAS_Cpp::Transp trans_rhs1, const DMatrixSlice &gms_rhs2, BLAS_Cpp::Transp trans_rhs2)
 gms_lhs += alpha * op(coom_rhs1) * op(gms_rhs2) (right) (BLAS xGEMM)
template<class T_COOM>
void Mp_StMtCOOM (DMatrixSlice *gms_lhs, value_type alpha, const DMatrixSlice &gms_rhs1, BLAS_Cpp::Transp trans_rhs1, const T_COOM &coom_rhs2, BLAS_Cpp::Transp trans_rhs2)
 gms_lhs += alpha * op(gms_rhs1) * op(coom_rhs2) (left) (BLAS xGEMM)
template<class T_Indice, class T_Value>
std::ostream & operator<< (std::ostream &os, const COOMatrixPartitionedViewUtilityPack::Partition< T_Indice, T_Value > &part)
 Partition<> output stream operator.
template<class T_Indice, class T_Value>
std::ostream & operator<< (std::ostream &os, const COOMatrixPartitionedViewUtilityPack::TransposedPartition< T_Indice, T_Value > &trans_part)
 TransposedPartition<> output stream operator.
template<class M_t, class V_t>
void dense_Vp_StPtMtV (DVectorSlice *y, value_type a, const GenPermMatrixSlice &P, BLAS_Cpp::Transp P_trans, const M_t &M, BLAS_Cpp::Transp M_trans, const V_t &x, value_type b)
 Implements y = b*y + a*op(P)*op(M)*x where it is assumed that generating rows of op(M) is cheap compared to computing op(M)*x.
template<class T_Matrix>
void assign (DMatrix &gm_lhs, const T_Matrix &gm_rhs, BLAS_Cpp::Transp trans_rhs)
 gm_lhs = T_M (templated matrix type T_M)
template<class T_Matrix>
void assign (DMatrixSlice &gms_lhs, const T_Matrix &gm_rhs, BLAS_Cpp::Transp trans_rhs)
 gms_lhs = T_M (templated matrix type T_M)
template<class T_Matrix>
void V_MtV (DVector &v_lhs, const T_Matrix &gm_rhs1, BLAS_Cpp::Transp trans_rhs1, const DVectorSlice &vs_rhs2)
 v_lhs = T_M * vs_lhs (templated matrix type T_M)
template<class T_Matrix>
void V_MtV (DVectorSlice &v_lhs, const T_Matrix &gm_rhs1, BLAS_Cpp::Transp trans_rhs1, const DVectorSlice &vs_rhs2)
 vs_lhs = T_M * vs_lhs (templated matrix type T_M)
void rank_2_chol_update (const value_type a,DVectorSlice *u,const DVectorSlice &v,DVectorSlice *w,DMatrixSliceTriEle *R,BLAS_Cpp::Transp R_trans)
 Update the cholesky factor of symmetric positive definite matrix for a rank-2 update.
void imp_sparse_bnd_diff (int sign, const SpVectorSlice &sv, BLAS_Cpp::Uplo uplo, const DVectorSlice &v, DVectorSlice *r)
 Take the difference between a spare lower bound vector and a dense vector.
void read_coo_into_valarrays (std::istream &istrm, size_type &m, size_type &n, size_type &nz, std::valarray< value_type > &a, std::valarray< indice_type > &ivect, std::valarray< indice_type > &jvect)
 Read in a Coordinate Matrix from a C++ input stream and store it in valarrays.
template<class T_Indice, class T_Value>
std::ostream & operator<< (std::ostream &o, const SparseElement< T_Indice, T_Value > &ele)
 Outputs a SparseElement<> object.
void add_elements (SpVector *sv_lhs, value_type alpha, const DVectorSlice &vs_rhs, size_type offset=0, bool add_zeros=true)
 Add elements from a dense vector to a sparse vector.
void add_elements (SpVector *sv_lhs, value_type alpha, const SpVectorSlice &sv_rhs, size_type offset=0, bool add_zeros=true)
 Add elements from a sparse vector to another sparse vector.
DVectorSlice dense_view (SpVectorSlice &sv_rhs)
 Create a dense representation of a sparse vector.
const DVectorSlice dense_view (const SpVectorSlice &sv_rhs)
 
DenseLinAlgPack::DVectorSlice dense_view (SpVectorSlice &sv_rhs)
 Create a dense representation of a sparse vector.
const DenseLinAlgPack::DVectorSlice dense_view (const SpVectorSlice &sv_rhs)
 
template<class Iter, class Cat, class Indice, class ValRef, class Diff>
TransSparseCOOElementViewIter<
Iter, Cat, Indice, ValRef,
Diff > 
operator+ (Diff n, const TransSparseCOOElementViewIter< Iter, Cat, Indice, ValRef, Diff > itr)
void M_StMtInvMtM (DMatrixSliceSym *sym_gms_lhs, value_type alpha, const MatrixOpSerial &mwo, BLAS_Cpp::Transp mwo_trans, const MatrixSymNonsingSerial &mswons, MatrixSymNonsingSerial::EMatrixDummyArg mwo_rhs)
 sym_gms_lhs = alpha * op(mwo) * inv(mswof) * op(mwo)'
void Mp_StPtMtP (DMatrixSliceSym *sym_lhs, value_type alpha, MatrixSymOpSerial::EMatRhsPlaceHolder dummy_place_holder, const MatrixSymOpSerial &M, const GenPermMatrixSlice &gpms_rhs, BLAS_Cpp::Transp gpms_rhs_trans, value_type beta=1.0)
 sym_lhs = alpha * op(gpms_rhs') * M * op(gpms_rhs) + beta * sym_lhs.
void Mp_StMtMtM (DMatrixSliceSym *sym_lhs, value_type alpha, MatrixSymOpSerial::EMatRhsPlaceHolder dummy_place_holder, const MatrixSymOpSerial &M, const MatrixOpSerial &mwo_rhs, BLAS_Cpp::Transp mwo_rhs_trans, value_type beta=1.0)
 sym_lhs = alpha * op(mwo_rhs') * M * op(mwo_rhs) + beta * sym_lhs


Typedef Documentation

typedef DenseLinAlgPack::VectorTmpl<value_type> AbstractLinAlgPack::DVector

Definition at line 50 of file AbstractLinAlgPack_Types.hpp.

typedef DenseLinAlgPack::VectorSliceTmpl<value_type> AbstractLinAlgPack::DVectorSlice

Definition at line 52 of file AbstractLinAlgPack_Types.hpp.

typedef DenseLinAlgPack::DMatrix AbstractLinAlgPack::DMatrix

Definition at line 54 of file AbstractLinAlgPack_Types.hpp.

typedef DenseLinAlgPack::DMatrixSlice AbstractLinAlgPack::DMatrixSlice

Definition at line 56 of file AbstractLinAlgPack_Types.hpp.

typedef DenseLinAlgPack::DMatrixSliceTriEle AbstractLinAlgPack::DMatrixSliceTriEle

Definition at line 58 of file AbstractLinAlgPack_Types.hpp.

typedef DenseLinAlgPack::DMatrixSliceTri AbstractLinAlgPack::DMatrixSliceTri

Definition at line 60 of file AbstractLinAlgPack_Types.hpp.

typedef DenseLinAlgPack::DMatrixSliceSym AbstractLinAlgPack::DMatrixSliceSym

Definition at line 62 of file AbstractLinAlgPack_Types.hpp.

typedef RangePack::Range1D AbstractLinAlgPack::Range1D

Definition at line 64 of file AbstractLinAlgPack_Types.hpp.


Enumeration Type Documentation

enum AbstractLinAlgPack::EApplyBy

Enumerator:
APPLY_BY_ROW 
APPLY_BY_COL 

Definition at line 39 of file AbstractLinAlgPack_MultiVector.hpp.


Function Documentation

void AbstractLinAlgPack::apply_op_validate_input ( const char  func_name[],
const RTOpPack::RTOp &  op,
const size_t  num_vecs,
const Vector *  vecs[],
const size_t  num_targ_vecs,
VectorMutable *  targ_vecs[],
RTOpPack::ReductTarget reduct_obj,
const index_type  first_ele,
const index_type  sub_dim,
const index_type  global_offset 
)

Validate the inputs to apply_op().

Throws an exception if one of the preconditions is not met.

ToDo: Finish documentation.

Definition at line 12 of file AbstractLinAlgPack_apply_op_helper.cpp.

void AbstractLinAlgPack::apply_op_serial ( const RTOpPack::RTOp &  op,
const size_t  num_vecs,
const Vector *  vecs[],
const size_t  num_targ_vecs,
VectorMutable *  targ_vecs[],
RTOpPack::ReductTarget reduct_obj,
const index_type  first_ele,
const index_type  sub_dim,
const index_type  global_offset 
)

Implements reduction/transformation operators for any serial vectors using just the public vector interface.

Note that this function does not validate the input arguments so it is up to the client to do that (i.e. by calling apply_op_validate_input()).

ToDo: Finish documentation!

Definition at line 60 of file AbstractLinAlgPack_apply_op_helper.cpp.

std::ostream & AbstractLinAlgPack::operator<< ( std::ostream &  out,
const GenPermMatrixSlice &  P 
)

Print the contents of a GenPermMatrixSlice object in machine readable format.

The format is:

{varbatim} rows cols nz row_i(1):col_j(1) ... row_i(nz):col_j(nz) {verbatim}

Definition at line 34 of file AbstractLinAlgPack_GenPermMatrixSliceOut.cpp.

std::ostream& AbstractLinAlgPack::operator<< ( std::ostream &  o,
const MatrixOp &  M 
) [inline]

Output operator for MatrixOp} objects.

Definition at line 41 of file AbstractLinAlgPack_MatrixOpOut.hpp.

void AbstractLinAlgPack::apply_op ( EApplyBy  apply_by,
const RTOpPack::RTOp &  primary_op,
const size_t  num_multi_vecs,
const MultiVector *  multi_vecs[],
const size_t  num_targ_multi_vecs,
MultiVectorMutable *  targ_multi_vecs[],
RTOpPack::ReductTarget reduct_objs[] = NULL,
const index_type  primary_first_ele = 1,
const index_type  primary_sub_dim = 0,
const index_type  primary_global_offset = 0,
const index_type  secondary_first_ele = 1,
const index_type  secondary_sub_dim = 0 
)

Apply a reduction/transformation operator column by column and return an array of the reduction objects.

ToDo: Finish documentation!

Definition at line 287 of file AbstractLinAlgPack_MultiVector.cpp.

void AbstractLinAlgPack::apply_op ( EApplyBy  apply_by,
const RTOpPack::RTOp &  primary_op,
const RTOpPack::RTOp &  secondary_op,
const size_t  num_multi_vecs,
const MultiVector *  multi_vecs[],
const size_t  num_targ_multi_vecs,
MultiVectorMutable *  targ_multi_vecs[],
RTOpPack::ReductTarget reduct_obj,
const index_type  primary_first_ele = 1,
const index_type  primary_sub_dim = 0,
const index_type  primary_global_offset = 0,
const index_type  secondary_first_ele = 1,
const index_type  secondary_sub_dim = 0 
)

Apply a reduction/transformation operator column by column and reduce the intermediate reduction objects into one reduction object.

ToDo: Finish documentation!

Definition at line 318 of file AbstractLinAlgPack_MultiVector.cpp.

std::ostream& AbstractLinAlgPack::operator<< ( std::ostream &  o,
const Permutation &  P 
) [inline]

Output operator for Permutation objects.

Definition at line 41 of file AbstractLinAlgPack_PermutationOut.hpp.

template<class T_Element>
SparseVectorSlice< T_Element > AbstractLinAlgPack::create_slice ( const SparseVectorUtilityPack::SpVecIndexLookup< T_Element > &  index_lookup,
size_type  size,
Range1D  rng 
)

Return a sparse vector slice.

Preconditions:

Postconditions:

Definition at line 47 of file AbstractLinAlgPack_SparseVectorClassDef.hpp.

std::ostream & AbstractLinAlgPack::operator<< ( std::ostream &  os,
const SpVectorSlice &  svs 
)

SpVectorSlice output stream operator.

Definition at line 36 of file AbstractLinAlgPack_SpVectorOut.cpp.

RTOpPack::SparseSubVector AbstractLinAlgPack::sub_vec_view ( const SpVectorSlice &  sv_in,
const Range1D &  rng_in = Range1D() 
)

Create an RTOpPack::SparseSubVector view object from a SpVectorSlice object.

Definition at line 85 of file AbstractLinAlgPack_SpVectorView.cpp.

void AbstractLinAlgPack::apply_op ( const RTOpPack::RTOp &  op,
const size_t  num_vecs,
const Vector *  vecs[],
const size_t  num_targ_vecs,
VectorMutable *  targ_vecs[],
RTOpPack::ReductTarget reduct_obj,
const index_type  first_ele = 1,
const index_type  sub_dim = 0,
const index_type  global_offset = 0 
)

Apply a reduction/transformation,operation over a set of vectors: op(op(v[0]...v[nv-1],z[0]...z[nz-1]),(*reduct_obj)) -> z[0]...z[nz-1],(*reduct_obj).

The logical vector passed to the op.apply_op(...) method is:

 v(k + global_offset) = this->get_ele(first_ele + k - 1)
 , for k = 1 ... sub_dim
 

where v represents any one of the input or input/output vectors. The situation where first_ele == 1 and global_offset > 1 corresponds to the case where the vectors represent consitituent vectors in a larger aggregrate vector. The situation where first_ele > 1 and global_offset == 0 is for when a sub-view of the vectors are being treated as full vectors. Other combinations of these arguments are also possible.

Preconditions:

Parameters:
op [in] Reduction/transformation operator to apply over each sub-vector and assemble the intermediate targets into reduct_obj (if reduct_obj != NULL).
num_vecs [in] Number of nonmutable vectors in vecs[]. If vecs==NULL then this argument is ignored but should be set to zero.
vecs [in] Array (length num_vecs) of a set of pointers to nonmutable vectors to include in the operation. The order of these vectors is significant to op.
num_targ_vecs [in] Number of mutable vectors in targ_vecs[]. If targ_vecs==NULL then this argument is ignored but should be set to zero.
targ_vecs [in] Array (length num_targ_vecs) of a set of pointers to mutable vectors to include in the operation. The order of these vectors is significant to op. If targ_vecs==NULL then op is called with no mutable vectors.
reduct_obj [in/out] Target object of the reduction operation. This object must have been created by the op.reduct_obj_create_raw(&reduct_obj) function first. The reduction operation will be added to (*reduct_obj) if (*reduct_obj) has already been through a reduction. By allowing the info in (*reduct_obj) to be added to the reduction over all of these vectors, the reduction operation can be accumulated over a set of abstract vectors which can be useful for implementing composite vectors for instance. If op.get_reduct_type_num_entries(...) returns num_values == 0, num_indexes == 0 and num_chars == 0 then reduct_obj should be set to NULL and no reduction will be performed.
first_ele [in] (default = 1) The index of the first element in this to be included.
sub_dim [in] (default = 0) The number of elements in these vectors to include in the reduction/transformation operation. The value of sub_dim == 0 means to include all available elements.
global_offset [in] (default = 0) The offset applied to the included vector elements.

Definition at line 318 of file AbstractLinAlgPack_Vector.cpp.

void AbstractLinAlgPack::Vp_StMtV ( VectorMutable *  y,
value_type  alpha,
const GenPermMatrixSlice &  P,
BLAS_Cpp::Transp  P_trans,
const Vector &  x,
value_type  beta = 1.0 
) [inline]

y = alpha * op(P) * x + beta *y

Definition at line 277 of file AbstractLinAlgPack_VectorMutable.hpp.

std::ostream& AbstractLinAlgPack::operator<< ( std::ostream &  o,
const Vector &  v 
) [inline]

Output operator for Vector} objects.

Definition at line 41 of file AbstractLinAlgPack_VectorOut.hpp.

bool AbstractLinAlgPack::assert_print_nan_inf ( const value_type &  val,
char  name[],
bool  throw_excpt,
std::ostream *  out 
)

This function asserts if a value_type scalare is a NaN or Inf and optionally prints out these entires.

Parameters:
val [in] Value the check
name [in] Name of the scale variable for output purposes
throw_excpt [in] If true and is found to be a NaN or Inf then a NaNInfException excetion is thrown after any output.
out [in/out] If out==NULL then not output is produced. If out!=NULL and val is not NaN or Inf, then no output is produced. If out!=NULL and val is NaN or Inf then this will be printed before any execption is thrown.
Returns:
Returns true if val is not NaN or Inf. If val is NaN or Inf then false will be returned unless a excetion NaNInfException was thrown (throw_except==true).

Definition at line 57 of file AbstractLinAlgPack_assert_print_nan_inf.cpp.

bool AbstractLinAlgPack::assert_print_nan_inf ( const Vector &  v,
char  name[],
bool  throw_excpt,
std::ostream *  out 
)

This function asserts if a vector has any NaN or inf entries and optionally prints out these entires.

Parameters:
v [in] Vector slice to check
name [in] Name of the vector for output purposes
throw_excpt [in] If true and an entry is found to be a NaN or Inf then a NaNInfException excetion is thrown after any output.
out [in/out] If out==NULL then not output is produced. If out!=NULL and none of the entries is NaN or Inf, then no output is produced. If out!=NULL then any entries that are NaN or Inf will be printed before any execption is thrown.
Returns:
Returns true none of the entries are NaN or Inf. If one of the entries is NaN or Inf then false will be returned unless an excetion was thrown (throw_except==true).

Definition at line 75 of file AbstractLinAlgPack_assert_print_nan_inf.cpp.

bool AbstractLinAlgPack::TestMatrixSymSecant ( const MatrixOp &  B,
const Vector &  s,
const Vector &  y,
value_type  warning_tol,
value_type  error_tol,
bool  print_all_warnings,
std::ostream *  out,
bool  trase = true 
)

Checks the secant condition B*s = y.

Call this function after calling B.secant_update(s,y,...).

Returns true if the secant condition satsifies error_tol and false otherwise.

Parameters:
B [in] The matrix object we are testing.
s [in] First secant vector
y [in] Second secant vector
warning_tol [in] Any relative error above warning_tol will be noted and possibly printed.
error_tol [in] Any relative error above error_tol will cause the tests to stop and false to be returned.
print_all_warnings [in] If true then all relative errors greater than warning_tol will be printed.
out [in/out] Stream that output or error messages are sent to follow the tests.
trase [in] If trase==true then tests will be trased and if trase==false then only error messages will be output.

Definition at line 44 of file AbstractLinAlgPack_TestMatrixSymSecant.cpp.

bool AbstractLinAlgPack::BFGS_sTy_suff_p_d ( const Vector &  s,
const Vector &  y,
const value_type *  sTy = NULL,
std::ostream *  out = NULL,
const char  func_name[] = NULL 
)

Check that s'*y is sufficiently positive and print the result if it is not.

Parameters:
s [in] DVector (size n): Secant update vector B*s=y.
y [in] DVector (size n): Secant update vector for B*s=y.
sTy [in] If sTy != NULL then *sTy must contain the value computed from dot(s,y). If sTy == NULL, then this value will be computed internally. This argument is included so that the same computation does not have to be performed more than once by the client and this function.
out [in/out] If out==NULL then no output will be printed if the condition fails. If out!=NULL and the function returns false then a small amount of output will be sent to *out.
func_name [in] The name of the function this is being called from. If the condition is not met then this name in included in the printout to *out. If func_name == NULL then this string will obviously not be printed.
Returns:
If s'*y >= sqrt(mach_epsilon) * ||s||2 * ||y||2 then this function will return true. Otherwise it will return false.

Definition at line 37 of file AbstractLinAlgPack_BFGS_helpers.cpp.

std::istream & AbstractLinAlgPack::operator>> ( std::istream &  istrm,
COOMatrix &  coom 
) [inline]

Inputstream stream operator for COOMatrix.

The format for the imput is:

m n nz#\ a1:i1:j1 a2:i2:j2 .... anz:inz:jnz#\

In the above format, each non-zero element is given as a three item pair: value of the non-zero element, row indice (1-based) of the non-zero element, and the column indice (1-based) of the non-zero element. There must be no spaces between the numbers and the \':\' charachter and there must be at least one whitespace character between elements.

Definition at line 54 of file AbstractLinAlgPack_COOMatrixIn.hpp.

std::ostream & AbstractLinAlgPack::operator<< ( std::ostream &  o,
const COOMatrix &  coom 
) [inline]

Output stream operator for COOMatrix.

Calls the function:

std::ostream& output(std::ostream& o, const COOMatrix& coom)

Definition at line 47 of file AbstractLinAlgPack_COOMatrixOut.hpp.

std::ostream& AbstractLinAlgPack::output ( std::ostream &  o,
const COOMatrix &  coom 
)

Output stream function for COOMatrix.

The format for the output is:

m n nz#\ a1:i1:j1 a2:i2:j2 .... anz:inz:jnz#\

In the above format, each non-zero element is given as a three item pair: value of the non-zero element, row indice (1-based) of the non-zero element, and the column indice (1-based) of the non-zero element. There are no spaces between the numbers and the \':\' charachter and there is one whitespace character between elements. There is a new line character added after all of the elements have been output.

template<class T_Indice, class T_Value>
COOMatrixPartitionedViewUtilityPack::TransposedPartition<T_Indice,T_Value> AbstractLinAlgPack::trans ( COOMatrixPartitionedViewUtilityPack::Partition< T_Indice, T_Value > &  part  )  [inline]

Create a transposed view of a partition object.

Definition at line 882 of file AbstractLinAlgPack_COOMatrixPartitionedViewClassDecl.hpp.

template<class T_COOM>
size_type AbstractLinAlgPack::COOM_num_in_column ( const T_COOM &  m,
BLAS_Cpp::Transp  trans,
size_type  col_offset,
const IVector::value_type *  col_perm,
size_type num_in_col 
)

Definition at line 37 of file AbstractLinAlgPack_COOMatrixTmplConvertToSparseCompressedColumnDef.hpp.

template<class T_COOM>
void AbstractLinAlgPack::COOM_insert_nonzeros ( const T_COOM &  m,
BLAS_Cpp::Transp  trans,
value_type  alpha,
size_type  row_offset,
size_type  col_offset,
const IVector::value_type *  row_perm,
const IVector::value_type *  col_perm,
size_type next_nz_in_col,
FortranTypes::f_dbl_prec *  D_val,
FortranTypes::f_int *  D_row_i 
)

Definition at line 63 of file AbstractLinAlgPack_COOMatrixTmplConvertToSparseCompressedColumnDef.hpp.

template<class T_COOM>
value_type AbstractLinAlgPack::COOM_insert_scaled_nonzeros ( const T_COOM &  m,
BLAS_Cpp::Transp  trans,
value_type  scaled_max_ele,
size_type  row_offset,
size_type  col_offset,
const IVector::value_type *  row_perm,
const IVector::value_type *  col_perm,
size_type next_nz_in_col,
FortranTypes::f_dbl_prec *  D_val,
FortranTypes::f_int *  D_row_i 
)

Definition at line 108 of file AbstractLinAlgPack_COOMatrixTmplConvertToSparseCompressedColumnDef.hpp.

template<class T_Indice, class T_Value>
void AbstractLinAlgPack::Mp_StM ( DMatrixSlice *  gms_lhs,
value_type  alpha,
const COOMatrixPartitionedViewUtilityPack::Partition< T_Indice, T_Value > &  coom_rhs,
BLAS_Cpp::Transp  trans_rhs 
) [inline]

gms_lhs += alpha * op(coom_rhs) (time = O(coom_rhs.nz()), space = O(1)).

Definition at line 52 of file AbstractLinAlgPack_COOMPartitionOp.hpp.

template<class T_Indice, class T_Value>
void AbstractLinAlgPack::Vp_StMtV ( DVectorSlice *  vs_lhs,
value_type  alpha,
const COOMatrixPartitionedViewUtilityPack::Partition< T_Indice, T_Value > &  coom_rhs1,
BLAS_Cpp::Transp  trans_rhs1,
const DVectorSlice &  vs_rhs2 
) [inline]

vs_lhs += alpha * op(coom_rhs1) * vs_rhs2 (BLAS xGEMV) (time = O(coom_rhs.nz()), space = O(1)).

Definition at line 72 of file AbstractLinAlgPack_COOMPartitionOp.hpp.

template<class T_Indice, class T_Value>
void AbstractLinAlgPack::Vp_StMtV ( DVectorSlice *  vs_lhs,
value_type  alpha,
const COOMatrixPartitionedViewUtilityPack::Partition< T_Indice, T_Value > &  coom_rhs1,
BLAS_Cpp::Transp  trans_rhs1,
const DVectorSlice &  vs_rhs2,
value_type  beta 
) [inline]

vs_lhs += alpha * op(coom_rhs1) * vs_rhs2 (BLAS xGEMV) (time = O(coom_rhs.nz()), space = O(1)).

Definition at line 81 of file AbstractLinAlgPack_COOMPartitionOp.hpp.

template<class T_Indice, class T_Value>
void AbstractLinAlgPack::Mp_StMtM ( DMatrixSlice *  gms_lhs,
value_type  alpha,
const COOMatrixPartitionedViewUtilityPack::Partition< T_Indice, T_Value > &  coom_rhs1,
BLAS_Cpp::Transp  trans_rhs1,
const DMatrixSlice &  gms_rhs2,
BLAS_Cpp::Transp  trans_rhs2 
) [inline]

gms_lhs += alpha * op(coom_rhs1) * op(gms_rhs2) (right) (BLAS xGEMM).

Definition at line 104 of file AbstractLinAlgPack_COOMPartitionOp.hpp.

template<class T_Indice, class T_Value>
void AbstractLinAlgPack::Mp_StMtM ( DMatrixSlice *  gms_lhs,
value_type  alpha,
const DMatrixSlice &  gms_rhs1,
BLAS_Cpp::Transp  trans_rhs1,
const COOMatrixPartitionedViewUtilityPack::Partition< T_Indice, T_Value > &  coom_rhs2,
BLAS_Cpp::Transp  trans_rhs2 
) [inline]

gms_lhs += alpha * op(gms_rhs1) * op(coom_rhs2) (left) (BLAS xGEMM).

Definition at line 113 of file AbstractLinAlgPack_COOMPartitionOp.hpp.

template<class T_Indice, class T_Value, class M2>
void AbstractLinAlgPack::Mp_StMtM ( DMatrixSlice *  gms_lhs,
value_type  alpha,
const COOMatrixPartitionedViewUtilityPack::Partition< T_Indice, T_Value > &  coom_rhs1,
BLAS_Cpp::Transp  trans_rhs1,
const M2 &  M2_rhs2,
BLAS_Cpp::Transp  trans_rhs2,
value_type  beta 
) [inline]

gms_lhs = alpha * op(coom_rhs1) * op(M2_rhs2) + beta * gms_lhs (right).

Was part of LinAlgOpPack but had to be removed becasue of unexplained bug.

Definition at line 127 of file AbstractLinAlgPack_COOMPartitionOp.hpp.

template<class M1, class T_Indice, class T_Value>
void AbstractLinAlgPack::Mp_StMtM ( DMatrixSlice *  gms_lhs,
value_type  alpha,
const M1 &  M1_rhs1,
BLAS_Cpp::Transp  trans_rhs1,
const COOMatrixPartitionedViewUtilityPack::Partition< T_Indice, T_Value > &  coom_rhs2,
BLAS_Cpp::Transp  trans_rhs2,
value_type  beta 
) [inline]

gms_lhs = alpha * op(M1_rhs1) * op(coom_rhs2) + beta * gms_lhs (right).

Was part of LinAlgOpPack but had to be removed becasue of unexplained bug.

Definition at line 151 of file AbstractLinAlgPack_COOMPartitionOp.hpp.

template<class T_Indice, class T_Value>
void AbstractLinAlgPack::Mp_StM ( DMatrixSlice *  gms_lhs,
value_type  alpha,
const COOMatrixPartitionedViewUtilityPack::TransposedPartition< T_Indice, T_Value > &  coom_rhs,
BLAS_Cpp::Transp  trans_rhs 
) [inline]

gms_lhs += alpha * op(coom_rhs) (time = O(coom_rhs.nz()), space = O(1)).

Definition at line 189 of file AbstractLinAlgPack_COOMPartitionOp.hpp.

template<class T_Indice, class T_Value>
void AbstractLinAlgPack::Vp_StMtV ( DVectorSlice *  vs_lhs,
value_type  alpha,
const COOMatrixPartitionedViewUtilityPack::TransposedPartition< T_Indice, T_Value > &  coom_rhs1,
BLAS_Cpp::Transp  trans_rhs1,
const DVectorSlice &  vs_rhs2 
) [inline]

vs_lhs += alpha * op(coom_rhs1) * vs_rhs2 (BLAS xGEMV) (time = O(coom_rhs.nz()), space = O(1)).

Definition at line 209 of file AbstractLinAlgPack_COOMPartitionOp.hpp.

template<class T_Indice, class T_Value>
void AbstractLinAlgPack::Vp_StMtV ( DVectorSlice *  vs_lhs,
value_type  alpha,
const COOMatrixPartitionedViewUtilityPack::TransposedPartition< T_Indice, T_Value > &  coom_rhs1,
BLAS_Cpp::Transp  trans_rhs1,
const DVectorSlice &  vs_rhs2,
value_type  beta 
) [inline]

vs_lhs += alpha * op(coom_rhs1) * vs_rhs2 (BLAS xGEMV) (time = O(coom_rhs.nz()), space = O(1)).

Definition at line 218 of file AbstractLinAlgPack_COOMPartitionOp.hpp.

template<class T_Indice, class T_Value>
void AbstractLinAlgPack::Mp_StMtM ( DMatrixSlice *  gms_lhs,
value_type  alpha,
const COOMatrixPartitionedViewUtilityPack::TransposedPartition< T_Indice, T_Value > &  coom_rhs1,
BLAS_Cpp::Transp  trans_rhs1,
const DMatrixSlice &  gms_rhs2,
BLAS_Cpp::Transp  trans_rhs2 
) [inline]

gms_lhs += alpha * op(coom_rhs1) * op(gms_rhs2) (right) (BLAS xGEMM).

Definition at line 241 of file AbstractLinAlgPack_COOMPartitionOp.hpp.

template<class T_Indice, class T_Value>
void AbstractLinAlgPack::Mp_StMtM ( DMatrixSlice *  gms_lhs,
value_type  alpha,
const DMatrixSlice &  gms_rhs1,
BLAS_Cpp::Transp  trans_rhs1,
const COOMatrixPartitionedViewUtilityPack::TransposedPartition< T_Indice, T_Value > &  coom_rhs2,
BLAS_Cpp::Transp  trans_rhs2 
) [inline]

gms_lhs += alpha * op(gms_rhs1) * op(coom_rhs2) (left) (BLAS xGEMM).

Definition at line 250 of file AbstractLinAlgPack_COOMPartitionOp.hpp.

template<class T_Indice, class T_Value, class M2>
void AbstractLinAlgPack::Mp_StMtM ( DMatrixSlice *  gms_lhs,
value_type  alpha,
const COOMatrixPartitionedViewUtilityPack::TransposedPartition< T_Indice, T_Value > &  coom_rhs1,
BLAS_Cpp::Transp  trans_rhs1,
const M2 &  M2_rhs2,
BLAS_Cpp::Transp  trans_rhs2,
value_type  beta 
) [inline]

gms_lhs = alpha * op(coom_rhs1) * op(M2_rhs2) + beta * gms_lhs (right).

Was part of LinAlgOpPack but had to be removed becasue of unexplained bug.

Definition at line 264 of file AbstractLinAlgPack_COOMPartitionOp.hpp.

template<class M1, class T_Indice, class T_Value>
void AbstractLinAlgPack::Mp_StMtM ( DMatrixSlice *  gms_lhs,
value_type  alpha,
const M1 &  M1_rhs1,
BLAS_Cpp::Transp  trans_rhs1,
const COOMatrixPartitionedViewUtilityPack::TransposedPartition< T_Indice, T_Value > &  coom_rhs2,
BLAS_Cpp::Transp  trans_rhs2,
value_type  beta 
) [inline]

gms_lhs = alpha * op(M1_rhs1) * op(coom_rhs2) + beta * gms_lhs (right).

Was part of LinAlgOpPack but had to be removed becasue of unexplained bug.

Definition at line 288 of file AbstractLinAlgPack_COOMPartitionOp.hpp.

template<class T_Indice, class T_Value>
std::ostream& AbstractLinAlgPack::operator<< ( std::ostream &  os,
const COOMatrixPartitionedViewUtilityPack::Partition< T_Indice, T_Value > &  part 
) [inline]

Partition<> output stream operator.

This operator function calls the function output_COOM(os,part,0).

Definition at line 43 of file AbstractLinAlgPack_COOMPartitionOut.hpp.

template<class T_Indice, class T_Value>
std::ostream& AbstractLinAlgPack::operator<< ( std::ostream &  os,
const COOMatrixPartitionedViewUtilityPack::TransposedPartition< T_Indice, T_Value > &  trans_part 
) [inline]

TransposedPartition<> output stream operator.

This operator function calls the function output_COOM(os,trans_part,0).

Definition at line 53 of file AbstractLinAlgPack_COOMPartitionOut.hpp.

template<class M_t, class V_t>
void AbstractLinAlgPack::dense_Vp_StPtMtV ( DVectorSlice *  y,
value_type  a,
const GenPermMatrixSlice &  P,
BLAS_Cpp::Transp  P_trans,
const M_t &  M,
BLAS_Cpp::Transp  M_trans,
const V_t &  x,
value_type  b 
)

Implements y = b*y + a*op(P)*op(M)*x where it is assumed that generating rows of op(M) is cheap compared to computing op(M)*x.

This function is not ment to be used by clients directly but instead by MatrixOp# subclasses that want to use it.

Definition at line 52 of file AbstractLinAlgPack_dense_Vp_StPtMtV.hpp.

template<class T_Matrix>
void AbstractLinAlgPack::assign ( DMatrix &  gm_lhs,
const T_Matrix &  gm_rhs,
BLAS_Cpp::Transp  trans_rhs 
)

gm_lhs = T_M (templated matrix type T_M)

Definition at line 62 of file AbstractLinAlgPack_MatrixVectorTemplateOpDef.hpp.

template<class T_Matrix>
void AbstractLinAlgPack::assign ( DMatrixSlice &  gms_lhs,
const T_Matrix &  gm_rhs,
BLAS_Cpp::Transp  trans_rhs 
)

gms_lhs = T_M (templated matrix type T_M)

Definition at line 72 of file AbstractLinAlgPack_MatrixVectorTemplateOpDef.hpp.

template<class T_Matrix>
void AbstractLinAlgPack::V_MtV ( DVector &  v_lhs,
const T_Matrix &  gm_rhs1,
BLAS_Cpp::Transp  trans_rhs1,
const DVectorSlice &  vs_rhs2 
)

v_lhs = T_M * vs_lhs (templated matrix type T_M)

Definition at line 123 of file AbstractLinAlgPack_MatrixVectorTemplateOpDef.hpp.

template<class T_Matrix>
void AbstractLinAlgPack::V_MtV ( DVectorSlice &  v_lhs,
const T_Matrix &  gm_rhs1,
BLAS_Cpp::Transp  trans_rhs1,
const DVectorSlice &  vs_rhs2 
)

vs_lhs = T_M * vs_lhs (templated matrix type T_M)

Definition at line 136 of file AbstractLinAlgPack_MatrixVectorTemplateOpDef.hpp.

template<class T_Matrix>
void AbstractLinAlgPack::assign ( DMatrix &  gm_lhs,
const T_Matrix &  gm_rhs,
BLAS_Cpp::Transp  trans_rhs 
)

gm_lhs = T_M (templated matrix type T_M)

Definition at line 62 of file AbstractLinAlgPack_MatrixVectorTemplateOpDef.hpp.

template<class T_Matrix>
void AbstractLinAlgPack::assign ( DMatrixSlice &  gms_lhs,
const T_Matrix &  gm_rhs,
BLAS_Cpp::Transp  trans_rhs 
)

gms_lhs = T_M (templated matrix type T_M)

Definition at line 72 of file AbstractLinAlgPack_MatrixVectorTemplateOpDef.hpp.

template<class T_Matrix>
void AbstractLinAlgPack::V_MtV ( DVector &  v_lhs,
const T_Matrix &  gm_rhs1,
BLAS_Cpp::Transp  trans_rhs1,
const DVectorSlice &  vs_rhs2 
)

v_lhs = T_M * vs_lhs (templated matrix type T_M)

Definition at line 123 of file AbstractLinAlgPack_MatrixVectorTemplateOpDef.hpp.

template<class T_Matrix>
void AbstractLinAlgPack::V_MtV ( DVectorSlice &  v_lhs,
const T_Matrix &  gm_rhs1,
BLAS_Cpp::Transp  trans_rhs1,
const DVectorSlice &  vs_rhs2 
)

vs_lhs = T_M * vs_lhs (templated matrix type T_M)

Definition at line 136 of file AbstractLinAlgPack_MatrixVectorTemplateOpDef.hpp.

void AbstractLinAlgPack::rank_2_chol_update ( const value_type  a,
DVectorSlice *  u,
const DVectorSlice &  v,
DVectorSlice *  w,
DMatrixSliceTriEle *  R,
BLAS_Cpp::Transp  R_trans 
)

Update the cholesky factor of symmetric positive definite matrix for a rank-2 update.

This function updates and an upper or lower triangular cholesky factor in O(n^2) flops. The basic idea is that the original symmetric positive definite matrix

       B = op(R')*op(R)
 
is subjected to a rank-2 update. This rank-2 update to B must be expressed in the form
       B_new = J'*J

   where:
       J = (op(R) + a*u*v')
 
The basic approach is to introduce an othogonal matrix Q such that
       Q*(op(R) + a*u*v') -> op(R_new)
 
is triangular. In other words (with I = Q'*Q)
       B_new = (op(R') + a*v*u')*Q'*Q*(op(R) + a*u*v') = op(R_new')*op(R_new)
 
This algorithm is based on Algorithm A3.4.1a in Dennis and Schnabel. However, it has been extended in the sense that it handles upper and lower along with transposed and nontransposed factors. It does not touch any of the elements of R outside of the designated triangular region and returns the rotations used with no extra storage space needed. This is a much nicer function than any other one that I have seen in the public domain.

It is guarrenteed that after this function finishes that the diagonal of R_new will be positive.

Parameters:
a [in] Scalar for update (see above).
u [in/out] (size n ) On input, contaitns the update vector u (see above). On output, contains the rotations needed for the transformation Q1*u -> ||u||2 * e(last_i). (ToDo: Document this!).
v [in] (size n )Update vector (see above).
w [out] (size n-1) On output, contains stored rotations from BLAS_Cpp::rotg(...) used to transform the upper or lower Hessenberg itermediate factor R2 back to upper or lower triangular form. (ToDo: Document this!). If n == 1 then w can be NULL.
R [in/out] (size n x n) Upper or lower triangular factor. On input the diagonal must contain all positive elements on the diagonal. On output contains the updated factor with all positive diagonal elements.
R_trans [in] Determines if op(R) = R (no_trans) or op(R) = R' (trans)

Definition at line 36 of file AbstractLinAlgPack_rank_2_chol_update.cpp.

void AbstractLinAlgPack::imp_sparse_bnd_diff ( int  sign,
const SpVectorSlice &  sv,
BLAS_Cpp::Uplo  uplo,
const DVectorSlice &  v,
DVectorSlice *  r 
)

Take the difference between a spare lower bound vector and a dense vector.

r = alpha * ( sv - v )

If sign > 0 then alpha = 1.0. If sign < 0 then alpha = -1.0.

If uplo == upper, then the nonstored elements in sv are +inf, and if uplo == lower then the nonstored elements are lower.

void AbstractLinAlgPack::read_coo_into_valarrays ( std::istream &  istrm,
size_type m,
size_type n,
size_type nz,
std::valarray< value_type > &  a,
std::valarray< indice_type > &  ivect,
std::valarray< indice_type > &  jvect 
)

Read in a Coordinate Matrix from a C++ input stream and store it in valarrays.

The format for the imput is:

m n nz#\ a1:i1:j1 a2:i2:j2 .... anz:inz:jnz#\

In the above format, each non-zero element is given as a three item pair: value of the non-zero element, row indice (1-based) of the non-zero element, and the column indice (1-based) of the non-zero element. There must be no spaces between the numbers and the \':\' charachter and there must be at least one whitespace character between elements.

The vectors a#, ivect#, and jvect# are resized to nz#. If any problem is found in the input an InputException will be throw that will include a descriptive message about the error.

Parameters:
m number of rows of the sparse matrix
n number of columns of sparse matrix
nz number of non-zero elements of the sparse matrix
a vector holding the non-zero elements
ivect vector holding the row indices (1-based)
jvect vector holding the column indices (1-based)

template<class T_Indice, class T_Value>
std::ostream & AbstractLinAlgPack::operator<< ( std::ostream &  o,
const SparseElement< T_Indice, T_Value > &  ele 
) [inline]

Outputs a SparseElement<> object.

Output format is:

ele.value():ele.indice()#\

Definition at line 52 of file AbstractLinAlgPack_SparseElementOut.hpp.

template<class T_SpVec>
value_type AbstractLinAlgPack::dot_V_SV ( const DVectorSlice &  vs_rhs1,
const T_SpVec &  sv_rhs2 
)

result = dot(vs_rhs1,sv_rhs2) (BLAS xDOT)

Definition at line 78 of file AbstractLinAlgPack_SparseVectorOpDef.hpp.

template<class T_SpVec>
value_type AbstractLinAlgPack::dot_SV_V ( const T_SpVec &  sv_rhs1,
const DVectorSlice &  vs_rhs2 
)

result = dot(sv_rhs1,vs_rhs2) (BLAS xDOT)

Definition at line 89 of file AbstractLinAlgPack_SparseVectorOpDef.hpp.

template<class T_SpVec>
value_type AbstractLinAlgPack::norm_1_SV ( const T_SpVec &  sv_rhs  ) 

result = ||sv_rhs||1 (BLAS xASUM)

Definition at line 95 of file AbstractLinAlgPack_SparseVectorOpDef.hpp.

template<class T_SpVec>
value_type AbstractLinAlgPack::norm_2_SV ( const T_SpVec &  sv_rhs  ) 

result = ||sv_rhs||2 (BLAS xNRM2)

Definition at line 104 of file AbstractLinAlgPack_SparseVectorOpDef.hpp.

template<class T_SpVec>
value_type AbstractLinAlgPack::norm_inf_SV ( const T_SpVec &  sv_rhs  ) 

result = ||sv_rhs||inf (BLAS IxAMAX)

Definition at line 113 of file AbstractLinAlgPack_SparseVectorOpDef.hpp.

template<class T_SpVec>
value_type AbstractLinAlgPack::max_SV ( const T_SpVec &  sv_rhs  ) 

result = max(sv_rhs)

Definition at line 122 of file AbstractLinAlgPack_SparseVectorOpDef.hpp.

template<class T_SpVec>
value_type AbstractLinAlgPack::min_SV ( const T_SpVec &  sv_rhs  ) 

result = min(sv_rhs)

Definition at line 131 of file AbstractLinAlgPack_SparseVectorOpDef.hpp.

template<class T_SpVec>
void AbstractLinAlgPack::Vt_S ( T_SpVec *  sv_lhs,
value_type  alpha 
)

sv_lhs *= alpha (BLAS xSCAL)

Definition at line 140 of file AbstractLinAlgPack_SparseVectorOpDef.hpp.

template<class T_SpVec>
void AbstractLinAlgPack::Vp_StSV ( DVectorSlice *  vs_lhs,
value_type  alpha,
const T_SpVec &  sv_rhs 
)

vs_lhs += alpha * sv_rhs (BLAS xAXPY)

Definition at line 149 of file AbstractLinAlgPack_SparseVectorOpDef.hpp.

template<class T_SpVec>
void AbstractLinAlgPack::Vp_StMtSV ( DVectorSlice *  vs_lhs,
value_type  alpha,
const DMatrixSlice &  gms_rhs1,
BLAS_Cpp::Transp  trans_rhs1,
const T_SpVec &  sv_rhs2 
)

vs_lhs += alpha * op(gms_rhs1) * sv_rhs2 (BLAS xGEMV)

Definition at line 159 of file AbstractLinAlgPack_SparseVectorOpDef.hpp.

template<class T_SpVec>
void AbstractLinAlgPack::Vp_StMtSV ( DVectorSlice *  vs_lhs,
value_type  alpha,
const DMatrixSliceTri &  tri_rhs1,
BLAS_Cpp::Transp  trans_rhs1,
const T_SpVec &  sv_rhs2 
)

vs_lhs += alpha * op(tri_gms_rhs1) * sv_rhs2 (BLAS xTRMV)

Definition at line 186 of file AbstractLinAlgPack_SparseVectorOpDef.hpp.

template<class T_SpVec>
void AbstractLinAlgPack::Vp_StMtSV ( DVectorSlice *  vs_lhs,
value_type  alpha,
const DMatrixSliceSym &  sym_rhs1,
BLAS_Cpp::Transp  trans_rhs1,
const T_SpVec &  sv_rhs2 
)

vs_lhs += alpha * op(sym_gms_rhs1) * sv_rhs2 (BLAS xSYMV)

Definition at line 275 of file AbstractLinAlgPack_SparseVectorOpDef.hpp.

template<class T_Ele>
value_type AbstractLinAlgPack::dot ( const DVectorSlice &  vs_rhs1,
const SparseVectorSlice< T_Ele > &  sv_rhs2 
) [inline]

result = dot(vs_rhs1,sv_rhs2) (BLAS xDOT)

Definition at line 67 of file AbstractLinAlgPack_SparseVectorSliceOp.hpp.

template<class T_Ele>
value_type AbstractLinAlgPack::dot ( const SparseVectorSlice< T_Ele > &  sv_rhs1,
const DVectorSlice &  vs_rhs2 
) [inline]

result = dot(sv_rhs1,vs_rhs2) (BLAS xDOT)

Definition at line 75 of file AbstractLinAlgPack_SparseVectorSliceOp.hpp.

template<class T_Ele>
value_type AbstractLinAlgPack::norm_1 ( const SparseVectorSlice< T_Ele > &  sv_rhs  )  [inline]

result = ||sv_rhs||1 (BLAS xASUM)

Definition at line 83 of file AbstractLinAlgPack_SparseVectorSliceOp.hpp.

template<class T_Ele>
value_type AbstractLinAlgPack::norm_2 ( const SparseVectorSlice< T_Ele > &  sv_rhs  )  [inline]

result = ||sv_rhs||2 (BLAS xNRM2)

Definition at line 91 of file AbstractLinAlgPack_SparseVectorSliceOp.hpp.

template<class T_Ele>
value_type AbstractLinAlgPack::norm_inf ( const SparseVectorSlice< T_Ele > &  sv_rhs  )  [inline]

result = ||sv_rhs||inf (BLAS IxAMAX)

Definition at line 99 of file AbstractLinAlgPack_SparseVectorSliceOp.hpp.

template<class T_Ele>
value_type AbstractLinAlgPack::max ( const SparseVectorSlice< T_Ele > &  sv_rhs  )  [inline]

result = max(sv_rhs)

Definition at line 107 of file AbstractLinAlgPack_SparseVectorSliceOp.hpp.

template<class T_Ele>
value_type AbstractLinAlgPack::min ( const SparseVectorSlice< T_Ele > &  sv_rhs  )  [inline]

result = min(sv_rhs)

Definition at line 115 of file AbstractLinAlgPack_SparseVectorSliceOp.hpp.

template<class T_Ele>
void AbstractLinAlgPack::Vp_StV ( DVectorSlice *  vs_lhs,
value_type  alpha,
const SparseVectorSlice< T_Ele > &  sv_rhs 
) [inline]

vs_lhs += alpha * sv_rhs (BLAS xAXPY)

Definition at line 123 of file AbstractLinAlgPack_SparseVectorSliceOp.hpp.

template<class T_Ele>
void AbstractLinAlgPack::Vp_StMtV ( DVectorSlice *  vs_lhs,
value_type  alpha,
const DMatrixSlice &  gms_rhs1,
BLAS_Cpp::Transp  trans_rhs1,
const SparseVectorSlice< T_Ele > &  sv_rhs2 
) [inline]

vs_lhs += alpha * op(gms_rhs1) * sv_rhs2 (BLAS xGEMV)

Definition at line 131 of file AbstractLinAlgPack_SparseVectorSliceOp.hpp.

template<class T_Ele>
void AbstractLinAlgPack::Vp_StMtV ( DVectorSlice *  vs_lhs,
value_type  alpha,
const DMatrixSliceTri &  tri_gms_rhs1,
BLAS_Cpp::Transp  trans_rhs1,
const SparseVectorSlice< T_Ele > &  sv_rhs2 
) [inline]

vs_lhs += alpha * op(tri_gms_rhs1) * sv_rhs2 (BLAS xTRMV)

Definition at line 140 of file AbstractLinAlgPack_SparseVectorSliceOp.hpp.

template<class T_Ele>
void AbstractLinAlgPack::Vp_StMtV ( DVectorSlice *  vs_lhs,
value_type  alpha,
const DMatrixSliceSym &  sym_gms_rhs1,
BLAS_Cpp::Transp  trans_rhs1,
const SparseVectorSlice< T_Ele > &  sv_rhs2 
) [inline]

vs_lhs += alpha * op(sym_gms_rhs1) * sv_rhs2 (BLAS xSYMV)

Definition at line 149 of file AbstractLinAlgPack_SparseVectorSliceOp.hpp.

template<class M, class T_Ele>
void AbstractLinAlgPack::Vp_StMtSVS ( DVectorSlice *  vs_lhs,
value_type  alpha,
const M &  M_rhs1,
BLAS_Cpp::Transp  trans_rhs1,
const SparseVectorSlice< T_Ele > &  sv_rhs2,
value_type  beta 
) [inline]

vs_lhs = alpha * op(M_rhs1) * sv_rhs2 + beta * vs_lhs

Calls: Vp_StMtSV(vs_lhs,alpha,M_rhs1,trans_rhs1,V_rhs2);#

Needed for LinAlgOpPack template functions and provides implementations for gms, tri, and sym matrices.

The name Vp_StMtV could not be used because of a conflict with another functions.

Definition at line 167 of file AbstractLinAlgPack_SparseVectorSliceOp.hpp.

template<class T_Ele>
void AbstractLinAlgPack::Vp_StMtV ( DVectorSlice *  vs_lhs,
value_type  alpha,
const DMatrixSlice &  gms_rhs1,
BLAS_Cpp::Transp  trans_rhs1,
const SparseVectorSlice< T_Ele > &  sv_rhs2,
value_type  beta 
) [inline]

vs_lhs = alpha * op(gms_rhs1) * sv_rhs2 + beta * vs_lhs

Definition at line 184 of file AbstractLinAlgPack_SparseVectorSliceOp.hpp.

template<class T_Ele>
void AbstractLinAlgPack::Vp_StMtV ( DVectorSlice *  vs_lhs,
value_type  alpha,
const DMatrixSliceTri &  tri_gms_rhs1,
BLAS_Cpp::Transp  trans_rhs1,
const SparseVectorSlice< T_Ele > &  sv_rhs2,
value_type  beta 
) [inline]

vs_lhs = alpha * op(tri_gms_rhs1) * sv_rhs2 + beta * vs_lhs

Definition at line 192 of file AbstractLinAlgPack_SparseVectorSliceOp.hpp.

template<class T_Ele>
void AbstractLinAlgPack::Vp_StMtV ( DVectorSlice *  vs_lhs,
value_type  alpha,
const DMatrixSliceSym &  sym_gms_rhs1,
BLAS_Cpp::Transp  trans_rhs1,
const SparseVectorSlice< T_Ele > &  sv_rhs2,
value_type  beta 
) [inline]

vs_lhs = alpha * op(sym_gms_rhs1) * sv_rhs2 + beta * vs_lhs

Definition at line 200 of file AbstractLinAlgPack_SparseVectorSliceOp.hpp.

void AbstractLinAlgPack::add_elements ( SpVector *  sv_lhs,
value_type  alpha,
const DVectorSlice &  vs_rhs,
size_type  offset = 0,
bool  add_zeros = true 
)

Add elements from a dense vector to a sparse vector.

Here sv_lhs is not resized and only elements are added. The purpose of this function is to add elements from a dense vector to a sparse vector.

Postconditions:{itemize} sv_lhs->nz() == vs_rhs->size() + sv_lhs_before->size() [sv_lhs_before->is_sorted() || sv_lhs_before->nz() == 0] sv_lhs->is_sorted() == true {itemize}

Definition at line 71 of file AbstractLinAlgPack_SpVectorOp.cpp.

void AbstractLinAlgPack::add_elements ( SpVector *  sv_lhs,
value_type  alpha,
const SpVectorSlice &  sv_rhs,
size_type  offset = 0,
bool  add_zeros = true 
)

Add elements from a sparse vector to another sparse vector.

Here sv_lhs is not resized and only elements are added. The purpose of this function is to add elements from a sparse vector to a sparse vector.

Postconditions:{itemize} sv_lhs->nz() == sv_rhs->nz() + sv_lhs_before->size() [(sv_lhs_before->is_sorted() || sv_lhs_before->nz() == 0) && (sv_rhs.is_sorted() || sv_rhs.nz() == 0)] sv_lhs->is_sorted() == true {itemize}

Definition at line 90 of file AbstractLinAlgPack_SpVectorOp.cpp.

DVectorSlice AbstractLinAlgPack::dense_view ( SpVectorSlice &  sv_rhs  )  [inline]

Create a dense representation of a sparse vector.

The primary use if the function is to create a DVectorSlice object that only represents the nonzero values of the sparse vector. This could have several different uses but one of the most significant examples is when you want to discard the indices when sv_rhs->size() == sv_rhs->nz() and sv_rhs->is_sorted() == true.

Definition at line 89 of file AbstractLinAlgPack_SpVectorOp.hpp.

const DVectorSlice AbstractLinAlgPack::dense_view ( const SpVectorSlice &  sv_rhs  )  [inline]

Definition at line 98 of file AbstractLinAlgPack_SpVectorOp.hpp.

DenseLinAlgPack::DVectorSlice AbstractLinAlgPack::dense_view ( SpVectorSlice &  sv_rhs  )  [inline]

Create a dense representation of a sparse vector.

The primary use if the function is to create a DVectorSlice object that only represents the nonzero values of the sparse vector. This could have several different uses but one of the most significant examples is when you want to discard the indices when sv_rhs->size() == sv_rhs->nz() and sv_rhs->is_sorted() == true.

Definition at line 89 of file AbstractLinAlgPack_SpVectorOp.hpp.

const DenseLinAlgPack::DVectorSlice AbstractLinAlgPack::dense_view ( const SpVectorSlice &  sv_rhs  )  [inline]

Definition at line 98 of file AbstractLinAlgPack_SpVectorOp.hpp.

void AbstractLinAlgPack::V_StMtV ( SpVector *  sv_lhs,
value_type  alpha,
const GenPermMatrixSlice &  P_rhs1,
BLAS_Cpp::Transp  P_rhs1_trans,
const DVectorSlice &  vs_rhs2 
)

sv_lhs = alpha * op(P_rhs1) * vs_rhs2.

This function will resize the sparse vector lhs and only the resultant nonzero elements will be added.

If op(P_rhs1) is sorted by row (i.e. op(P_rhs1) = P_rhs1 sorted by row or op(P_rhs1) = P_rhs1' sorted by column) then sv_lhs->assume_sorted(true) is called and sv_lhs->is_sorted()==true on output.

This function will execute in O(P_rhs1.nz()) time.

Definition at line 38 of file AbstractLinAlgPack_GenPermMatrixSliceOp.cpp.

void AbstractLinAlgPack::V_StMtV ( SpVector *  sv_lhs,
value_type  alpha,
const GenPermMatrixSlice &  P_rhs1,
BLAS_Cpp::Transp  P_rhs1_trans,
const SpVectorSlice &  sv_rhs2 
)

sv_lhs = alpha * op(P_rhs1) * sv_rhs2.

This function will resize the sparse vector lhs and add only the nonzero elements in the rhs.

If op(P_rhs1) is sorted by row (i.e. op(P_rhs1) = P_rhs1 sorted by row or op(P_rhs1) = P_rhs1' sorted by column) then sv_lhs->assume_sorted(true) is called.

Let's assume that op(P_rhs1) is not sorted by column and sv_rhs2 is sorted. In this case a linear search will have to be performed to match up elements. P_rhs1 will be iterated through sequentially and the corresponding nonzero element in sv_rhs2 searched for (binary search). Therefore, the runtime in this case will be:

    O( P_rhs1.nz() * log(sv_rhs2.nz()) )
 
If P_rhs1 and sv_rhs2 are unsorted, then the runtime will be:
    O( P_rhs1.nz() * sv_rhs2.nz() )
 
If op(P_rhs1) is sorted by column and sv_rhs2 is also sorted then the runtime will be:
    O( max( P_rhs1.nz(), sv_rhs2.nz() ) )
 
Of course if op(P_rhs1) is not sorted by row then the output vector will not be assumed sorted.

Definition at line 88 of file AbstractLinAlgPack_GenPermMatrixSliceOp.cpp.

void AbstractLinAlgPack::Vp_StMtV ( SpVector *  sv_lhs,
value_type  alpha,
const GenPermMatrixSlice &  P_rhs1,
BLAS_Cpp::Transp  P_rhs1_trans,
const DVectorSlice &  vs_rhs2 
)

sv_lhs += alpha * op(P_rhs1) * vs_rhs2.

This function will not resize the sparse vector lhs and will add new elements for the nonzero elements in the rhs. Therefore it is up to the client to ensure that there is sufficient storage for these elements. This function will not check to see if elements with duplicate indexes are added. It is up to the client to determine that. If sv_lhs is sorted on input and op(P_rhs1) is sorted by row, then sv_lhs->is_sorted() == true on output.

This function will execute in O(P_rhs1.nz()) time.

Definition at line 138 of file AbstractLinAlgPack_GenPermMatrixSliceOp.cpp.

void AbstractLinAlgPack::Vp_StMtV ( DVectorSlice *  y,
value_type  a,
const GenPermMatrixSlice &  P,
BLAS_Cpp::Transp  P_trans,
const DVectorSlice &  x,
value_type  b = 1.0 
)

vs_lhs = alpha * op(P_rhs1) * vs_rhs2 + beta * vs_lhs

Definition at line 189 of file AbstractLinAlgPack_GenPermMatrixSliceOp.cpp.

void AbstractLinAlgPack::Vp_StMtV ( DVectorSlice *  y,
value_type  a,
const GenPermMatrixSlice &  P,
BLAS_Cpp::Transp  P_trans,
const SpVectorSlice &  x,
value_type  b = 1.0 
)

vs_lhs = alpha * op(P_rhs1) * sv_rhs2 + beta * vs_lhs

Definition at line 227 of file AbstractLinAlgPack_GenPermMatrixSliceOp.cpp.

void AbstractLinAlgPack::intersection ( const GenPermMatrixSlice &  P1,
BLAS_Cpp::Transp  P1_trans,
const GenPermMatrixSlice &  P2,
BLAS_Cpp::Transp  P2_trans,
size_type Q_nz,
const size_type  Q_max_nz = 0,
size_type  Q_row_i[] = NULL,
size_type  Q_col_j[] = NULL,
GenPermMatrixSlice *  Q = NULL 
)

Find the intersection between two GenPermMatrixSlice objects.

This subroutine has two modes. In the first mode (Q_max_nz == 0) it just computes the number of nonzero entries in the matrix:

Q = op(P1)*op(P1)

In the second mode (Q_max_nz > 0 && Q_row_i != NULL && Q_col_j != NULL) it also computes the row and column arrays for the resultant matrix Q. In addition if Q != NULL then a GenPermMatrixSlice object will be setup with as:

Q->initialize( op(P1).rows(), op(P2).cols(), Q_nz, 0, 0, Q_ordered_by, Q_row_i, Q_col_j, false )

Above Q_ordered_by will be determined of the fly.

This operation might require O(min(op(P1).cols(),op(P2).rows()) temporary storage but will always be executed in:

O(P1.nz()) + O(P2.nz()) + O(min(op(P1).cols(),op(P2).rows())

Parameters:
P1 [in] Right hand side permutation matrix.
P1_trans [in] If no_trans then op(P1) = P1 otherwise op(P1) = P1'.
P1 [in] Left hand side permutation matrix.
P1_trans [in] If no_trans then op(P2) = P2 otherwise op(P2) = P2'.
Q_nz [out] On return will contain the number of nonzeros in the resultant matrix Q
Q_max_nz [in] If Q_max_nz > 0 then the resultant row Q_row_i and column Q_col_j indices will be set. If it turns out that Q_nz will be larger than Q_max_nz then the exception std::length_error will be thrown and Q_row_i and Q_col_j may be left in an inconsistent state. If Q_max_nz == 0 then the rest of the return arguments are ignored and the resultant matrix will not be returned.
Q_row_i [out] Array (length Q_max_nz): If Q_max_nz > 0 then out return Q_row_i[k], k=0,,,Q_nz-1 will contain the row indices for the resultant matrix Q. If Q_max_nz == 0 then Q_row_i can be NULL.
Q_row_i [out] Array (length Q_max_nz): If Q_max_nz > 0 then out return Q_col_j[k], k=0,,,Q_nz-1 will contain the column indices for the resultant matrix Q. If Q_max_nz == 0 then Qd_col_j can be NULL.
Q [out] If Q_max_nz > 0 && Q != NULL then Q will be initialized as described above. It is allowed for Q == NULL.

Definition at line 327 of file AbstractLinAlgPack_GenPermMatrixSliceOp.cpp.

void AbstractLinAlgPack::V_MtV ( SpVector *  sv_lhs,
const GenPermMatrixSlice &  P_rhs1,
BLAS_Cpp::Transp  P_rhs1_trans,
const DVectorSlice &  vs_rhs2 
) [inline]

sv_lhs = op(P_rhs1) * vs_rhs2

Definition at line 61 of file AbstractLinAlgPack_GenPermMatrixSliceOp.hpp.

void AbstractLinAlgPack::V_MtV ( SpVector *  sv_lhs,
const GenPermMatrixSlice &  P_rhs1,
BLAS_Cpp::Transp  P_rhs1_trans,
const SpVectorSlice &  sv_rhs2 
) [inline]

sv_lhs = op(P_rhs1) * sv_rhs2

Definition at line 108 of file AbstractLinAlgPack_GenPermMatrixSliceOp.hpp.

void AbstractLinAlgPack::Vp_MtV ( SpVector *  sv_lhs,
const GenPermMatrixSlice &  P_rhs1,
BLAS_Cpp::Transp  P_rhs1_trans,
const DVectorSlice &  vs_rhs2 
) [inline]

sv_lhs += op(P_rhs1) * vs_rhs2.

Definition at line 137 of file AbstractLinAlgPack_GenPermMatrixSliceOp.hpp.


Generated on Wed May 12 21:31:42 2010 for AbstractLinAlgPack: C++ Interfaces For Vectors, Matrices And Related Linear Algebra Objects by  doxygen 1.4.7