Modules | Classes | Functions | Friends
Dense Vectors

Modules

 DynamicVector
 
 HybridVector
 
 StaticVector
 
 Expressions
 

Classes

struct  blaze::DenseVector< VT, TF >
 Base class for N-dimensional dense vectors.The DenseVector class is a base class for all arbitrarily sized (N-dimensional) dense vectors. It provides an abstraction from the actual type of the dense vector, but enables a conversion back to this type via the Vector base class. More...
 

Functions

template<typename T1 , typename T2 >
const DisableIf< IsMatMatMultExpr< T1 >, DMatDVecMultExpr< T1, T2 > >::Type blaze::operator* (const DenseMatrix< T1, false > &mat, const DenseVector< T2, false > &vec)
 Multiplication operator for the multiplication of a row-major dense matrix and a dense vector ( $ \vec{y}=A*\vec{x} $). More...
 
template<typename T1 , bool SO, typename T2 >
const EnableIf< IsMatMatMultExpr< T1 >, typename MultExprTrait< T1, T2 >::Type >::Type blaze::operator* (const DenseMatrix< T1, SO > &mat, const DenseVector< T2, false > &vec)
 Multiplication operator for the multiplication of a dense matrix-matrix multiplication expression and a dense vector ( $ \vec{y}=(A*B)*\vec{x} $). More...
 
template<typename T1 , typename T2 >
const DisableIf< Or< IsSymmetric< T1 >, IsMatMatMultExpr< T1 > >, DMatSVecMultExpr< T1, T2 > >::Type blaze::operator* (const DenseMatrix< T1, false > &mat, const SparseVector< T2, false > &vec)
 Multiplication operator for the multiplication of a row-major dense matrix and a sparse vector ( $ \vec{y}=A*\vec{x} $). More...
 
template<typename VT , bool TF>
const DVecAbsExpr< VT, TF > blaze::abs (const DenseVector< VT, TF > &dv)
 Returns a vector containing the absolute values of each single element of dv. More...
 
template<typename T1 , typename T2 , bool TF>
const DVecDVecAddExpr< T1, T2, TF > blaze::operator+ (const DenseVector< T1, TF > &lhs, const DenseVector< T2, TF > &rhs)
 Addition operator for the addition of two dense vectors ( $ \vec{a}=\vec{b}+\vec{c} $). More...
 
template<typename T1 , typename T2 >
const DVecDVecCrossExpr< T1, T2 > blaze::operator% (const DenseVector< T1, false > &lhs, const DenseVector< T2, false > &rhs)
 Operator for the cross product of two dense vectors ( $ \vec{a}=\vec{b} \times \vec{c} $). More...
 
template<typename T1 , typename T2 , bool TF>
const DVecDVecMultExpr< T1, T2, TF > blaze::operator* (const DenseVector< T1, TF > &lhs, const DenseVector< T2, TF > &rhs)
 Multiplication operator for the componentwise product of two dense vectors ( $ \vec{a}=\vec{b}*\vec{c} $). More...
 
template<typename T1 , typename T2 , bool TF>
const DVecDVecSubExpr< T1, T2, TF > blaze::operator- (const DenseVector< T1, TF > &lhs, const DenseVector< T2, TF > &rhs)
 Subtraction operator for the subtraction of two dense vectors ( $ \vec{a}=\vec{b}-\vec{c} $). More...
 
template<typename VT , bool TF>
const DVecEvalExpr< VT, TF > blaze::eval (const DenseVector< VT, TF > &dv)
 Forces the evaluation of the given dense vector expression dv. More...
 
template<typename T1 , typename T2 , bool TF>
const EnableIf< IsNumeric< T2 >, typename DivExprTrait< T1, T2 >::Type >::Type blaze::operator/ (const DenseVector< T1, TF > &vec, T2 scalar)
 Division operator for the divison of a dense vector by a scalar value ( $ \vec{a}=\vec{b}/s $). More...
 
template<typename VT , bool TF>
const DVecScalarMultExpr< VT, typename BaseElementType< VT >::Type, TF > blaze::operator- (const DenseVector< VT, TF > &dv)
 Unary minus operator for the negation of a dense vector ( $ \vec{a} = -\vec{b} $). More...
 
template<typename T1 , typename T2 , bool TF>
const EnableIf< IsNumeric< T2 >, typename MultExprTrait< T1, T2 >::Type >::Type blaze::operator* (const DenseVector< T1, TF > &vec, T2 scalar)
 Multiplication operator for the multiplication of a dense vector and a scalar value ( $ \vec{a}=\vec{b}*s $). More...
 
template<typename T1 , typename T2 , bool TF>
const EnableIf< IsNumeric< T1 >, typename MultExprTrait< T1, T2 >::Type >::Type blaze::operator* (T1 scalar, const DenseVector< T2, TF > &vec)
 Multiplication operator for the multiplication of a scalar value and a dense vector ( $ \vec{a}=s*\vec{b} $). More...
 
template<typename VT , bool TF>
const DVecSerialExpr< VT, TF > blaze::serial (const DenseVector< VT, TF > &dv)
 Forces the serial evaluation of the given dense vector expression dv. More...
 
template<typename T1 , typename T2 , bool TF>
const DVecSVecAddExpr< T1, T2, TF > blaze::operator+ (const DenseVector< T1, TF > &lhs, const SparseVector< T2, TF > &rhs)
 Addition operator for the addition of a dense vector and a sparse vector ( $ \vec{a}=\vec{b}+\vec{c} $). More...
 
template<typename T1 , typename T2 , bool TF>
const DVecSVecAddExpr< T2, T1, TF > blaze::operator+ (const SparseVector< T1, TF > &lhs, const DenseVector< T2, TF > &rhs)
 Addition operator for the addition of a sparse vector and a dense vector ( $ \vec{a}=\vec{b}+\vec{c} $). More...
 
template<typename T1 , typename T2 >
const DVecSVecCrossExpr< T1, T2 > blaze::operator% (const DenseVector< T1, false > &lhs, const SparseVector< T2, false > &rhs)
 Operator for the cross product of a dense vector and a sparse vector ( $ \vec{a}=\vec{b} \times \vec{c} $). More...
 
template<typename T1 , typename T2 , bool TF>
const DVecSVecSubExpr< T1, T2, TF > blaze::operator- (const DenseVector< T1, TF > &lhs, const SparseVector< T2, TF > &rhs)
 Subtraction operator for the subtraction of a dense vector and a sparse vector ( $ \vec{a}=\vec{b}-\vec{c} $). More...
 
template<typename VT , bool TF>
const DVecTransExpr< VT,!TF > blaze::trans (const DenseVector< VT, TF > &dv)
 Calculation of the transpose of the given dense vector. More...
 
template<typename T1 , typename T2 >
const DisableIf< IsMatMatMultExpr< T1 >, SMatDVecMultExpr< T1, T2 > >::Type blaze::operator* (const SparseMatrix< T1, false > &mat, const DenseVector< T2, false > &vec)
 Multiplication operator for the multiplication of a row-major sparse matrix and a dense vector ( $ \vec{y}=A*\vec{x} $). More...
 
template<typename T1 , bool SO, typename T2 >
const EnableIf< IsMatMatMultExpr< T1 >, typename MultExprTrait< T1, T2 >::Type >::Type blaze::operator* (const SparseMatrix< T1, SO > &mat, const DenseVector< T2, false > &vec)
 Multiplication operator for the multiplication of a sparse matrix-matrix multiplication expression and a dense vector ( $ \vec{y}=(A*B)*\vec{x} $). More...
 
template<typename T1 , typename T2 >
const SVecDVecCrossExpr< T1, T2 > blaze::operator% (const SparseVector< T1, false > &lhs, const DenseVector< T2, false > &rhs)
 Operator for the cross product of a sparse vector and a dense vector ( $ \vec{a}=\vec{b} \times \vec{c} $). More...
 
template<typename T1 , typename T2 , bool TF>
const SVecDVecSubExpr< T1, T2, TF > blaze::operator- (const SparseVector< T1, TF > &lhs, const DenseVector< T2, TF > &rhs)
 Subtraction operator for the subtraction of a sparse vector and a dense vector ( $ \vec{a}=\vec{b}-\vec{c} $). More...
 
template<typename T1 , typename T2 >
const SVecSVecCrossExpr< T1, T2 > blaze::operator% (const SparseVector< T1, false > &lhs, const SparseVector< T2, false > &rhs)
 Operator for the cross product of two sparse vectors ( $ \vec{a}=\vec{b} \times \vec{c} $). More...
 
template<typename T1 , typename T2 >
const DisableIf< IsMatMatMultExpr< T1 >, TDMatDVecMultExpr< T1, T2 > >::Type blaze::operator* (const DenseMatrix< T1, true > &mat, const DenseVector< T2, false > &vec)
 Multiplication operator for the multiplication of a column-major dense matrix and a dense vector ( $ \vec{y}=A*\vec{x} $). More...
 
template<typename T1 , typename T2 >
const DisableIf< IsMatMatMultExpr< T1 >, TDMatSVecMultExpr< T1, T2 > >::Type blaze::operator* (const DenseMatrix< T1, true > &mat, const SparseVector< T2, false > &vec)
 Multiplication operator for the multiplication of a column-major dense matrix and a sparse vector ( $ \vec{y}=A*\vec{x} $). More...
 
template<typename T1 , typename T2 >
const DisableIf< IsMatMatMultExpr< T2 >, TDVecDMatMultExpr< T1, T2 > >::Type blaze::operator* (const DenseVector< T1, true > &vec, const DenseMatrix< T2, false > &mat)
 Multiplication operator for the multiplication of a transpose dense vector and a row-major dense matrix ( $ \vec{y}^T=\vec{x}^T*A $). More...
 
template<typename T1 , typename T2 , bool SO>
const EnableIf< IsMatMatMultExpr< T2 >, typename MultExprTrait< T1, T2 >::Type >::Type blaze::operator* (const DenseVector< T1, true > &vec, const DenseMatrix< T2, SO > &mat)
 Multiplication operator for the multiplication of a transpose dense vector and a dense matrix-matrix multiplication expression ( $ \vec{y}^T=\vec{x}^T*(A*B) $). More...
 
template<typename T1 , typename T2 >
DisableIf< TDVecDVecMultExprHelper< T1, T2 >, const typename MultTrait< typename T1::ElementType, typename T2::ElementType >::Type >::Type blaze::operator* (const DenseVector< T1, true > &lhs, const DenseVector< T2, false > &rhs)
 Default multiplication operator for the scalar product (inner product) of two dense vectors ( $ s=\vec{a}*\vec{b} $). More...
 
template<typename T1 , typename T2 >
const DisableIf< Or< IsSymmetric< T2 >, IsMatMatMultExpr< T2 > >, TDVecSMatMultExpr< T1, T2 > >::Type blaze::operator* (const DenseVector< T1, true > &vec, const SparseMatrix< T2, false > &mat)
 Multiplication operator for the multiplication of a transpose dense vector and a row-major sparse matrix ( $ \vec{y}^T=\vec{x}^T*A $). More...
 
template<typename T1 , typename T2 , bool SO>
const EnableIf< IsMatMatMultExpr< T2 >, typename MultExprTrait< T1, T2 >::Type >::Type blaze::operator* (const DenseVector< T1, true > &vec, const SparseMatrix< T2, SO > &mat)
 Multiplication operator for the multiplication of a transpose dense vector and a sparse matrix-matrix multiplication expression ( $ \vec{y}^T=\vec{x}^T*(A*B) $). More...
 
