Linear algebra operations for coordinate matrices.

Functions
template<class T_COOM >
void	AbstractLinAlgPack::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)) More...
template<class T_COOM >
void	AbstractLinAlgPack::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)) More...
template<class T_COOM >
void	AbstractLinAlgPack::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) More...
template<class T_COOM >
void	AbstractLinAlgPack::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) More...

Detailed Description

This is a basic set of BLAS like linear algebra operations with sparse coordinate (COO) matrices accesses through a template interface called COOMatrixTemplateInterface. Through this template interface the client can inquire as to the dimensions of the matrix (rows()#, cols()#) and how many nonzero elements it has (#nz()#). The nonzero elements are accessed using forward iterators returned from #begin()# and #end()#. The iterator must return a type with an interface compatable with the SparseCOOElementTemplateInterface specification.

The specifications for these template interfaces are given below:\

{verbatim} class SparseCOOElementTemplateInterface { public: typedef ... value_type; typedef ... index_type;

value_type& value(); value_type value() const; index_type row_i() const; index_type col_j() const; };

class COOMatrixTemplateInterface { public: typedef ... size_type; typedef ... difference_type; typedef ... element_type; // SparseCOOElementTemplateInterface compliant typedef ... iterator; // returns an element_type typedef ... const_iterator; // returns a const element_type

size_type rows() const; size_type cols() const; size_type nz() const; difference_type row_offset() const; difference_type col_offset() const; iterator begin(); const_iterator begin() const; iterator end(); const_iterator end() const; }; {verbatim}

The nonzero elements are specified by the triplet (val,i,j) where:\

#val[k] = (begin() + k)->value()#\ #i[k] = (begin() + k)->row_i() + row_offset()#\ #j[k] = (begin() + k)->col_j() + col_offset()#\

for #k# = #0#, ..., #nz() - 1#.

The iterator returned by the begin() functions needs to be a forward iterator that supports ++itr. These elements need not be sorted but the operations may perform better if they are. What order will dependent on which operation and which options. See the individual operations to determine which sorting orders are best.

Actually these linear algebra functions only use the constant interface to these tempalte interfaces so the iterators only need to support the constant interface.

These functions use the same basic naming sceme as DenseLinAlgPack with a few exceptions. All of the operations are += instead of = because of the nature of the sparse matrix calculates so instead of #V_# and #M_# starting out the function names they begin with #Vp_# and #Mp_# with #p_# used to signify += instead of just =. Also #COOM# replaces #M# where a COO matrrix replaces the dense DMatrix. This is because the overload resolution rules would mess up the implicit type conversions that go on in DenseLinAlgPack if the exact same names where used.

Function Documentation

template<class T_COOM >

void AbstractLinAlgPack::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))

Definition at line 61 of file AbstractLinAlgPack_COOMatrixTmplOpDef.hpp.

template<class T_COOM >

void AbstractLinAlgPack::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))

Definition at line 79 of file AbstractLinAlgPack_COOMatrixTmplOpDef.hpp.

template<class T_COOM >

void AbstractLinAlgPack::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)

Definition at line 107 of file AbstractLinAlgPack_COOMatrixTmplOpDef.hpp.

template<class T_COOM >

void AbstractLinAlgPack::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)

Definition at line 119 of file AbstractLinAlgPack_COOMatrixTmplOpDef.hpp.