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 dot (const DVectorSlice &vs_rhs1, const SparseVectorSlice< T_Ele > &sv_rhs2)
 begin Sparse BLAS operations 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


Function Documentation

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

begin Sparse BLAS operations result = dot(vs_rhs1,sv_rhs2) (BLAS xDOT)

Definition at line 67 of file AbstractLinAlgPack_SparseVectorSliceOp.hpp.

template<class T_Ele>
value_type 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 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 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 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 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 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 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 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 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 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 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 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 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 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.


Generated on Thu Sep 18 12:35:29 2008 for MOOCHO (Single Doxygen Collection) by doxygen 1.3.9.1