template<typename T1 , typename T2 >
const DisableIf< Or< IsSymmetric< T1 >, IsMatMatMultExpr< T1 > >, TSMatDVecMultExpr< T1, T2 > >::Type blaze::operator* (const SparseMatrix< T1, true > &mat, const DenseVector< T2, false > &vec)
 Multiplication operator for the multiplication of a column-major sparse matrix and a dense vector ( $ \vec{y}=A*\vec{x} $). More...
 
template<typename T1 , typename T2 , bool SO>
const EnableIf< IsMatMatMultExpr< T2 >, typename MultExprTrait< T1, T2 >::Type >::Type blaze::operator* (const SparseVector< T1, true > &vec, const DenseMatrix< T2, SO > &mat)
 Multiplication operator for the multiplication of a transpose sparse vector and a dense matrix-matrix multiplication expression ( $ \vec{y}^T=\vec{x}^T*(A*B) $). More...
 
template<typename T1 , typename T2 >
const DisableIf< Or< IsSymmetric< T2 >, IsMatMatMultExpr< T2 > >, TSVecTDMatMultExpr< T1, T2 > >::Type blaze::operator* (const SparseVector< T1, true > &vec, const DenseMatrix< T2, true > &mat)
 Multiplication operator for the multiplication of a transpose sparse vector and a column-major dense matrix ( $ \vec{y}^T=\vec{x}^T*A $). More...
 

Friends

template<typename VT2 >
void blaze::TDVecSMatMultExpr< VT, MT >::assign (DenseVector< VT2, true > &lhs, const TDVecSMatMultExpr &rhs)
 Assignment of a transpose dense vector-sparse matrix multiplication to a dense vector ( $ \vec{y}^T=\vec{x}^T*A $). More...
 
template<typename VT2 >
void blaze::TDVecSMatMultExpr< VT, MT >::assign (SparseVector< VT2, true > &lhs, const TDVecSMatMultExpr &rhs)
 Assignment of a transpose dense vector-sparse matrix multiplication to a sparse vector ( $ \vec{y}^T=\vec{x}^T*A $). More...
 
template<typename VT2 >
void blaze::TDVecSMatMultExpr< VT, MT >::addAssign (DenseVector< VT2, true > &lhs, const TDVecSMatMultExpr &rhs)
 Addition assignment of a transpose dense vector-sparse matrix multiplication to a dense vector ( $ \vec{y}^T+=\vec{x}^T*A $). More...
 
template<typename VT2 >
void blaze::TDVecSMatMultExpr< VT, MT >::subAssign (DenseVector< VT2, true > &lhs, const TDVecSMatMultExpr &rhs)
 Subtraction assignment of a transpose dense vector-sparse matrix multiplication to a dense vector ( $ \vec{y}^T-=\vec{x}^T*A $). More...
 
template<typename VT2 >
void blaze::TDVecSMatMultExpr< VT, MT >::multAssign (DenseVector< VT2, true > &lhs, const TDVecSMatMultExpr &rhs)
 Multiplication assignment of a transpose dense vector-sparse matrix multiplication to a dense vector ( $ \vec{y}^T*=\vec{x}^T*A $). More...
 
template<typename VT2 >
EnableIf< UseSMPAssign< VT2 > >::Type blaze::TDVecSMatMultExpr< VT, MT >::smpAssign (DenseVector< VT2, true > &lhs, const TDVecSMatMultExpr &rhs)
 SMP assignment of a transpose dense vector-sparse matrix multiplication to a dense vector ( $ \vec{y}^T=\vec{x}^T*A $). More...
 
template<typename VT2 >
EnableIf< UseSMPAssign< VT2 > >::Type blaze::TDVecSMatMultExpr< VT, MT >::smpAssign (SparseVector< VT2, true > &lhs, const TDVecSMatMultExpr &rhs)
 SMP assignment of a transpose dense vector-sparse matrix multiplication to a sparse vector ( $ \vec{y}^T=\vec{x}^T*A $). More...
 
template<typename VT2 >
EnableIf< UseSMPAssign< VT2 > >::Type blaze::TDVecSMatMultExpr< VT, MT >::smpAddAssign (DenseVector< VT2, true > &lhs, const TDVecSMatMultExpr &rhs)
 Addition assignment of a transpose dense vector-sparse matrix multiplication to a dense vector ( $ \vec{y}^T+=\vec{x}^T*A $). More...
 
template<typename VT2 >
EnableIf< UseSMPAssign< VT2 > >::Type blaze::TDVecSMatMultExpr< VT, MT >::smpSubAssign (DenseVector< VT2, true > &lhs, const TDVecSMatMultExpr &rhs)
 SMP subtraction assignment of a transpose dense vector-sparse matrix multiplication to a dense vector ( $ \vec{y}^T-=\vec{x}^T*A $). More...
 
template<typename VT2 >
EnableIf< UseSMPAssign< VT2 > >::Type blaze::TDVecSMatMultExpr< VT, MT >::smpMultAssign (DenseVector< VT2, true > &lhs, const TDVecSMatMultExpr &rhs)
 SMP multiplication assignment of a transpose dense vector-sparse matrix multiplication to a dense vector ( $ \vec{y}^T*=\vec{x}^T*A $). More...
 
template<typename VT2 >
EnableIf< UseAssign< VT2 > >::Type blaze::TDVecTSMatMultExpr< VT, MT >::assign (DenseVector< VT2, true > &lhs, const TDVecTSMatMultExpr &rhs)
 Assignment of a transpose dense vector-transpose sparse matrix multiplication to a dense vector ( $ \vec{y}^T=\vec{x}^T*A $). More...
 
template<typename VT2 >
EnableIf< UseAssign< VT2 > >::Type blaze::TDVecTSMatMultExpr< VT, MT >::assign (SparseVector< VT2, true > &lhs, const TDVecTSMatMultExpr &rhs)
 Assignment of a transpose dense vector-transpose sparse matrix multiplication to a sparse vector ( $ \vec{y}^T=\vec{x}^T*A $). More...
 
template<typename VT2 >
EnableIf< UseAssign< VT2 > >::Type blaze::TDVecTSMatMultExpr< VT, MT >::addAssign (DenseVector< VT2, true > &lhs, const TDVecTSMatMultExpr &rhs)
 Addition assignment of a transpose dense vector-transpose sparse matrix multiplication to a dense vector ( $ \vec{y}^T+=\vec{x}^T*A $). More...
 
template<typename VT2 >
EnableIf< UseAssign< VT2 > >::Type blaze::TDVecTSMatMultExpr< VT, MT >::subAssign (DenseVector< VT2, true > &lhs, const TDVecTSMatMultExpr &rhs)
 Subtraction assignment of a transpose dense vector-transpose sparse matrix multiplication to a dense vector ( $ \vec{y}^T-=\vec{x}^T*A $). More...
 
template<typename VT2 >
EnableIf< UseAssign< VT2 > >::Type blaze::TDVecTSMatMultExpr< VT, MT >::multAssign (DenseVector< VT2, true > &lhs, const TDVecTSMatMultExpr &rhs)
 Multiplication assignment of a transpose dense vector-transpose sparse matrix multiplication to a dense vector ( $ \vec{y}^T*=\vec{x}^T*A $). More...
 
template<typename VT2 >
EnableIf< UseSMPAssign< VT2 > >::Type blaze::TDVecTSMatMultExpr< VT, MT >::smpAssign (DenseVector< VT2, true > &lhs, const TDVecTSMatMultExpr &rhs)
 SMP assignment of a transpose dense vector-transpose sparse matrix multiplication to a dense vector ( $ \vec{y}^T=\vec{x}^T*A $). More...
 
template<typename VT2 >
EnableIf< UseSMPAssign< VT2 > >::Type blaze::TDVecTSMatMultExpr< VT, MT >::smpAssign (SparseVector< VT2, true > &lhs, const TDVecTSMatMultExpr &rhs)
 SMP assignment of a transpose dense vector-transpose sparse matrix multiplication to a sparse vector ( $ \vec{y}^T=\vec{x}^T*A $). More...
 
template<typename VT2 >
EnableIf< UseSMPAssign< VT2 > >::Type blaze::TDVecTSMatMultExpr< VT, MT >::smpAddAssign (DenseVector< VT2, true > &lhs, const TDVecTSMatMultExpr &rhs)
 SMP addition assignment of a transpose dense vector-transpose sparse matrix multiplication to a dense vector ( $ \vec{y}^T+=\vec{x}^T*A $). More...
 
template<typename VT2 >
EnableIf< UseSMPAssign< VT2 > >::Type blaze::TDVecTSMatMultExpr< VT, MT >::smpSubAssign (DenseVector< VT2, true > &lhs, const TDVecTSMatMultExpr &rhs)
 SMP subtraction assignment of a transpose dense vector-transpose sparse matrix multiplication to a dense vector ( $ \vec{y}^T-=\vec{x}^T*A $). More...
 
template<typename VT2 >
EnableIf< UseSMPAssign< VT2 > >::Type blaze::TDVecTSMatMultExpr< VT, MT >::smpMultAssign (DenseVector< VT2, true > &lhs, const TDVecTSMatMultExpr &rhs)
 SMP multiplication assignment of a transpose dense vector-transpose sparse matrix multiplication to a dense vector ( $ \vec{y}^T*=\vec{x}^T*A $). More...
 
template<typename VT2 >
void blaze::TSVecDMatMultExpr< VT, MT >::addAssign (DenseVector< VT2, true > &lhs, const TSVecDMatMultExpr &rhs)
 Addition assignment of a transpose sparse vector-dense matrix multiplication to a dense vector ( $ \vec{y}^T+=\vec{x}^T*A $). More...
 
template<typename VT2 >
void blaze::TSVecDMatMultExpr< VT, MT >::subAssign (DenseVector< VT2, true > &lhs, const TSVecDMatMultExpr &rhs)
 Subtraction assignment of a transpose sparse vector-dense matrix multiplication to a dense vector ( $ \vec{y}^T-=\vec{x}^T*A $). More...
 
template<typename VT2 >
void blaze::TSVecDMatMultExpr< VT, MT >::multAssign (DenseVector< VT2, true > &lhs, const TSVecDMatMultExpr &rhs)
 Multiplication assignment of a transpose sparse vector-dense matrix multiplication to a dense vector ( $ \vec{y}^T*=\vec{x}^T*A $). More...
 
template<typename VT2 >
EnableIf< UseSMPAssign< VT2 > >::Type blaze::TSVecDMatMultExpr< VT, MT >::smpAddAssign (DenseVector< VT2, true > &lhs, const TSVecDMatMultExpr &rhs)
 SMP addition assignment of a transpose sparse vector-dense matrix multiplication to a dense vector ( $ \vec{y}^T+=\vec{x}^T*A $). More...
 
template<typename VT2 >
EnableIf< UseSMPAssign< VT2 > >::Type blaze::TSVecDMatMultExpr< VT, MT >::smpSubAssign (DenseVector< VT2, true > &lhs, const TSVecDMatMultExpr &rhs)
 SMP subtraction assignment of a transpose sparse vector-dense matrix multiplication to a dense vector ( $ \vec{y}^T-=\vec{x}^T*A $). More...
 
template<typename VT2 >
EnableIf< UseSMPAssign< VT2 > >::Type blaze::TSVecDMatMultExpr< VT, MT >::smpMultAssign (DenseVector< VT2, true > &lhs, const TSVecDMatMultExpr &rhs)
 SMP multiplication assignment of a transpose sparse vector-dense matrix multiplication to a dense vector ( $ \vec{y}^T*=\vec{x}^T*A $). More...
 
