AbstractLinAlgPack_SparseVectorOpDef.hpp File Reference

#include "AbstractLinAlgPack_Types.hpp"
#include "AbstractLinAlgPack_SparseVectorClass.hpp"
#include "DenseLinAlgPack_DVectorOp.hpp"
#include "DenseLinAlgPack_DMatrixAsTriSym.hpp"
#include "DenseLinAlgPack_DMatrixClass.hpp"
#include "DenseLinAlgPack_AssertOp.hpp"

Include dependency graph for AbstractLinAlgPack_SparseVectorOpDef.hpp:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.


namespace  AbstractLinAlgPack
namespace  AbstractLinAlgPack::SparseVectorUtilityPack

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 AbstractLinAlgPack::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 AbstractLinAlgPack::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 AbstractLinAlgPack::norm_1_SV (const T_SpVec &sv_rhs)
 result = ||sv_rhs||1 (BLAS xASUM)
template<class T_SpVec>
value_type AbstractLinAlgPack::norm_2_SV (const T_SpVec &sv_rhs)
 result = ||sv_rhs||2 (BLAS xNRM2)
template<class T_SpVec>
value_type AbstractLinAlgPack::norm_inf_SV (const T_SpVec &sv_rhs)
 result = ||sv_rhs||inf (BLAS IxAMAX)
template<class T_SpVec>
value_type AbstractLinAlgPack::max_SV (const T_SpVec &sv_rhs)
 result = max(sv_rhs)
template<class T_SpVec>
value_type AbstractLinAlgPack::min_SV (const T_SpVec &sv_rhs)
 result = min(sv_rhs)
template<class T_SpVec>
void AbstractLinAlgPack::Vt_S (T_SpVec *sv_lhs, value_type alpha)
 sv_lhs *= alpha (BLAS xSCAL)
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)
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)
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)
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)


template<class T>
my_my_max (const T &v1, const T &v2)
template<class T>
my_my_min (const T &v1, const T &v2)
template<class T_SpVec>
value_type AbstractLinAlgPack::SparseVectorUtilityPack::imp_dot2_V_V_SV (const DVectorSlice &vs1, const DVectorSlice &vs2, const T_SpVec &sv)

Function Documentation

template<class T>
T @20::my_my_max ( const T &  v1,
const T &  v2 
) [inline, static]

Definition at line 56 of file AbstractLinAlgPack_SparseVectorOpDef.hpp.

template<class T>
T @20::my_my_min ( const T &  v1,
const T &  v2 
) [inline, static]

Definition at line 59 of file AbstractLinAlgPack_SparseVectorOpDef.hpp.

Generated on Tue Jul 13 09:31:37 2010 for MOOCHO (Single Doxygen Collection) by  doxygen 1.4.7