AbstractLinAlgPack_SparseVectorSliceOp.hpp File Reference

#include "AbstractLinAlgPack_SparseVectorOp.hpp"
#include "DenseLinAlgPack_AssertOp.hpp"
#include "DenseLinAlgPack_DVectorOp.hpp"

Include dependency graph for AbstractLinAlgPack_SparseVectorSliceOp.hpp:

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

Go to the source code of this file.

Namespaces

namespace  AbstractLinAlgPack

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 AbstractLinAlgPack::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 AbstractLinAlgPack::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 AbstractLinAlgPack::norm_1 (const SparseVectorSlice< T_Ele > &sv_rhs)
 result = ||sv_rhs||1 (BLAS xASUM)
template<class T_Ele>
value_type AbstractLinAlgPack::norm_2 (const SparseVectorSlice< T_Ele > &sv_rhs)
 result = ||sv_rhs||2 (BLAS xNRM2)
template<class T_Ele>
value_type AbstractLinAlgPack::norm_inf (const SparseVectorSlice< T_Ele > &sv_rhs)
 result = ||sv_rhs||inf (BLAS IxAMAX)
template<class T_Ele>
value_type AbstractLinAlgPack::max (const SparseVectorSlice< T_Ele > &sv_rhs)
 result = max(sv_rhs)
template<class T_Ele>
value_type AbstractLinAlgPack::min (const SparseVectorSlice< T_Ele > &sv_rhs)
 result = min(sv_rhs)
template<class T_Ele>
void AbstractLinAlgPack::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 AbstractLinAlgPack::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 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)
 vs_lhs += alpha * op(tri_gms_rhs1) * sv_rhs2 (BLAS xTRMV)
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)
 vs_lhs += alpha * op(sym_gms_rhs1) * sv_rhs2 (BLAS xSYMV)
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)
 vs_lhs = alpha * op(M_rhs1) * sv_rhs2 + beta * vs_lhs
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)
 vs_lhs = alpha * op(gms_rhs1) * sv_rhs2 + beta * vs_lhs
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)
 vs_lhs = alpha * op(tri_gms_rhs1) * sv_rhs2 + beta * vs_lhs
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)
 vs_lhs = alpha * op(sym_gms_rhs1) * sv_rhs2 + beta * vs_lhs


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