template<typename VT2 >
EnableIf< UseAssign< VT2 > >::Type blaze::TSVecTDMatMultExpr< VT, MT >::addAssign (DenseVector< VT2, true > &lhs, const TSVecTDMatMultExpr &rhs)
 Addition assignment of a transpose sparse vector-transpose dense matrix multiplication to a dense vector ( $ \vec{y}^T+=\vec{x}^T*A $). More...
 
template<typename VT2 >
EnableIf< UseAssign< VT2 > >::Type blaze::TSVecTDMatMultExpr< VT, MT >::subAssign (DenseVector< VT2, true > &lhs, const TSVecTDMatMultExpr &rhs)
 Subtraction assignment of a transpose sparse vector-transpose dense matrix multiplication to a dense vector ( $ \vec{y}^T-=\vec{x}^T*A $). More...
 
template<typename VT2 >
EnableIf< UseAssign< VT2 > >::Type blaze::TSVecTDMatMultExpr< VT, MT >::multAssign (DenseVector< VT2, true > &lhs, const TSVecTDMatMultExpr &rhs)
 Multiplication assignment of a transpose sparse vector-transpose dense matrix multiplication to a dense vector ( $ \vec{y}^T*=\vec{x}^T*A $). More...
 
template<typename VT2 >
EnableIf< UseSMPAssign< VT2 > >::Type blaze::TSVecTDMatMultExpr< VT, MT >::smpAddAssign (DenseVector< VT2, true > &lhs, const TSVecTDMatMultExpr &rhs)
 SMP addition assignment of a transpose sparse vector-transpose dense matrix multiplication to a dense vector ( $ \vec{y}^T+=\vec{x}^T*A $). More...
 
template<typename VT2 >
EnableIf< UseSMPAssign< VT2 > >::Type blaze::TSVecTDMatMultExpr< VT, MT >::smpSubAssign (DenseVector< VT2, true > &lhs, const TSVecTDMatMultExpr &rhs)
 SMP subtraction assignment of a transpose sparse vector-transpose dense matrix multiplication to a dense vector ( $ \vec{y}^T-=\vec{x}^T*A $). More...
 
template<typename VT2 >
EnableIf< UseSMPAssign< VT2 > >::Type blaze::TSVecTDMatMultExpr< VT, MT >::smpMultAssign (DenseVector< VT2, true > &lhs, const TSVecTDMatMultExpr &rhs)
 SMP multiplication assignment of a transpose sparse vector-transpose dense matrix multiplication to a dense vector ( $ \vec{y}^T*=\vec{x}^T*A $). More...
 

DenseVector operators

template<typename T1 , bool TF1, typename T2 , bool TF2>
bool blaze::operator== (const DenseVector< T1, TF1 > &lhs, const DenseVector< T2, TF2 > &rhs)
 Equality operator for the comparison of two dense vectors. More...
 
template<typename T1 , bool TF1, typename T2 , bool TF2>
bool blaze::operator== (const DenseVector< T1, TF1 > &lhs, const SparseVector< T2, TF2 > &rhs)
 Equality operator for the comparison of a dense vector and a sparse vector. More...
 
template<typename T1 , bool TF1, typename T2 , bool TF2>
bool blaze::operator== (const SparseVector< T1, TF1 > &lhs, const DenseVector< T2, TF2 > &rhs)
 Equality operator for the comparison of a sparse vector and a dense vector. More...
 
template<typename T1 , typename T2 , bool TF>
EnableIf< IsNumeric< T2 >, bool >::Type blaze::operator== (const DenseVector< T1, TF > &vec, T2 scalar)
 Equality operator for the comparison of a dense vector and a scalar value. More...
 
template<typename T1 , typename T2 , bool TF>
EnableIf< IsNumeric< T1 >, bool >::Type blaze::operator== (T1 scalar, const DenseVector< T2, TF > &vec)
 Equality operator for the comparison of a scalar value and a dense vector. More...
 
template<typename T1 , bool TF1, typename T2 , bool TF2>
bool blaze::operator!= (const DenseVector< T1, TF1 > &lhs, const DenseVector< T2, TF2 > &rhs)
 Inequality operator for the comparison of two dense vectors. More...
 
template<typename T1 , bool TF1, typename T2 , bool TF2>
bool blaze::operator!= (const DenseVector< T1, TF1 > &lhs, const SparseVector< T2, TF2 > &rhs)
 Inequality operator for the comparison of a dense vector and a sparse vector. More...
 
template<typename T1 , bool TF1, typename T2 , bool TF2>
bool blaze::operator!= (const SparseVector< T1, TF1 > &lhs, const DenseVector< T2, TF2 > &rhs)
 Inequality operator for the comparison of a sparse vector and a dense vector. More...
 
template<typename T1 , typename T2 , bool TF>
EnableIf< IsNumeric< T2 >, bool >::Type blaze::operator!= (const DenseVector< T1, TF > &vec, T2 scalar)
 Inequality operator for the comparison of a dense vector and a scalar value. More...
 
template<typename T1 , typename T2 , bool TF>
EnableIf< IsNumeric< T1 >, bool >::Type blaze::operator!= (T1 scalar, const DenseVector< T2, TF > &vec)
 Inequality operator for the comparison of a scalar value and a dense vector. More...
 

DenseVector functions

template<typename VT , bool TF>
bool blaze::isnan (const DenseVector< VT, TF > &dv)
 Checks the given dense vector for not-a-number elements. More...
 
template<typename VT , bool TF>
bool blaze::isUniform (const DenseVector< VT, TF > &dv)
 Checks if the given dense vector is a uniform vector. More...
 
template<typename VT , bool TF>
CMathTrait< typename VT::ElementType >::Type blaze::length (const DenseVector< VT, TF > &dv)
 Calculation of the dense vector length $|\vec{a}|$. More...
 
template<typename VT , bool TF>
const VT::ElementType blaze::sqrLength (const DenseVector< VT, TF > &dv)
 Calculation of the dense vector square length $|\vec{a}|^2$. More...
 
template<typename VT , bool TF>
const VT::ElementType blaze::min (const DenseVector< VT, TF > &dv)
 Returns the smallest element of the dense vector. More...
 
template<typename VT , bool TF>
const VT::ElementType blaze::max (const DenseVector< VT, TF > &dv)
 Returns the largest element of the dense vector. More...
 

Detailed Description

Function Documentation

template<typename VT , bool TF>
const DVecAbsExpr<VT,TF> blaze::abs ( const DenseVector< VT, TF > &  dv)
inline

Returns a vector containing the absolute values of each single element of dv.

Parameters
dvThe input vector.
Returns
The absolute value of each single element of dv.

The abs function calculates the absolute value of each element of the input vector dv. The function returns an expression representing this operation.
The following example demonstrates the use of the abs function:

// ... Resizing and initialization
b = abs( a );
template<typename VT , bool TF>
const DVecEvalExpr<VT,TF> blaze::eval ( const DenseVector< VT, TF > &  dv)
inline

Forces the evaluation of the given dense vector expression dv.

Parameters
dvThe input vector.
Returns
The evaluated dense vector.

The eval function forces the evaluation of the given dense vector expression dv. The function returns an expression representing this operation.
The following example demonstrates the use of the eval function:

// ... Resizing and initialization
b = eval( a );
template<typename VT , bool TF>
bool blaze::isnan ( const DenseVector< VT, TF > &  dv)

Checks the given dense vector for not-a-number elements.

Parameters
dvThe vector to be checked for not-a-number elements.
Returns
true if at least one element of the vector is not-a-number, false otherwise.

This function checks the N-dimensional dense vector for not-a-number (NaN) elements. If at least one element of the vector is not-a-number, the function returns true, otherwise it returns false.

// ... Resizing and initialization
if( isnan( a ) ) { ... }

Note that this function only works for vectors with floating point elements. The attempt to use it for a vector with a non-floating point element type results in a compile time error.

template<typename VT , bool TF>
bool blaze::isUniform ( const DenseVector< VT, TF > &  dv)

Checks if the given dense vector is a uniform vector.

Parameters
dvThe dense vector to be checked.
Returns
true if the vector is a uniform vector, false if not.

This function checks if the given dense vector is a uniform vector. The vector is considered to be uniform if all its elements are identical. The following code example demonstrates the use of the function:

// ... Initialization
if( isUniform( a ) ) { ... }

It is also possible to check if a vector expression results in a uniform vector:

if( isUniform( a + b ) ) { ... }

However, note that this might require the complete evaluation of the expression, including the generation of a temporary vector.

template<typename VT , bool TF>
CMathTrait< typename VT::ElementType >::Type blaze::length ( const DenseVector< VT, TF > &  dv)

Calculation of the dense vector length $|\vec{a}|$.

Parameters
dvThe given dense vector.
Returns
The length of the dense vector.

This function calculates the actual length of the dense vector. The return type of the length() function depends on the actual element type of the vector instance:

ElementType LengthType
float float
integral data types and double double
long double long double

Note: This operation is only defined for numeric data types. In case the element type is not a numeric data type (i.e. a user defined data type or boolean) the attempt to use the length() function results in a compile time error!

template<typename VT , bool TF>
const VT::ElementType blaze::max ( const DenseVector< VT, TF > &  dv)

Returns the largest element of the dense vector.

Parameters
dvThe given dense vector.
Returns
The largest dense vector element.

This function returns the largest element of the given dense vector. This function can only be used for element types that support the smaller-than relationship. In case the vector currently has a size of 0, the returned value is the default value (e.g. 0 in case of fundamental data types).

template<typename VT , bool TF>
const VT::ElementType blaze::min ( const DenseVector< VT, TF > &  dv)

Returns the smallest element of the dense vector.

Parameters
dvThe given dense vector.
Returns
The smallest dense vector element.

This function returns the smallest element of the given dense vector. This function can only be used for element types that support the smaller-than relationship. In case the vector currently has a size of 0, the returned value is the default value (e.g. 0 in case of fundamental data types).

template<typename T1 , bool TF1, typename T2 , bool TF2>
bool blaze::operator!= ( const DenseVector< T1, TF1 > &  lhs,
const DenseVector< T2, TF2 > &  rhs 
)
inline

Inequality operator for the comparison of two dense vectors.

Parameters
lhsThe left-hand side dense vector for the comparison.
rhsThe right-hand side dense vector for the comparison.
Returns
true if the two vectors are not equal, false if they are equal.
template<typename T1 , bool TF1, typename T2 , bool TF2>
bool blaze::operator!= ( const DenseVector< T1, TF1 > &  lhs,
const SparseVector< T2, TF2 > &  rhs 
)
inline

Inequality operator for the comparison of a dense vector and a sparse vector.

Parameters
lhsThe left-hand side dense vector for the comparison.
rhsThe right-hand side sparse vector for the comparison.
Returns
true if the two vectors are not equal, false if they are equal.
template<typename T1 , bool TF1, typename T2 , bool TF2>
bool blaze::operator!= ( const SparseVector< T1, TF1 > &  lhs,
const DenseVector< T2, TF2 > &  rhs 
)
inline

Inequality operator for the comparison of a sparse vector and a dense vector.

Parameters
lhsThe left-hand side sparse vector for the comparison.
rhsThe right-hand side dense vector for the comparison.
Returns
true if the two vectors are not equal, false if they are equal.
template<typename T1 , typename T2 , bool TF>
EnableIf< IsNumeric< T2 >, bool >::Type blaze::operator!= ( const DenseVector< T1, TF > &  vec,
T2  scalar 
)
inline

Inequality operator for the comparison of a dense vector and a scalar value.

Parameters
vecThe left-hand side dense vector for the comparison.
scalarThe right-hand side scalar value for the comparison.
Returns
true if at least one element of the vector is different from the scalar, false if not.

If one value of the vector is inequal to the scalar value, the inequality test returns true, otherwise false. Note that this function can only be used with built-in, numerical data types!

template<typename T1 , typename T2 , bool TF>
EnableIf< IsNumeric< T1 >, bool >::Type blaze::operator!= ( T1  scalar,
const DenseVector< T2, TF > &  vec 
)
inline

Inequality operator for the comparison of a scalar value and a dense vector.

Parameters
scalarThe left-hand side scalar value for the comparison.
vecThe right-hand side dense vector for the comparison.
Returns
true if at least one element of the vector is different from the scalar, false if not.

If one value of the vector is inequal to the scalar value, the inequality test returns true, otherwise false. Note that this function can only be used with built-in, numerical data types!

template<typename T1 , typename T2 >
const SVecSVecCrossExpr<T1,T2> blaze::operator% ( const SparseVector< T1, false > &  lhs,
const SparseVector< T2, false > &  rhs 
)
inline

Operator for the cross product of two sparse vectors ( $ \vec{a}=\vec{b} \times \vec{c} $).

Parameters
lhsThe left-hand side sparse vector for the cross product.
rhsThe right-hand side sparse vector for the cross product.
Returns
The cross product of the two sparse vectors.
Exceptions
std::invalid_argumentInvalid vector size for cross product.

This operator represents the cross product of two sparse vectors:

// ... Resizing and initialization
c = a % b;

The operator returns a dense vector of the higher-order element type of the two involved vector element types T1::ElementType and T2::ElementType. Both vector types T1 and T2 as well as the two element types T1::ElementType and T2::ElementType have to be supported by the CrossTrait class template.
In case the current sizes of the two given vectors don't match, a std::invalid_argument is thrown.

template<typename T1 , typename T2 >
const DVecDVecCrossExpr<T1,T2> blaze::operator% ( const DenseVector< T1, false > &  lhs,
const DenseVector< T2, false > &  rhs 
)
inline

Operator for the cross product of two dense vectors ( $ \vec{a}=\vec{b} \times \vec{c} $).

Parameters
lhsThe left-hand side dense vector for the cross product.
rhsThe right-hand side dense vector for the cross product.
Returns
The cross product of the two vectors.
Exceptions
std::invalid_argumentInvalid vector size for cross product.

This operator represents the cross product of two dense vectors:

blaze::DynamicVector<double> a( 3UL ), b( 3UL );
// ... Resizing and initialization
c = a % b;

The operator returns an expression representing a dense vector of the higher-order element type of the two involved vector element types T1::ElementType and T2::ElementType. Both vector types T1 and T2 as well as the two element types T1::ElementType and T2::ElementType have to be supported by the CrossTrait class template.
In case the current sizes of the two given vectors don't match, a std::invalid_argument is thrown.

template<typename T1 , typename T2 >
const DVecSVecCrossExpr<T1,T2> blaze::operator% ( const DenseVector< T1, false > &  lhs,
const SparseVector< T2, false > &  rhs 
)
inline

Operator for the cross product of a dense vector and a sparse vector ( $ \vec{a}=\vec{b} \times \vec{c} $).

Parameters
lhsThe left-hand side dense vector for the cross product.
rhsThe right-hand side sparse vector for the cross product.
Returns
The cross product of the two vectors.
Exceptions
std::invalid_argumentInvalid vector size for cross product.

This operator represents the cross product of a dense vector and a sparse vector:

// ... Resizing and initialization
c = a % b;

The operator returns an expression representing a dense vector of the higher-order element type of the two involved vector element types T1::ElementType and T2::ElementType. Both vector types T1 and T2 as well as the two element types T1::ElementType and T2::ElementType have to be supported by the CrossTrait class template.
In case the current sizes of the two given vectors don't match, a std::invalid_argument is thrown.

template<typename T1 , typename T2 >
const SVecDVecCrossExpr<T1,T2> blaze::operator% ( const SparseVector< T1, false > &  lhs,
const DenseVector< T2, false > &  rhs 
)
inline

Operator for the cross product of a sparse vector and a dense vector ( $ \vec{a}=\vec{b} \times \vec{c} $).

Parameters
lhsThe left-hand side sparse vector for the cross product.
rhsThe right-hand side dense vector for the cross product.
Returns
The cross product of the two vectors.
Exceptions
std::invalid_argumentInvalid vector size for cross product.

This operator represents the cross product of a sparse vector and a dense vector:

// ... Resizing and initialization
c = a % b;

The operator returns an expression representing a dense vector of the higher-order element type of the two involved vector element types T1::ElementType and T2::ElementType. Both vector types T1 and T2 as well as the two element types T1::ElementType and T2::ElementType have to be supported by the CrossTrait class template.
In case the current sizes of the two given vectors don't match, a std::invalid_argument is thrown.

template<typename T1 , typename T2 >
DisableIf< TDVecDVecMultExprHelper<T1,T2>, const typename MultTrait<typename T1::ElementType,typename T2::ElementType>::Type >::Type blaze::operator* ( const DenseVector< T1, true > &  lhs,
const DenseVector< T2, false > &  rhs 
)
inline

Default multiplication operator for the scalar product (inner product) of two dense vectors ( $ s=\vec{a}*\vec{b} $).

Parameters
lhsThe left-hand side dense vector for the inner product.
rhsThe right-hand side dense vector for the inner product.
Returns
The scalar product.
Exceptions
std::invalid_argumentVector sizes do not match.

This operator represents the scalar product (inner product) of two dense vectors:

blaze::double res;
// ... Resizing and initialization
res = trans(a) * b;

The operator returns a scalar value of the higher-order element type of the two involved vector element types T1::ElementType and T2::ElementType. Both vector types T1 and T2 as well as the two element types T1::ElementType and T2::ElementType have to be supported by the MultTrait class template.
In case the current sizes of the two given vectors don't match, a std::invalid_argument is thrown.

template<typename T1 , typename T2 >
const DisableIf< Or< IsSymmetric<T2>, IsMatMatMultExpr<T2> > , TSVecTDMatMultExpr<T1,T2> >::Type blaze::operator* ( const SparseVector< T1, true > &  vec,
const DenseMatrix< T2, true > &  mat 
)
inline

Multiplication operator for the multiplication of a transpose sparse vector and a column-major dense matrix ( $ \vec{y}^T=\vec{x}^T*A $).

Parameters
vecThe left-hand side transpose sparse vector for the multiplication.
matThe right-hand side column-major dense matrix for the multiplication.
Returns
The resulting transpose vector.
Exceptions
std::invalid_argumentVector and matrix sizes do not match.

This operator represents the multiplication between a transpose sparse vector and a column-major dense matrix:

The operator returns an expression representing a transpose sparse vector of the higher-order element type of the two involved element types T1::ElementType and T2::ElementType. Both the dense matrix type T1 and the dense vector type T2 as well as the two element types T1::ElementType and T2::ElementType have to be supported by the MultTrait class template.
In case the current size of the vector vec doesn't match the current number of rows of the matrix mat, a std::invalid_argument is thrown.

template<typename T1 , typename T2 >
const DisableIf< Or< IsSymmetric<T1>, IsMatMatMultExpr<T1> > , DMatSVecMultExpr<T1,T2> >::Type blaze::operator* ( const DenseMatrix< T1, false > &  mat,
const SparseVector< T2, false > &  vec 
)
inline

Multiplication operator for the multiplication of a row-major dense matrix and a sparse vector ( $ \vec{y}=A*\vec{x} $).

Parameters
matThe left-hand side row-major dense matrix for the multiplication.
vecThe right-hand side sparse vector for the multiplication.
Returns
The resulting vector.
Exceptions
std::invalid_argumentMatrix and vector sizes do not match.

This operator represents the multiplication between a row-major dense matrix and a sparse vector:

The operator returns an expression representing a dense vector of the higher-order element type of the two involved element types T1::ElementType and T2::ElementType. Both the dense matrix type T1 and the sparse vector type T2 as well as the two element types T1::ElementType and T2::ElementType have to be supported by the MultTrait class template.
In case the current size of the vector vec doesn't match the current number of columns of the matrix mat, a std::invalid_argument is thrown.

template<typename T1 , typename T2 >
const DisableIf< Or< IsSymmetric<T2>, IsMatMatMultExpr<T2> > , TDVecSMatMultExpr<T1,T2> >::Type blaze::operator* ( const DenseVector< T1, true > &  vec,
const SparseMatrix< T2, false > &  mat 
)
inline

Multiplication operator for the multiplication of a transpose dense vector and a row-major sparse matrix ( $ \vec{y}^T=\vec{x}^T*A $).

Parameters
vecThe left-hand side transpose dense vector for the multiplication.
matThe right-hand side row-major sparse matrix for the multiplication.
Returns
The resulting transpose vector.
Exceptions
std::invalid_argumentVector and matrix sizes do not match.

This operator represents the multiplication between a transpose dense vector and a row-major sparse matrix:

// ... Resizing and initialization
y = x * A;

The operator returns an expression representing a transpose dense vector of the higher-order element type of the two involved element types T1::ElementType and T2::ElementType. Both the sparse matrix type T1 and the dense vector type T2 as well as the two element types T1::ElementType and T2::ElementType have to be supported by the MultTrait class template.
In case the current size of the vector vec doesn't match the current number of rows of the matrix mat, a std::invalid_argument is thrown.

template<typename T1 , typename T2 >
const DisableIf< IsMatMatMultExpr<T1>, SMatDVecMultExpr<T1,T2> >::Type blaze::operator* ( const SparseMatrix< T1, false > &  mat,
const DenseVector< T2, false > &  vec 
)
inline

Multiplication operator for the multiplication of a row-major sparse matrix and a dense vector ( $ \vec{y}=A*\vec{x} $).

Parameters
matThe left-hand side row-major sparse matrix for the multiplication.
vecThe right-hand side dense vector for the multiplication.
Returns
The resulting vector.
Exceptions
std::invalid_argumentMatrix and vector sizes do not match.

This operator represents the multiplication between a row-major sparse matrix and a dense vector:

The operator returns an expression representing a dense vector of the higher-order element type of the two involved element types T1::ElementType and T2::ElementType. Both the sparse matrix type T1 and the dense vector type T2 as well as the two element types T1::ElementType and T2::ElementType have to be supported by the MultTrait class template.
In case the current size of the vector vec doesn't match the current number of columns of the matrix mat, a std::invalid_argument is thrown.

template<typename T1 , typename T2 >
const DisableIf< Or< IsSymmetric<T1>, IsMatMatMultExpr<T1> > , TSMatDVecMultExpr<T1,T2> >::Type blaze::operator* ( const SparseMatrix< T1, true > &  mat,
const DenseVector< T2, false > &  vec 
)
inline

Multiplication operator for the multiplication of a column-major sparse matrix and a dense vector ( $ \vec{y}=A*\vec{x} $).

Parameters
matThe left-hand side column-major sparse matrix for the multiplication.
vecThe right-hand side dense vector for the multiplication.
Returns
The resulting vector.
Exceptions
std::invalid_argumentMatrix and vector sizes do not match.

This operator represents the multiplication between a column-major sparse matrix and a dense vector:

The operator returns an expression representing a dense vector of the higher-order element type of the two involved element types T1::ElementType and T2::ElementType. Both the sparse matrix type T1 and the dense vector type T2 as well as the two element types T1::ElementType and T2::ElementType have to be supported by the MultTrait class template.
In case the current size of the vector vec doesn't match the current number of columns of the matrix mat, a std::invalid_argument is thrown.

template<typename T1 , bool SO, typename T2 >
const EnableIf< IsMatMatMultExpr<T1>, typename MultExprTrait<T1,T2>::Type >::Type blaze::operator* ( const SparseMatrix< T1, SO > &  mat,
const DenseVector< T2, false > &  vec 
)
inline

Multiplication operator for the multiplication of a sparse matrix-matrix multiplication expression and a dense vector ( $ \vec{y}=(A*B)*\vec{x} $).

Parameters
matThe left-hand side sparse matrix-matrix multiplication.
vecThe right-hand side dense vector for the multiplication.
Returns
The resulting vector.

This operator implements a performance optimized treatment of the multiplication of a sparse matrix-matrix multiplication expression and a dense vector. It restructures the expression $ \vec{y}=(A*B)*\vec{x} $ to the expression $ \vec{y}=A*(B*\vec{x}) $.

template<typename T1 , typename T2 , bool SO>
const EnableIf< IsMatMatMultExpr<T2>, typename MultExprTrait<T1,T2>::Type >::Type blaze::operator* ( const DenseVector< T1, true > &  vec,
const SparseMatrix< T2, SO > &  mat 
)
inline

Multiplication operator for the multiplication of a transpose dense vector and a sparse matrix-matrix multiplication expression ( $ \vec{y}^T=\vec{x}^T*(A*B) $).

Parameters
vecThe left-hand side dense vector for the multiplication.
matThe right-hand side sparse matrix-matrix multiplication.
Returns
The resulting vector.

This operator implements a performance optimized treatment of the multiplication of a dense vector and a sparse matrix-matrix multiplication expression. It restructures the expression $ \vec{y}^T=\vec{x}^T*(A*B) $ to the expression $ \vec{y}^T=(\vec{x}^T*A)*B $.

template<typename T1 , typename T2 , bool TF>
const EnableIf< IsNumeric<T2>, typename MultExprTrait<T1,T2>::Type >::Type blaze::operator* ( const DenseVector< T1, TF > &  vec,
T2  scalar 
)
inline

Multiplication operator for the multiplication of a dense vector and a scalar value ( $ \vec{a}=\vec{b}*s $).

Parameters
vecThe left-hand side dense vector for the multiplication.
scalarThe right-hand side scalar value for the multiplication.
Returns
The scaled result vector.

This operator represents the multiplication between a dense vector and a scalar value:

// ... Resizing and initialization
b = a * 1.25;

The operator returns an expression representing a dense vector of the higher-order element type of the involved data types T1::ElementType and T2. Both data types T1::ElementType and T2 have to be supported by the MultTrait class template. Note that this operator only works for scalar values of built-in data type.

template<typename T1 , typename T2 , bool TF>
const DVecDVecMultExpr<T1,T2,TF> blaze::operator* ( const DenseVector< T1, TF > &  lhs,
const DenseVector< T2, TF > &  rhs 
)
inline

Multiplication operator for the componentwise product of two dense vectors ( $ \vec{a}=\vec{b}*\vec{c} $).

Parameters
lhsThe left-hand side dense vector for the component product.
rhsThe right-hand side dense vector for the component product.
Returns
The product of the two vectors.
Exceptions
std::invalid_argumentVector sizes do not match.

This operator represents the component product of two dense vectors:

// ... Resizing and initialization
c = a * b;

The operator returns an expression representing a dense vector of the higher-order element type of the two involved vector element types T1::ElementType and T2::ElementType. Both vector types T1 and T2 as well as the two element types T1::ElementType and T2::ElementType have to be supported by the MultTrait class template.
In case the current sizes of the two given vectors don't match, a std::invalid_argument is thrown.

template<typename T1 , typename T2 , bool TF>
const EnableIf< IsNumeric<T1>, typename MultExprTrait<T1,T2>::Type >::Type blaze::operator* ( T1  scalar,
const DenseVector< T2, TF > &  vec 
)
inline

Multiplication operator for the multiplication of a scalar value and a dense vector ( $ \vec{a}=s*\vec{b} $).

Parameters
scalarThe left-hand side scalar value for the multiplication.
vecThe right-hand side vector for the multiplication.
Returns
The scaled result vector.

This operator represents the multiplication between a a scalar value and dense vector:

// ... Resizing and initialization
b = 1.25 * a;

The operator returns an expression representing a dense vector of the higher-order element type of the involved data types T1::ElementType and T2. Both data types T1 and T2::ElementType have to be supported by the MultTrait class template. Note that this operator only works for scalar values of built-in data type.

template<typename T1 , typename T2 >
const DisableIf< IsMatMatMultExpr<T1>, TDMatSVecMultExpr<T1,T2> >::Type blaze::operator* ( const DenseMatrix< T1, true > &  mat,
const SparseVector< T2, false > &  vec 
)
inline

Multiplication operator for the multiplication of a column-major dense matrix and a sparse vector ( $ \vec{y}=A*\vec{x} $).

Parameters
matThe left-hand side column-major dense matrix for the multiplication.
vecThe right-hand side sparse vector for the multiplication.
Returns
The resulting vector.
Exceptions
std::invalid_argumentMatrix and vector sizes do not match.

This operator represents the multiplication between a column-major dense matrix and a sparse vector:

The operator returns an expression representing a dense vector of the higher-order element type of the two involved element types T1::ElementType and T2::ElementType. Both the dense matrix type T1 and the sparse vector type T2 as well as the two element types T1::ElementType and T2::ElementType have to be supported by the MultTrait class template.
In case the current size of the vector vec doesn't match the current number of columns of the matrix mat, a std::invalid_argument is thrown.

template<typename T1 , typename T2 , bool SO>
const EnableIf< IsMatMatMultExpr<T2>, typename MultExprTrait<T1,T2>::Type >::Type blaze::operator* ( const SparseVector< T1, true > &  vec,
const DenseMatrix< T2, SO > &  mat 
)
inline

Multiplication operator for the multiplication of a transpose sparse vector and a dense matrix-matrix multiplication expression ( $ \vec{y}^T=\vec{x}^T*(A*B) $).

Parameters
vecThe left-hand side sparse vector for the multiplication.
matThe right-hand side dense matrix-matrix multiplication.
Returns
The resulting vector.

This operator implements a performance optimized treatment of the multiplication of a sparse vector and a dense matrix-matrix multiplication expression. It restructures the expression $ \vec{y}^T=\vec{x}^T*(A*B) $ to the expression $ \vec{y}^T=(\vec{x}^T*A)*B $.

template<typename T1 , typename T2 >
const DisableIf< IsMatMatMultExpr<T1>, TDMatDVecMultExpr<T1,T2> >::Type blaze::operator* ( const DenseMatrix< T1, true > &  mat,
const DenseVector< T2, false > &  vec 
)
inline

Multiplication operator for the multiplication of a column-major dense matrix and a dense vector ( $ \vec{y}=A*\vec{x} $).

Parameters
matThe left-hand side column-major dense matrix for the multiplication.
vecThe right-hand side dense vector for the multiplication.
Returns
The resulting vector.
Exceptions
std::invalid_argumentMatrix and vector sizes do not match.

This operator represents the multiplication between a column-major dense matrix and a dense vector:

The operator returns an expression representing a dense vector of the higher-order element type of the two involved element types T1::ElementType and T2::ElementType. Both the dense matrix type T1 and the dense vector type T2 as well as the two element types T1::ElementType and T2::ElementType have to be supported by the MultTrait class template.
In case the current size of the vector vec doesn't match the current number of columns of the matrix mat, a std::invalid_argument is thrown.

template<typename T1 , typename T2 >
const DisableIf< IsMatMatMultExpr<T2>, TDVecDMatMultExpr<T1,T2> >::Type blaze::operator* ( const DenseVector< T1, true > &  vec,
const DenseMatrix< T2, false > &  mat 
)
inline

Multiplication operator for the multiplication of a transpose dense vector and a row-major dense matrix ( $ \vec{y}^T=\vec{x}^T*A $).

Parameters
vecThe left-hand side transpose dense vector for the multiplication.
matThe right-hand side row-major dense matrix for the multiplication.
Returns
The resulting transpose vector.
Exceptions
std::invalid_argumentVector and matrix sizes do not match.

This operator represents the multiplication between a transpose dense vector and a row-major dense matrix:

// ... Resizing and initialization
y = x * A;

The operator returns an expression representing a transpose dense vector of the higher-order element type of the two involved element types T1::ElementType and T2::ElementType. Both the dense matrix type T1 and the dense vector type T2 as well as the two element types T1::ElementType and T2::ElementType have to be supported by the MultTrait class template.
In case the current size of the vector vec doesn't match the current number of rows of the matrix mat, a std::invalid_argument is thrown.

template<typename T1 , typename T2 , bool SO>
const EnableIf< IsMatMatMultExpr<T2>, typename MultExprTrait<T1,T2>::Type >::Type blaze::operator* ( const DenseVector< T1, true > &  vec,
const DenseMatrix< T2, SO > &  mat 
)
inline

Multiplication operator for the multiplication of a transpose dense vector and a dense matrix-matrix multiplication expression ( $ \vec{y}^T=\vec{x}^T*(A*B) $).

Parameters
vecThe left-hand side dense vector for the multiplication.
matThe right-hand side dense matrix-matrix multiplication.
Returns
The resulting vector.

This operator implements a performance optimized treatment of the multiplication of a dense vector and a dense matrix-matrix multiplication expression. It restructures the expression $ \vec{y}^T=\vec{x}^T*(A*B) $ to the expression $ \vec{y}^T=(\vec{x}^T*A)*B $.

template<typename T1 , typename T2 >
const DisableIf< IsMatMatMultExpr<T1>, DMatDVecMultExpr<T1,T2> >::Type blaze::operator* ( const DenseMatrix< T1, false > &  mat,
const DenseVector< T2, false > &  vec 
)
inline

Multiplication operator for the multiplication of a row-major dense matrix and a dense vector ( $ \vec{y}=A*\vec{x} $).

Parameters
matThe left-hand side row-major dense matrix for the multiplication.
vecThe right-hand side dense vector for the multiplication.
Returns
The resulting vector.
Exceptions
std::invalid_argumentMatrix and vector sizes do not match.

This operator represents the multiplication between a row-major dense matrix and a dense vector:

The operator returns an expression representing a dense vector of the higher-order element type of the two involved element types T1::ElementType and T2::ElementType. Both the dense matrix type T1 and the dense vector type T2 as well as the two element types T1::ElementType and T2::ElementType have to be supported by the MultTrait class template.
In case the current size of the vector vec doesn't match the current number of columns of the matrix mat, a std::invalid_argument is thrown.

template<typename T1 , bool SO, typename T2 >
const EnableIf< IsMatMatMultExpr<T1>, typename MultExprTrait<T1,T2>::Type >::Type blaze::operator* ( const DenseMatrix< T1, SO > &  mat,
const DenseVector< T2, false > &  vec 
)
inline

Multiplication operator for the multiplication of a dense matrix-matrix multiplication expression and a dense vector ( $ \vec{y}=(A*B)*\vec{x} $).

Parameters
matThe left-hand side dense matrix-matrix multiplication.
vecThe right-hand side dense vector for the multiplication.
Returns
The resulting vector.

This operator implements a performance optimized treatment of the multiplication of a dense matrix-matrix multiplication expression and a dense vector. It restructures the expression $ \vec{x}=(A*B)*\vec{x} $ to the expression $ \vec{y}=A*(B*\vec{x}) $.

template<typename T1 , typename T2 , bool TF>
const DVecSVecAddExpr<T1,T2,TF> blaze::operator+ ( const DenseVector< T1, TF > &  lhs,
const SparseVector< T2, TF > &  rhs 
)
inline

Addition operator for the addition of a dense vector and a sparse vector ( $ \vec{a}=\vec{b}+\vec{c} $).

Parameters
lhsThe left-hand side dense vector for the vector addition.
rhsThe right-hand side sparse vector for the vector addition.
Returns
The sum of the two vectors.
Exceptions
std::invalid_argumentVector sizes do not match.

This operator represents the addition of a dense vector and a sparse vector:

// ... Resizing and initialization
c = a + b;

The operator returns an expression representing a dense vector of the higher-order element type of the two involved vector element types T1::ElementType and T2::ElementType. Both vector types T1 and T2 as well as the two element types T1::ElementType and T2::ElementType have to be supported by the AddTrait class template.
In case the current sizes of the two given vectors don't match, a std::invalid_argument is thrown.

template<typename T1 , typename T2 , bool TF>
const DVecSVecAddExpr<T2,T1,TF> blaze::operator+ ( const SparseVector< T1, TF > &  lhs,
const DenseVector< T2, TF > &  rhs 
)
inline

Addition operator for the addition of a sparse vector and a dense vector ( $ \vec{a}=\vec{b}+\vec{c} $).

Parameters
lhsThe left-hand side sparse vector for the vector addition.
rhsThe right-hand side dense vector for the vector addition.
Returns
The sum of the two vectors.
Exceptions
std::invalid_argumentVector sizes do not match.

This operator represents the addition of a sparse vector and a dense vector:

// ... Resizing and initialization
c = a + b;

The operator returns an expression representing a dense vector of the higher-order element type of the two involved vector element types T1::ElementType and T2::ElementType. Both vector types T1 and T2 as well as the two element types T1::ElementType and T2::ElementType have to be supported by the AddTrait class template.
In case the current sizes of the two given vectors don't match, a std::invalid_argument is thrown.

template<typename T1 , typename T2 , bool TF>
const DVecDVecAddExpr<T1,T2,TF> blaze::operator+ ( const DenseVector< T1, TF > &  lhs,
const DenseVector< T2, TF > &  rhs 
)
inline

Addition operator for the addition of two dense vectors ( $ \vec{a}=\vec{b}+\vec{c} $).

Parameters
lhsThe left-hand side dense vector for the vector addition.
rhsThe right-hand side dense vector for the vector addition.
Returns
The sum of the two vectors.
Exceptions
std::invalid_argumentVector sizes do not match.

This operator represents the addition of two dense vectors:

// ... Resizing and initialization
c = a + b;

The operator returns an expression representing a dense vector of the higher-order element type of the two involved vector element types T1::ElementType and T2::ElementType. Both vector types T1 and T2 as well as the two element types T1::ElementType and T2::ElementType have to be supported by the AddTrait class template.
In case the current sizes of the two given vectors don't match, a std::invalid_argument is thrown.

template<typename T1 , typename T2 , bool TF>
const SVecDVecSubExpr<T1,T2,TF> blaze::operator- ( const SparseVector< T1, TF > &  lhs,
const DenseVector< T2, TF > &  rhs 
)
inline

Subtraction operator for the subtraction of a sparse vector and a dense vector ( $ \vec{a}=\vec{b}-\vec{c} $).

Parameters
lhsThe left-hand side sparse vector for the vector subtraction.
rhsThe right-hand side dense vector to be subtracted from the sparse vector.
Returns
The difference of the two vectors.
Exceptions
std::invalid_argumentVector sizes do not match.

This operator represents the subtraction of a sparse vector and a dense vector:

// ... Resizing and initialization
c = a - b;

The operator returns an expression representing a dense vector of the higher-order element type of the two involved vector element types T1::ElementType and T2::ElementType. Both vector types T1 and T2 as well as the two element types T1::ElementType and T2::ElementType have to be supported by the SubTrait class template.
In case the current sizes of the two given vectors don't match, a std::invalid_argument is thrown.

template<typename T1 , typename T2 , bool TF>
const DVecSVecSubExpr<T1,T2,TF> blaze::operator- ( const DenseVector< T1, TF > &  lhs,
const SparseVector< T2, TF > &  rhs 
)
inline

Subtraction operator for the subtraction of a dense vector and a sparse vector ( $ \vec{a}=\vec{b}-\vec{c} $).

Parameters
lhsThe left-hand side dense vector for the vector subtraction.
rhsThe right-hand side sparse vector to be subtracted from the dense vector.
Returns
The difference of the two vectors.
Exceptions
std::invalid_argumentVector sizes do not match.

This operator represents the subtraction of a dense vector and a sparse vector:

// ... Resizing and initialization
c = a - b;

The operator returns an expression representing a dense vector of the higher-order element type of the two involved vector element types T1::ElementType and T2::ElementType. Both vector types T1 and T2 as well as the two element types T1::ElementType and T2::ElementType have to be supported by the SubTrait class template.
In case the current sizes of the two given vectors don't match, a std::invalid_argument is thrown.

template<typename VT , bool TF>
const DVecScalarMultExpr<VT,typename BaseElementType<VT>::Type,TF> blaze::operator- ( const DenseVector< VT, TF > &  dv)
inline

Unary minus operator for the negation of a dense vector ( $ \vec{a} = -\vec{b} $).

Parameters
dvThe dense vector to be negated.
Returns
The negation of the vector.

This operator represents the negation of a dense vector:

// ... Resizing and initialization
b = -a;

The operator returns an expression representing the negation of the given dense vector.

template<typename T1 , typename T2 , bool TF>
const DVecDVecSubExpr<T1,T2,TF> blaze::operator- ( const DenseVector< T1, TF > &  lhs,
const DenseVector< T2, TF > &  rhs 
)
inline

Subtraction operator for the subtraction of two dense vectors ( $ \vec{a}=\vec{b}-\vec{c} $).

Parameters
lhsThe left-hand side dense vector for the vector subtraction.
rhsThe right-hand side dense vector to be subtracted from the vector.
Returns
The difference of the two vectors.
Exceptions
std::invalid_argumentVector sizes do not match.

This operator represents the subtraction of two dense vectors:

// ... Resizing and initialization
c = a - b;

The operator returns an expression representing a dense vector of the higher-order element type of the two involved vector element types T1::ElementType and T2::ElementType. Both vector types T1 and T2 as well as the two element types T1::ElementType and T2::ElementType have to be supported by the SubTrait class template.
In case the current sizes of the two given vectors don't match, a std::invalid_argument is thrown.

template<typename T1 , typename T2 , bool TF>
const EnableIf< IsNumeric<T2>, typename DivExprTrait<T1,T2>::Type >::Type blaze::operator/ ( const DenseVector< T1, TF > &  vec,
T2  scalar 
)
inline

Division operator for the divison of a dense vector by a scalar value ( $ \vec{a}=\vec{b}/s $).

Parameters
vecThe left-hand side dense vector for the division.
scalarThe right-hand side scalar value for the division.
Returns
The scaled result vector.

This operator represents the division of a dense vector by a scalar value:

// ... Resizing and initialization
b = a / 0.24;

The operator returns an expression representing a dense vector of the higher-order element type of the involved data types T1::ElementType and T2. Both data types T1::ElementType and T2 have to be supported by the DivTrait class template. Note that this operator only works for scalar values of built-in data type.

Note: A division by zero is only checked by an user assert.

template<typename T1 , bool TF1, typename T2 , bool TF2>
bool blaze::operator== ( const DenseVector< T1, TF1 > &  lhs,
const DenseVector< T2, TF2 > &  rhs 
)
inline

Equality operator for the comparison of two dense vectors.

Parameters
lhsThe left-hand side dense vector for the comparison.
rhsThe right-hand side dense vector for the comparison.
Returns
true if the two vectors are equal, false if not.
template<typename T1 , bool TF1, typename T2 , bool TF2>
bool blaze::operator== ( const DenseVector< T1, TF1 > &  lhs,
const SparseVector< T2, TF2 > &  rhs 
)
inline

Equality operator for the comparison of a dense vector and a sparse vector.

Parameters
lhsThe left-hand side dense vector for the comparison.
rhsThe right-hand side sparse vector for the comparison.
Returns
true if the two vectors are equal, false if not.
template<typename T1 , bool TF1, typename T2 , bool TF2>
bool blaze::operator== ( const SparseVector< T1, TF1 > &  lhs,
const DenseVector< T2, TF2 > &  rhs 
)
inline

Equality operator for the comparison of a sparse vector and a dense vector.

Parameters
lhsThe left-hand side sparse vector for the comparison.
rhsThe right-hand side dense vector for the comparison.
Returns
true if the two vectors are equal, false if not.
template<typename T1 , typename T2 , bool TF>
EnableIf< IsNumeric< T2 >, bool >::Type blaze::operator== ( const DenseVector< T1, TF > &  vec,
T2  scalar 
)
inline

Equality operator for the comparison of a dense vector and a scalar value.

Parameters
vecThe left-hand side dense vector for the comparison.
scalarThe right-hand side scalar value for the comparison.
Returns
true if all elements of the vector are equal to the scalar, false if not.

If all values of the vector are equal to the scalar value, the equality test returns true, otherwise false. Note that this function can only be used with built-in, numerical data types!

template<typename T1 , typename T2 , bool TF>
EnableIf< IsNumeric< T1 >, bool >::Type blaze::operator== ( T1  scalar,
const DenseVector< T2, TF > &  vec 
)
inline

Equality operator for the comparison of a scalar value and a dense vector.

Parameters
scalarThe left-hand side scalar value for the comparison.
vecThe right-hand side dense vector for the comparison.
Returns
true if all elements of the vector are equal to the scalar, false if not.

If all values of the vector are equal to the scalar value, the equality test returns true, otherwise false. Note that this function can only be used with built-in, numerical data types!

template<typename VT , bool TF>
const DVecSerialExpr< VT, TF > blaze::serial ( const DenseVector< VT, TF > &  dv)
inline

Forces the serial evaluation of the given dense vector expression dv.

Parameters
dvThe input vector.
Returns
The evaluated dense vector.

The serial function forces the serial evaluation of the given dense vector expression dv. The function returns an expression representing this operation.
The following example demonstrates the use of the serial function:

// ... Resizing and initialization
b = serial( a );
template<typename VT , bool TF>
const VT::ElementType blaze::sqrLength ( const DenseVector< VT, TF > &  dv)

Calculation of the dense vector square length $|\vec{a}|^2$.

Parameters
dvThe given dense vector.
Returns
The square length of the dense vector.

This function calculates the actual square length of the dense vector.

Note: This operation is only defined for numeric data types. In case the element type is not a numeric data type (i.e. a user defined data type or boolean) the attempt to use the sqrLength() function results in a compile time error!

template<typename VT , bool TF>
const DVecTransExpr< VT,!TF > blaze::trans ( const DenseVector< VT, TF > &  dv)
inline

Calculation of the transpose of the given dense vector.

Parameters
dvThe dense vector to be transposed.
Returns
The transpose of the dense vector.

This function returns an expression representing the transpose of the given dense vector:

Friends

template<typename VT , typename MT >
template<typename VT2 >
void addAssign ( DenseVector< VT2, true > &  lhs,
const TDVecSMatMultExpr< VT, MT > &  rhs 
)
friend

Addition assignment of a transpose dense vector-sparse matrix multiplication to a dense vector ( $ \vec{y}^T+=\vec{x}^T*A $).

Parameters
lhsThe target left-hand side dense vector.
rhsThe right-hand side multiplication expression to be added.
Returns
void

This function implements the performance optimized addition assignment of a transpose dense vector-sparse matrix multiplication expression to a dense vector.

template<typename VT , typename MT >
template<typename VT2 >
EnableIf< UseAssign<VT2> >::Type addAssign ( DenseVector< VT2, true > &  lhs,
const TDVecTSMatMultExpr< VT, MT > &  rhs 
)
friend

Addition assignment of a transpose dense vector-transpose sparse matrix multiplication to a dense vector ( $ \vec{y}^T+=\vec{x}^T*A $).

Parameters
lhsThe target left-hand side dense vector.
rhsThe right-hand side multiplication expression to be added.
Returns
void

This function implements the performance optimized addition assignment of a transpose dense vector-transpose sparse matrix multiplication expression to a dense vector. Due to the explicit application of the SFINAE principle, this function can only be selected by the compiler in case either the left-hand side vector operand is a compound expression or the right-hand side matrix operand requires an intermediate evaluation.

template<typename VT , typename MT >
template<typename VT2 >
EnableIf< UseAssign<VT2> >::Type addAssign ( DenseVector< VT2, true > &  lhs,
const TSVecTDMatMultExpr< VT, MT > &  rhs 
)
friend

Addition assignment of a transpose sparse vector-transpose dense matrix multiplication to a dense vector ( $ \vec{y}^T+=\vec{x}^T*A $).

Parameters
lhsThe target left-hand side dense vector.
rhsThe right-hand side multiplication expression to be added.
Returns
void

This function implements the performance optimized addition assignment of a transpose sparse vector-transpose dense matrix multiplication expression to a dense vector. Due to the explicit application of the SFINAE principle, this function can only be selected by the compiler in case either the left-hand side matrix operand requires an intermediate evaluation or the right-hand side vector operand is a compound expression.

template<typename VT , typename MT >
template<typename VT2 >
void addAssign ( DenseVector< VT2, true > &  lhs,
const TSVecDMatMultExpr< VT, MT > &  rhs 
)
friend

Addition assignment of a transpose sparse vector-dense matrix multiplication to a dense vector ( $ \vec{y}^T+=\vec{x}^T*A $).

Parameters
lhsThe target left-hand side dense vector.
rhsThe right-hand side multiplication expression to be added.
Returns
void

This function implements the performance optimized addition assignment of a transpose sparse vector-dense matrix multiplication expression to a dense vector.

template<typename VT , typename MT >
template<typename VT2 >
void assign ( DenseVector< VT2, true > &  lhs,
const TDVecSMatMultExpr< VT, MT > &  rhs 
)
friend

Assignment of a transpose dense vector-sparse matrix multiplication to a dense vector ( $ \vec{y}^T=\vec{x}^T*A $).

Parameters
lhsThe target left-hand side dense vector.
rhsThe right-hand side multiplication expression to be assigned.
Returns
void

This function implements the performance optimized assignment of a transpose dense vector- sparse matrix multiplication expression to a dense vector.

template<typename VT , typename MT >
template<typename VT2 >
EnableIf< UseAssign<VT2> >::Type assign ( DenseVector< VT2, true > &  lhs,
const TDVecTSMatMultExpr< VT, MT > &  rhs 
)
friend

Assignment of a transpose dense vector-transpose sparse matrix multiplication to a dense vector ( $ \vec{y}^T=\vec{x}^T*A $).

Parameters
lhsThe target left-hand side dense vector.
rhsThe right-hand side multiplication expression to be assigned.
Returns
void

This function implements the performance optimized assignment of a transpose dense vector- transpose sparse matrix multiplication expression to a dense vector. Due to the explicit application of the SFINAE principle, this function can only be selected by the compiler in case either the left-hand side vector operand is a compound expression or the right-hand side matrix operand requires an intermediate evaluation.

template<typename VT , typename MT >
template<typename VT2 >
void assign ( SparseVector< VT2, true > &  lhs,
const TDVecSMatMultExpr< VT, MT > &  rhs 
)
friend

Assignment of a transpose dense vector-sparse matrix multiplication to a sparse vector ( $ \vec{y}^T=\vec{x}^T*A $).

Parameters
lhsThe target left-hand side sparse vector.
rhsThe right-hand side multiplication expression to be assigned.
Returns
void

This function implements the performance optimized assignment of a transpose dense vector- sparse matrix multiplication expression to a sparse vector.

template<typename VT , typename MT >
template<typename VT2 >
EnableIf< UseAssign<VT2> >::Type assign ( SparseVector< VT2, true > &  lhs,
const TDVecTSMatMultExpr< VT, MT > &  rhs 
)
friend

Assignment of a transpose dense vector-transpose sparse matrix multiplication to a sparse vector ( $ \vec{y}^T=\vec{x}^T*A $).

Parameters
lhsThe target left-hand side sparse vector.
rhsThe right-hand side multiplication expression to be assigned.
Returns
void

This function implements the performance optimized assignment of a transpose dense vector- transpose sparse matrix multiplication expression to a sparse vector. Due to the explicit application of the SFINAE principle, this function can only be selected by the compiler in case either the left-hand side vector operand is a compound expression or the right-hand side matrix operand requires an intermediate evaluation.

template<typename VT , typename MT >
template<typename VT2 >
EnableIf< UseAssign<VT2> >::Type multAssign ( DenseVector< VT2, true > &  lhs,
const TDVecTSMatMultExpr< VT, MT > &  rhs 
)
friend

Multiplication assignment of a transpose dense vector-transpose sparse matrix multiplication to a dense vector ( $ \vec{y}^T*=\vec{x}^T*A $).

Parameters
lhsThe target left-hand side dense vector.
rhsThe right-hand side multiplication expression to be multiplied.
Returns
void

This function implements the performance optimized multiplication assignment of a transpose dense vector-transpose sparse matrix multiplication expression to a dense vector. Due to the explicit application of the SFINAE principle, this function can only be selected by the compiler in case either the left-hand side vector operand is a compound expression or the right-hand side matrix operand requires an intermediate evaluation.

template<typename VT , typename MT >
template<typename VT2 >
EnableIf< UseAssign<VT2> >::Type multAssign ( DenseVector< VT2, true > &  lhs,
const TSVecTDMatMultExpr< VT, MT > &  rhs 
)
friend

Multiplication assignment of a transpose sparse vector-transpose dense matrix multiplication to a dense vector ( $ \vec{y}^T*=\vec{x}^T*A $).

Parameters
lhsThe target left-hand side dense vector.
rhsThe right-hand side multiplication expression to be multiplied.
Returns
void

This function implements the performance optimized multiplication assignment of a transpose sparse vector-transpose dense matrix multiplication expression to a dense vector. Due to the explicit application of the SFINAE principle, this function can only be selected by the compiler in case either the left-hand side matrix operand requires an intermediate evaluation or the right-hand side vector operand is a compound expression.

template<typename VT , typename MT >
template<typename VT2 >
void multAssign ( DenseVector< VT2, true > &  lhs,
const TDVecSMatMultExpr< VT, MT > &  rhs 
)
friend

Multiplication assignment of a transpose dense vector-sparse matrix multiplication to a dense vector ( $ \vec{y}^T*=\vec{x}^T*A $).

Parameters
lhsThe target left-hand side dense vector.
rhsThe right-hand side multiplication expression to be multiplied.
Returns
void

This function implements the performance optimized multiplication assignment of a transpose dense vector-sparse matrix multiplication expression to a dense vector.

template<typename VT , typename MT >
template<typename VT2 >
void multAssign ( DenseVector< VT2, true > &  lhs,
const TSVecDMatMultExpr< VT, MT > &  rhs 
)
friend

Multiplication assignment of a transpose sparse vector-dense matrix multiplication to a dense vector ( $ \vec{y}^T*=\vec{x}^T*A $).

Parameters
lhsThe target left-hand side dense vector.
rhsThe right-hand side multiplication expression to be multiplied.
Returns
void

This function implements the performance optimized multiplication assignment of a transpose sparse vector-dense matrix multiplication expression to a dense vector.

template<typename VT , typename MT >
template<typename VT2 >
EnableIf< UseSMPAssign<VT2> >::Type smpAddAssign ( DenseVector< VT2, true > &  lhs,
const TDVecTSMatMultExpr< VT, MT > &  rhs 
)
friend

SMP addition assignment of a transpose dense vector-transpose sparse matrix multiplication to a dense vector ( $ \vec{y}^T+=\vec{x}^T*A $).

Parameters
lhsThe target left-hand side dense vector.
rhsThe right-hand side multiplication expression to be added.
Returns
void

This function implements the performance optimized SMP addition assignment of a transpose dense vector-transpose sparse matrix multiplication expression to a dense vector. Due to the explicit application of the SFINAE principle, this function can only be selected by the compiler in case the expression specific parallel evaluation strategy is selected.

template<typename VT , typename MT >
template<typename VT2 >
EnableIf< UseSMPAssign<VT2> >::Type smpAddAssign ( DenseVector< VT2, true > &  lhs,
const TSVecTDMatMultExpr< VT, MT > &  rhs 
)
friend

SMP addition assignment of a transpose sparse vector-transpose dense matrix multiplication to a dense vector ( $ \vec{y}^T+=\vec{x}^T*A $).

Parameters
lhsThe target left-hand side dense vector.
rhsThe right-hand side multiplication expression to be added.
Returns
void

This function implements the performance optimized SMP addition assignment of a transpose sparse vector-transpose dense matrix multiplication expression to a dense vector. Due to the explicit application of the SFINAE principle, this function can only be selected by the compiler in case the expression specific parallel evaluation strategy is selected.

template<typename VT , typename MT >
template<typename VT2 >
EnableIf< UseSMPAssign<VT2> >::Type smpAddAssign ( DenseVector< VT2, true > &  lhs,
const TDVecSMatMultExpr< VT, MT > &  rhs 
)
friend

Addition assignment of a transpose dense vector-sparse matrix multiplication to a dense vector ( $ \vec{y}^T+=\vec{x}^T*A $).

Parameters
lhsThe target left-hand side dense vector.
rhsThe right-hand side multiplication expression to be added.
Returns
void

This function implements the performance optimized SMP addition assignment of a transpose dense vector-sparse matrix multiplication expression to a dense vector. Due to the explicit application of the SFINAE principle, this function can only be selected by the compiler in case the expression specific parallel evaluation strategy is selected.

template<typename VT , typename MT >
template<typename VT2 >
EnableIf< UseSMPAssign<VT2> >::Type smpAddAssign ( DenseVector< VT2, true > &  lhs,
const TSVecDMatMultExpr< VT, MT > &  rhs 
)
friend

SMP addition assignment of a transpose sparse vector-dense matrix multiplication to a dense vector ( $ \vec{y}^T+=\vec{x}^T*A $).

Parameters
lhsThe target left-hand side dense vector.
rhsThe right-hand side multiplication expression to be added.
Returns
void

This function implements the performance optimized SMP addition assignment of a transpose sparse vector-dense matrix multiplication expression to a dense vector. Due to the explicit application of the SFINAE principle, this function can only be selected by the compiler in case the expression specific parallel evaluation strategy is selected.

template<typename VT , typename MT >
template<typename VT2 >
EnableIf< UseSMPAssign<VT2> >::Type smpAssign ( DenseVector< VT2, true > &  lhs,
const TDVecTSMatMultExpr< VT, MT > &  rhs 
)
friend

SMP assignment of a transpose dense vector-transpose sparse matrix multiplication to a dense vector ( $ \vec{y}^T=\vec{x}^T*A $).

Parameters
lhsThe target left-hand side dense vector.
rhsThe right-hand side multiplication expression to be assigned.
Returns
void

This function implements the performance optimized SMP assignment of a transpose dense vector-transpose sparse matrix multiplication expression to a dense vector. Due to the explicit application of the SFINAE principle, this function can only be selected by the compiler in case the expression specific parallel evaluation strategy is selected.

template<typename VT , typename MT >
template<typename VT2 >
EnableIf< UseSMPAssign<VT2> >::Type smpAssign ( SparseVector< VT2, true > &  lhs,
const TDVecTSMatMultExpr< VT, MT > &  rhs 
)
friend

SMP assignment of a transpose dense vector-transpose sparse matrix multiplication to a sparse vector ( $ \vec{y}^T=\vec{x}^T*A $).

Parameters
lhsThe target left-hand side sparse vector.
rhsThe right-hand side multiplication expression to be assigned.
Returns
void

This function implements the performance optimized SMP assignment of a transpose dense vector-transpose sparse matrix multiplication expression to a sparse vector. Due to the explicit application of the SFINAE principle, this function can only be selected by the compiler in case the expression specific parallel evaluation strategy is selected.

template<typename VT , typename MT >
template<typename VT2 >
EnableIf< UseSMPAssign<VT2> >::Type smpAssign ( DenseVector< VT2, true > &  lhs,
const TDVecSMatMultExpr< VT, MT > &  rhs 
)
friend

SMP assignment of a transpose dense vector-sparse matrix multiplication to a dense vector ( $ \vec{y}^T=\vec{x}^T*A $).

Parameters
lhsThe target left-hand side dense vector.
rhsThe right-hand side multiplication expression to be assigned.
Returns
void

This function implements the performance optimized SMP assignment of a transpose dense vector-sparse matrix multiplication expression to a dense vector. Due to the explicit application of the SFINAE principle, this function can only be selected by the compiler in case the expression specific parallel evaluation strategy is selected.

template<typename VT , typename MT >
template<typename VT2 >
EnableIf< UseSMPAssign<VT2> >::Type smpAssign ( SparseVector< VT2, true > &  lhs,
const TDVecSMatMultExpr< VT, MT > &  rhs 
)
friend

SMP assignment of a transpose dense vector-sparse matrix multiplication to a sparse vector ( $ \vec{y}^T=\vec{x}^T*A $).

Parameters
lhsThe target left-hand side sparse vector.
rhsThe right-hand side multiplication expression to be assigned.
Returns
void

This function implements the performance optimized SMP assignment of a transpose dense vector-sparse matrix multiplication expression to a sparse vector. Due to the explicit application of the SFINAE principle, this function can only be selected by the compiler in case the expression specific parallel evaluation strategy is selected.

template<typename VT , typename MT >
template<typename VT2 >
EnableIf< UseSMPAssign<VT2> >::Type smpMultAssign ( DenseVector< VT2, true > &  lhs,
const TDVecTSMatMultExpr< VT, MT > &  rhs 
)
friend

SMP multiplication assignment of a transpose dense vector-transpose sparse matrix multiplication to a dense vector ( $ \vec{y}^T*=\vec{x}^T*A $).

Parameters
lhsThe target left-hand side dense vector.
rhsThe right-hand side multiplication expression to be multiplied.
Returns
void

This function implements the performance optimized SMP multiplication assignment of a transpose dense vector-transpose sparse matrix multiplication expression to a dense vector. Due to the explicit application of the SFINAE principle, this function can only be selected by the compiler in case the expression specific parallel evaluation strategy is selected.

template<typename VT , typename MT >
template<typename VT2 >
EnableIf< UseSMPAssign<VT2> >::Type smpMultAssign ( DenseVector< VT2, true > &  lhs,
const TSVecTDMatMultExpr< VT, MT > &  rhs 
)
friend

SMP multiplication assignment of a transpose sparse vector-transpose dense matrix multiplication to a dense vector ( $ \vec{y}^T*=\vec{x}^T*A $).

Parameters
lhsThe target left-hand side dense vector.
rhsThe right-hand side multiplication expression to be multiplied.
Returns
void

This function implements the performance optimized SMP multiplication assignment of a transpose sparse vector-transpose dense matrix multiplication expression to a dense vector. Due to the explicit application of the SFINAE principle, this function can only be selected by the compiler in case the expression specific parallel evaluation strategy is selected.

template<typename VT , typename MT >
template<typename VT2 >
EnableIf< UseSMPAssign<VT2> >::Type smpMultAssign ( DenseVector< VT2, true > &  lhs,
const TDVecSMatMultExpr< VT, MT > &  rhs 
)
friend

SMP multiplication assignment of a transpose dense vector-sparse matrix multiplication to a dense vector ( $ \vec{y}^T*=\vec{x}^T*A $).

Parameters
lhsThe target left-hand side dense vector.
rhsThe right-hand side multiplication expression to be multiplied.
Returns
void

This function implements the performance optimized SMP multiplication assignment of a transpose dense vector-sparse matrix multiplication expression to a dense vector. Due to the explicit application of the SFINAE principle, this function can only be selected by the compiler in case the expression specific parallel evaluation strategy is selected.

template<typename VT , typename MT >
template<typename VT2 >
EnableIf< UseSMPAssign<VT2> >::Type smpMultAssign ( DenseVector< VT2, true > &  lhs,
const TSVecDMatMultExpr< VT, MT > &  rhs 
)
friend

SMP multiplication assignment of a transpose sparse vector-dense matrix multiplication to a dense vector ( $ \vec{y}^T*=\vec{x}^T*A $).

Parameters
lhsThe target left-hand side dense vector.
rhsThe right-hand side multiplication expression to be multiplied.
Returns
void

This function implements the performance optimized SMP multiplication assignment of a transpose sparse vector-dense matrix multiplication expression to a dense vector. Due to the explicit application of the SFINAE principle, this function can only be selected by the compiler in case the expression specific parallel evaluation strategy is selected.

template<typename VT , typename MT >
template<typename VT2 >
EnableIf< UseSMPAssign<VT2> >::Type smpSubAssign ( DenseVector< VT2, true > &  lhs,
const TDVecTSMatMultExpr< VT, MT > &  rhs 
)
friend

SMP subtraction assignment of a transpose dense vector-transpose sparse matrix multiplication to a dense vector ( $ \vec{y}^T-=\vec{x}^T*A $).

Parameters
lhsThe target left-hand side dense vector.
rhsThe right-hand side multiplication expression to be subtracted.
Returns
void

This function implements the performance optimized SMP subtraction assignment of a transpose dense vector-transpose sparse matrix multiplication expression to a dense vector. Due to the explicit application of the SFINAE principle, this function can only be selected by the compiler in case the expression specific parallel evaluation strategy is selected.

template<typename VT , typename MT >
template<typename VT2 >
EnableIf< UseSMPAssign<VT2> >::Type smpSubAssign ( DenseVector< VT2, true > &  lhs,
const TSVecTDMatMultExpr< VT, MT > &  rhs 
)
friend

SMP subtraction assignment of a transpose sparse vector-transpose dense matrix multiplication to a dense vector ( $ \vec{y}^T-=\vec{x}^T*A $).

Parameters
lhsThe target left-hand side dense vector.
rhsThe right-hand side multiplication expression to be subtracted.
Returns
void

This function implements the performance optimized SMP subtraction assignment of a transpose sparse vector-transpose dense matrix multiplication expression to a dense vector. Due to the explicit application of the SFINAE principle, this function can only be selected by the the compiler in case the expression specific parallel evaluation strategy is selected.

template<typename VT , typename MT >
template<typename VT2 >
EnableIf< UseSMPAssign<VT2> >::Type smpSubAssign ( DenseVector< VT2, true > &  lhs,
const TDVecSMatMultExpr< VT, MT > &  rhs 
)
friend

SMP subtraction assignment of a transpose dense vector-sparse matrix multiplication to a dense vector ( $ \vec{y}^T-=\vec{x}^T*A $).

Parameters
lhsThe target left-hand side dense vector.
rhsThe right-hand side multiplication expression to be subtracted.
Returns
void

This function implements the performance optimized SMP subtraction assignment of a transpose dense vector-sparse matrix multiplication expression to a dense vector. Due to the explicit application of the SFINAE principle, this function can only be selected by the compiler in case the expression specific parallel evaluation strategy is selected.

template<typename VT , typename MT >
template<typename VT2 >
EnableIf< UseSMPAssign<VT2> >::Type smpSubAssign ( DenseVector< VT2, true > &  lhs,
const TSVecDMatMultExpr< VT, MT > &  rhs 
)
friend

SMP subtraction assignment of a transpose sparse vector-dense matrix multiplication to a dense vector ( $ \vec{y}^T-=\vec{x}^T*A $).

Parameters
lhsThe target left-hand side dense vector.
rhsThe right-hand side multiplication expression to be subtracted.
Returns
void

This function implements the performance optimized SMP subtraction assignment of a transpose sparse vector-dense matrix multiplication expression to a dense vector. Due to the explicit application of the SFINAE principle, this function can only be selected by the compiler in case the expression specific parallel evaluation strategy is selected.

template<typename VT , typename MT >
template<typename VT2 >
EnableIf< UseAssign<VT2> >::Type subAssign ( DenseVector< VT2, true > &  lhs,
const TDVecTSMatMultExpr< VT, MT > &  rhs 
)
friend

Subtraction assignment of a transpose dense vector-transpose sparse matrix multiplication to a dense vector ( $ \vec{y}^T-=\vec{x}^T*A $).

Parameters
lhsThe target left-hand side dense vector.
rhsThe right-hand side multiplication expression to be subtracted.
Returns
void

This function implements the performance optimized subtraction assignment of a transpose dense vector-transpose sparse matrix multiplication expression to a dense vector. Due to the explicit application of the SFINAE principle, this function can only be selected by the compiler in case either the left-hand side vector operand is a compound expression or the right-hand side matrix operand requires an intermediate evaluation.

template<typename VT , typename MT >
template<typename VT2 >
EnableIf< UseAssign<VT2> >::Type subAssign ( DenseVector< VT2, true > &  lhs,
const TSVecTDMatMultExpr< VT, MT > &  rhs 
)
friend

Subtraction assignment of a transpose sparse vector-transpose dense matrix multiplication to a dense vector ( $ \vec{y}^T-=\vec{x}^T*A $).

Parameters
lhsThe target left-hand side dense vector.
rhsThe right-hand side multiplication expression to be subtracted.
Returns
void

This function implements the performance optimized subtraction assignment of a transpose sparse vector-transpose dense matrix multiplication expression to a dense vector. Due to the explicit application of the SFINAE principle, this function can only be selected by the compiler in case either the left-hand side matrix operand requires an intermediate evaluation or the right-hand side vector operand is a compound expression.

template<typename VT , typename MT >
template<typename VT2 >
void subAssign ( DenseVector< VT2, true > &  lhs,
const TDVecSMatMultExpr< VT, MT > &  rhs 
)
friend

Subtraction assignment of a transpose dense vector-sparse matrix multiplication to a dense vector ( $ \vec{y}^T-=\vec{x}^T*A $).

Parameters
lhsThe target left-hand side dense vector.
rhsThe right-hand side multiplication expression to be subtracted.
Returns
void

This function implements the performance optimized subtraction assignment of a transpose dense vector-sparse matrix multiplication expression to a dense vector.

template<typename VT , typename MT >
template<typename VT2 >
void subAssign ( DenseVector< VT2, true > &  lhs,
const TSVecDMatMultExpr< VT, MT > &  rhs 
)
friend

Subtraction assignment of a transpose sparse vector-dense matrix multiplication to a dense vector ( $ \vec{y}^T-=\vec{x}^T*A $).

Parameters
lhsThe target left-hand side dense vector.
rhsThe right-hand side multiplication expression to be subtracted.
Returns
void

This function implements the performance optimized subtraction assignment of a transpose sparse vector-dense matrix multiplication expression to a dense vector.