![]() |
Modules | |
CustomVector | |
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 MT , typename VT > | |
decltype(auto) | blaze::operator* (const DenseMatrix< MT, false > &mat, const DenseVector< VT, false > &vec) |
Multiplication operator for the multiplication of a row-major dense matrix and a dense vector ( ![]() | |
template<typename MT , typename VT > | |
decltype(auto) | blaze::operator* (const DenseMatrix< MT, false > &mat, const SparseVector< VT, false > &vec) |
Multiplication operator for the multiplication of a row-major dense matrix and a sparse vector ( ![]() | |
template<typename VT1 , typename VT2 , bool TF> | |
decltype(auto) | blaze::operator+ (const DenseVector< VT1, TF > &lhs, const DenseVector< VT2, TF > &rhs) |
Addition operator for the addition of two dense vectors ( ![]() | |
template<typename VT1 , typename VT2 , bool TF> | |
decltype(auto) | blaze::operator% (const DenseVector< VT1, TF > &lhs, const DenseVector< VT2, TF > &rhs) |
Operator for the cross product of two dense vectors ( ![]() | |
template<typename VT1 , typename VT2 , bool TF> | |
decltype(auto) | blaze::cross (const DenseVector< VT1, TF > &lhs, const DenseVector< VT2, TF > &rhs) |
Cross product of two dense vectors ( ![]() | |
template<typename VT1 , typename VT2 , bool TF> | |
decltype(auto) | blaze::operator/ (const DenseVector< VT1, TF > &lhs, const DenseVector< VT2, TF > &rhs) |
Division operator for the componentwise product of two dense vectors ( ![]() | |
template<typename VT1 , typename VT2 > | |
decltype(auto) | blaze::operator* (const DenseVector< VT1, true > &lhs, const DenseVector< VT2, false > &rhs) |
Multiplication operator for the scalar product (inner product) of two dense vectors ( ![]() | |
template<typename VT1 , typename VT2 , bool TF, typename OP > | |
decltype(auto) | blaze::map (const DenseVector< VT1, TF > &lhs, const DenseVector< VT2, TF > &rhs, OP op) |
Evaluates the given binary operation on each single element of the dense vectors lhs and rhs. More... | |
template<typename VT1 , typename VT2 , bool TF> | |
decltype(auto) | blaze::min (const DenseVector< VT1, TF > &lhs, const DenseVector< VT2, TF > &rhs) |
Computes the componentwise minimum of the dense vectors lhs and rhs. More... | |
template<typename VT1 , typename VT2 , bool TF> | |
decltype(auto) | blaze::max (const DenseVector< VT1, TF > &lhs, const DenseVector< VT2, TF > &rhs) |
Computes the componentwise maximum of the dense vectors lhs and rhs. More... | |
template<typename VT1 , typename VT2 , bool TF> | |
decltype(auto) | blaze::operator* (const DenseVector< VT1, TF > &lhs, const DenseVector< VT2, TF > &rhs) |
Multiplication operator for the componentwise product of two dense vectors ( ![]() | |
template<typename VT1 , typename VT2 , bool TF> | |
decltype(auto) | blaze::operator- (const DenseVector< VT1, TF > &lhs, const DenseVector< VT2, TF > &rhs) |
Subtraction operator for the subtraction of two dense vectors ( ![]() | |
template<typename VT , bool TF> | |
decltype(auto) | blaze::eval (const DenseVector< VT, TF > &dv) |
Forces the evaluation of the given dense vector expression dv. More... | |
template<typename VT , bool TF, typename OP > | |
decltype(auto) | blaze::map (const DenseVector< VT, TF > &dv, OP op) |
Evaluates the given custom operation on each single element of the dense vector dv. More... | |
template<typename VT , bool TF, typename OP > | |
decltype(auto) | blaze::forEach (const DenseVector< VT, TF > &dv, OP op) |
Evaluates the given custom operation on each single element of the dense vector dv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | blaze::abs (const DenseVector< VT, TF > &dv) |
Applies the abs() function to each single element of the dense vector dv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | blaze::floor (const DenseVector< VT, TF > &dv) |
Applies the floor() function to each single element of the dense vector dv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | blaze::ceil (const DenseVector< VT, TF > &dv) |
Applies the ceil() function to each single element of the dense vector dv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | blaze::trunc (const DenseVector< VT, TF > &dv) |
Applies the trunc() function to each single element of the dense vector dv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | blaze::round (const DenseVector< VT, TF > &dv) |
Applies the round() function to each single element of the dense vector dv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | blaze::conj (const DenseVector< VT, TF > &dv) |
Returns a vector containing the complex conjugate of each single element of dv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | blaze::ctrans (const DenseVector< VT, TF > &dv) |
Returns the conjugate transpose vector of dv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | blaze::real (const DenseVector< VT, TF > &dv) |
Returns a vector containing the real part of each single element of dv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | blaze::imag (const DenseVector< VT, TF > &dv) |
Returns a vector containing the imaginary part of each single element of dv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | blaze::sqrt (const DenseVector< VT, TF > &dv) |
Computes the square root of each single element of the dense vector dv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | blaze::invsqrt (const DenseVector< VT, TF > &dv) |
Computes the inverse square root of each single element of the dense vector dv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | blaze::cbrt (const DenseVector< VT, TF > &dv) |
Computes the cubic root of each single element of the dense vector dv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | blaze::invcbrt (const DenseVector< VT, TF > &dv) |
Computes the inverse cubic root of each single element of the dense vector dv. More... | |
template<typename VT , bool TF, typename DT > | |
decltype(auto) | blaze::clamp (const DenseVector< VT, TF > &dv, const DT &min, const DT &max) |
Restricts each single element of the dense vector dv to the range ![]() | |
template<typename VT , bool TF, typename ET > | |
decltype(auto) | blaze::pow (const DenseVector< VT, TF > &dv, ET exp) |
Computes the exponential value for each single element of the dense vector dv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | blaze::exp (const DenseVector< VT, TF > &dv) |
Computes ![]() | |
template<typename VT , bool TF> | |
decltype(auto) | blaze::exp2 (const DenseVector< VT, TF > &dv) |
Computes ![]() | |
template<typename VT , bool TF> | |
decltype(auto) | blaze::exp10 (const DenseVector< VT, TF > &dv) |
Computes ![]() | |
template<typename VT , bool TF> | |
decltype(auto) | blaze::log (const DenseVector< VT, TF > &dv) |
Computes the natural logarithm for each single element of the dense vector dv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | blaze::log2 (const DenseVector< VT, TF > &dv) |
Computes the binary logarithm for each single element of the dense vector dv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | blaze::log10 (const DenseVector< VT, TF > &dv) |
Computes the common logarithm for each single element of the dense vector dv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | blaze::sin (const DenseVector< VT, TF > &dv) |
Computes the sine for each single element of the dense vector dv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | blaze::asin (const DenseVector< VT, TF > &dv) |
Computes the inverse sine for each single element of the dense vector dv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | blaze::sinh (const DenseVector< VT, TF > &dv) |
Computes the hyperbolic sine for each single element of the dense vector dv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | blaze::asinh (const DenseVector< VT, TF > &dv) |
Computes the inverse hyperbolic sine for each single element of the dense vector dv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | blaze::cos (const DenseVector< VT, TF > &dv) |
Computes the cosine for each single element of the dense vector dv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | blaze::acos (const DenseVector< VT, TF > &dv) |
Computes the inverse cosine for each single element of the dense vector dv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | blaze::cosh (const DenseVector< VT, TF > &dv) |
Computes the hyperbolic cosine for each single element of the dense vector dv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | blaze::acosh (const DenseVector< VT, TF > &dv) |
Computes the inverse hyperbolic cosine for each single element of the dense vector dv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | blaze::tan (const DenseVector< VT, TF > &dv) |
Computes the tangent for each single element of the dense vector dv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | blaze::atan (const DenseVector< VT, TF > &dv) |
Computes the inverse tangent for each single element of the dense vector dv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | blaze::tanh (const DenseVector< VT, TF > &dv) |
Computes the hyperbolic tangent for each single element of the dense vector dv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | blaze::atanh (const DenseVector< VT, TF > &dv) |
Computes the inverse hyperbolic tangent for each single element of the dense vector dv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | blaze::erf (const DenseVector< VT, TF > &dv) |
Computes the error function for each single element of the dense vector dv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | blaze::erfc (const DenseVector< VT, TF > &dv) |
Computes the complementary error function for each single element of the dense vector dv. More... | |
template<typename VT , typename ST , bool TF, typename = EnableIf_< IsNumeric<ST> >> | |
decltype(auto) | blaze::operator/ (const DenseVector< VT, TF > &vec, ST scalar) |
Division operator for the divison of a dense vector by a scalar value ( ![]() | |
template<typename VT , bool TF> | |
decltype(auto) | blaze::operator- (const DenseVector< VT, TF > &dv) |
Unary minus operator for the negation of a dense vector ( ![]() | |
template<typename VT , typename ST , bool TF, typename = EnableIf_< IsNumeric<ST> >> | |
decltype(auto) | blaze::operator* (const DenseVector< VT, TF > &vec, ST scalar) |
Multiplication operator for the multiplication of a dense vector and a scalar value ( ![]() | |
template<typename ST , typename VT , bool TF, typename = EnableIf_< IsNumeric<ST> >> | |
decltype(auto) | blaze::operator* (ST scalar, const DenseVector< VT, TF > &vec) |
Multiplication operator for the multiplication of a scalar value and a dense vector ( ![]() | |
template<typename VT , bool TF> | |
decltype(auto) | blaze::serial (const DenseVector< VT, TF > &dv) |
Forces the serial evaluation of the given dense vector expression dv. More... | |
template<typename VT1 , typename VT2 , bool TF> | |
decltype(auto) | blaze::operator+ (const DenseVector< VT1, TF > &lhs, const SparseVector< VT2, TF > &rhs) |
Addition operator for the addition of a dense vector and a sparse vector ( ![]() | |
template<typename VT1 , typename VT2 , bool TF> | |
decltype(auto) | blaze::operator+ (const SparseVector< VT1, TF > &lhs, const DenseVector< VT2, TF > &rhs) |
Addition operator for the addition of a sparse vector and a dense vector ( ![]() | |
template<typename VT1 , typename VT2 , bool TF> | |
decltype(auto) | blaze::operator% (const DenseVector< VT1, TF > &lhs, const SparseVector< VT2, TF > &rhs) |
Operator for the cross product of a dense vector and a sparse vector ( ![]() | |
template<typename VT1 , typename VT2 , bool TF> | |
decltype(auto) | blaze::cross (const DenseVector< VT1, TF > &lhs, const SparseVector< VT2, TF > &rhs) |
Cross product of a dense vector and a sparse vector ( ![]() | |
template<typename VT1 , typename VT2 , bool TF> | |
decltype(auto) | blaze::operator- (const DenseVector< VT1, TF > &lhs, const SparseVector< VT2, TF > &rhs) |
Subtraction operator for the subtraction of a dense vector and a sparse vector ( ![]() | |
template<typename VT , bool TF> | |
decltype(auto) | blaze::trans (const DenseVector< VT, TF > &dv) |
Calculation of the transpose of the given dense vector. More... | |
template<typename MT , typename VT > | |
decltype(auto) | blaze::operator* (const SparseMatrix< MT, false > &mat, const DenseVector< VT, false > &vec) |
Multiplication operator for the multiplication of a row-major sparse matrix and a dense vector ( ![]() | |
template<typename VT1 , typename VT2 , bool TF> | |
decltype(auto) | blaze::operator% (const SparseVector< VT1, TF > &lhs, const DenseVector< VT2, TF > &rhs) |
Operator for the cross product of a sparse vector and a dense vector ( ![]() | |
template<typename VT1 , typename VT2 , bool TF> | |
decltype(auto) | blaze::cross (const SparseVector< VT1, TF > &lhs, const DenseVector< VT2, TF > &rhs) |
Cross product of a sparse vector and a dense vector ( ![]() | |
template<typename VT1 , typename VT2 , bool TF> | |
decltype(auto) | blaze::operator- (const SparseVector< VT1, TF > &lhs, const DenseVector< VT2, TF > &rhs) |
Subtraction operator for the subtraction of a sparse vector and a dense vector ( ![]() | |
template<typename VT1 , typename VT2 , bool TF> | |
decltype(auto) | blaze::operator% (const SparseVector< VT1, TF > &lhs, const SparseVector< VT2, TF > &rhs) |
Operator for the cross product of two sparse vectors ( ![]() | |
template<typename VT1 , typename VT2 , bool TF> | |
decltype(auto) | blaze::cross (const SparseVector< VT1, TF > &lhs, const SparseVector< VT2, TF > &rhs) |
Cross product of two sparse vectors ( ![]() | |
template<typename MT , typename VT > | |
decltype(auto) | blaze::operator* (const DenseMatrix< MT, true > &mat, const DenseVector< VT, false > &vec) |
Multiplication operator for the multiplication of a column-major dense matrix and a dense vector ( ![]() | |
template<typename MT , typename VT > | |
decltype(auto) | blaze::operator* (const DenseMatrix< MT, true > &mat, const SparseVector< VT, false > &vec) |
Multiplication operator for the multiplication of a column-major dense matrix and a sparse vector ( ![]() | |
template<typename VT , typename MT > | |
decltype(auto) | blaze::operator* (const DenseVector< VT, true > &vec, const DenseMatrix< MT, false > &mat) |
Multiplication operator for the multiplication of a transpose dense vector and a row-major dense matrix ( ![]() | |
template<typename VT , typename MT > | |
decltype(auto) | blaze::operator* (const DenseVector< VT, true > &vec, const SparseMatrix< MT, false > &mat) |
Multiplication operator for the multiplication of a transpose dense vector and a row-major sparse matrix ( ![]() | |
template<typename MT , typename VT > | |
decltype(auto) | blaze::operator* (const SparseMatrix< MT, true > &mat, const DenseVector< VT, false > &vec) |
Multiplication operator for the multiplication of a column-major sparse matrix and a dense vector ( ![]() | |
template<typename VT , typename MT > | |
decltype(auto) | blaze::operator* (const SparseVector< VT, true > &vec, const DenseMatrix< MT, true > &mat) |
Multiplication operator for the multiplication of a transpose sparse vector and a column-major dense matrix ( ![]() | |
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 ( ![]() | |
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 ( ![]() | |
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 ( ![]() | |
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 ( ![]() | |
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 ( ![]() | |
template<typename VT2 > | |
void | blaze::TDVecSMatMultExpr< VT, MT >::divAssign (DenseVector< VT2, true > &lhs, const TDVecSMatMultExpr &rhs) |
Division assignment of a transpose dense vector-sparse matrix multiplication to a dense vector ( ![]() | |
template<typename VT2 > | |
EnableIf_< UseSMPAssign< VT2 > > | 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 ( ![]() | |
template<typename VT2 > | |
EnableIf_< UseSMPAssign< VT2 > > | 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 ( ![]() | |
template<typename VT2 > | |
EnableIf_< UseSMPAssign< VT2 > > | 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 ( ![]() | |
template<typename VT2 > | |
EnableIf_< UseSMPAssign< VT2 > > | 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 ( ![]() | |
template<typename VT2 > | |
EnableIf_< UseSMPAssign< VT2 > > | 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 ( ![]() | |
template<typename VT2 > | |
EnableIf_< UseSMPAssign< VT2 > > | blaze::TDVecSMatMultExpr< VT, MT >::smpDivAssign (DenseVector< VT2, true > &lhs, const TDVecSMatMultExpr &rhs) |
SMP division assignment of a transpose dense vector-sparse matrix multiplication to a dense vector ( ![]() | |
template<typename VT2 > | |
EnableIf_< UseAssign< VT2 > > | 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 ( ![]() | |
template<typename VT2 > | |
EnableIf_< UseAssign< VT2 > > | 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 ( ![]() | |
template<typename VT2 > | |
EnableIf_< UseAssign< VT2 > > | 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 ( ![]() | |
template<typename VT2 > | |
EnableIf_< UseAssign< VT2 > > | 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 ( ![]() | |
template<typename VT2 > | |
EnableIf_< UseAssign< VT2 > > | 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 ( ![]() | |
template<typename VT2 > | |
EnableIf_< UseAssign< VT2 > > | blaze::TDVecTSMatMultExpr< VT, MT >::divAssign (DenseVector< VT2, true > &lhs, const TDVecTSMatMultExpr &rhs) |
Division assignment of a transpose dense vector-transpose sparse matrix multiplication to a dense vector ( ![]() | |
template<typename VT2 > | |
EnableIf_< UseSMPAssign< VT2 > > | 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 ( ![]() | |
template<typename VT2 > | |
EnableIf_< UseSMPAssign< VT2 > > | 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 ( ![]() | |
template<typename VT2 > | |
EnableIf_< UseSMPAssign< VT2 > > | 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 ( ![]() | |
template<typename VT2 > | |
EnableIf_< UseSMPAssign< VT2 > > | 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 ( ![]() | |
template<typename VT2 > | |
EnableIf_< UseSMPAssign< VT2 > > | 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 ( ![]() | |
template<typename VT2 > | |
EnableIf_< UseSMPAssign< VT2 > > | blaze::TDVecTSMatMultExpr< VT, MT >::smpDivAssign (DenseVector< VT2, true > &lhs, const TDVecTSMatMultExpr &rhs) |
SMP division assignment of a transpose dense vector-transpose sparse matrix multiplication to a dense vector ( ![]() | |
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 ( ![]() | |
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 ( ![]() | |
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 ( ![]() | |
template<typename VT2 > | |
void | blaze::TSVecDMatMultExpr< VT, MT >::divAssign (DenseVector< VT2, true > &lhs, const TSVecDMatMultExpr &rhs) |
Division assignment of a transpose sparse vector-dense matrix multiplication to a dense vector ( ![]() | |
template<typename VT2 > | |
EnableIf_< UseSMPAssign< VT2 > > | 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 ( ![]() | |
template<typename VT2 > | |
EnableIf_< UseSMPAssign< VT2 > > | 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 ( ![]() | |
template<typename VT2 > | |
EnableIf_< UseSMPAssign< VT2 > > | 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 ( ![]() | |
template<typename VT2 > | |
EnableIf_< UseSMPAssign< VT2 > > | blaze::TSVecDMatMultExpr< VT, MT >::smpDivAssign (DenseVector< VT2, true > &lhs, const TSVecDMatMultExpr &rhs) |
SMP division assignment of a transpose sparse vector-dense matrix multiplication to a dense vector ( ![]() | |
template<typename VT2 > | |
EnableIf_< UseAssign< VT2 > > | 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 ( ![]() | |
template<typename VT2 > | |
EnableIf_< UseAssign< VT2 > > | 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 ( ![]() | |
template<typename VT2 > | |
EnableIf_< UseAssign< VT2 > > | 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 ( ![]() | |
template<typename VT2 > | |
EnableIf_< UseAssign< VT2 > > | blaze::TSVecTDMatMultExpr< VT, MT >::divAssign (DenseVector< VT2, true > &lhs, const TSVecTDMatMultExpr &rhs) |
Division assignment of a transpose sparse vector-transpose dense matrix multiplication to a dense vector ( ![]() | |
template<typename VT2 > | |
EnableIf_< UseSMPAssign< VT2 > > | 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 ( ![]() | |
template<typename VT2 > | |
EnableIf_< UseSMPAssign< VT2 > > | 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 ( ![]() | |
template<typename VT2 > | |
EnableIf_< UseSMPAssign< VT2 > > | 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 ( ![]() | |
template<typename VT2 > | |
EnableIf_< UseSMPAssign< VT2 > > | blaze::TSVecTDMatMultExpr< VT, MT >::smpDivAssign (DenseVector< VT2, true > &lhs, const TSVecTDMatMultExpr &rhs) |
SMP division assignment of a transpose sparse vector-transpose dense matrix multiplication to a dense vector ( ![]() | |
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 > | 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 > | 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 > | 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 > | 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::isDivisor (const DenseVector< VT, TF > &dv) |
Returns whether the given dense vector is a valid divisor. 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> | |
const ElementType_< VT > | blaze::sqrLength (const DenseVector< VT, TF > &dv) |
Calculation of the square length (magnitude) of the dense vector ![]() | |
template<typename VT , bool TF> | |
auto | blaze::length (const DenseVector< VT, TF > &dv) -> decltype(sqrt(sqrLength(~dv))) |
Calculation of the length (magnitude) of the dense vector ![]() | |
template<typename VT , bool TF> | |
const ElementType_< VT > | blaze::min (const DenseVector< VT, TF > &dv) |
Returns the smallest element of the dense vector. More... | |
template<typename VT , bool TF> | |
const ElementType_< VT > | blaze::max (const DenseVector< VT, TF > &dv) |
Returns the largest element of the dense vector. More... | |
|
inline |
Applies the abs() function to each single element of the dense vector dv.
dv | The input vector. |
This function applies the abs() function to 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:
|
inline |
Computes the inverse cosine for each single element of the dense vector dv.
dv | The input vector; all elements must be in the range ![]() |
The acos() function computes the inverse cosine for each element of the input vector dv. The function returns an expression representing this operation.
The following example demonstrates the use of the acos() function:
|
inline |
Computes the inverse hyperbolic cosine for each single element of the dense vector dv.
dv | The input vector; all elements must be in the range ![]() |
The acosh() function computes the inverse hyperbolic cosine for each element of the input vector dv. The function returns an expression representing this operation.
The following example demonstrates the use of the acosh() function:
|
inline |
Computes the inverse sine for each single element of the dense vector dv.
dv | The input vector; all elements must be in the range ![]() |
The asin() function computes the inverse sine for each element of the input vector dv. The function returns an expression representing this operation.
The following example demonstrates the use of the asin() function:
|
inline |
Computes the inverse hyperbolic sine for each single element of the dense vector dv.
dv | The input vector. |
The asinh() function computes the inverse hyperbolic sine for each element of the input vector dv. The function returns an expression representing this operation.
The following example demonstrates the use of the asinh() function:
|
inline |
Computes the inverse tangent for each single element of the dense vector dv.
dv | The input vector. |
The atan() function computes the inverse tangent for each element of the input vector dv. The function returns an expression representing this operation.
The following example demonstrates the use of the atan() function:
|
inline |
Computes the inverse hyperbolic tangent for each single element of the dense vector dv.
dv | The input vector; all elements must be in the range ![]() |
The atanh() function computes the inverse hyperbolic tangent for each element of the input vector dv. The function returns an expression representing this operation.
The following example demonstrates the use of the atanh() function:
|
inline |
Computes the cubic root of each single element of the dense vector dv.
dv | The input vector; all elements must be in the range ![]() |
The cbrt() function computes the cubic root of each element of the input vector dv. The function returns an expression representing this operation.
The following example demonstrates the use of the cbrt() function:
|
inline |
Applies the ceil() function to each single element of the dense vector dv.
dv | The input vector. |
This function applies the ceil() function to each element of the input vector dv. The function returns an expression representing this operation.
The following example demonstrates the use of the ceil() function:
|
inline |
Restricts each single element of the dense vector dv to the range .
dv | The input vector. |
min | The lower delimiter. |
max | The upper delimiter. |
The clamp() function restricts each element of the input vector dv to the range . The function returns an expression representing this operation.
The following example demonstrates the use of the clamp() function:
|
inline |
Returns a vector containing the complex conjugate of each single element of dv.
dv | The input vector. |
The conj function calculates the complex conjugate of each element of the input vector dv. The function returns an expression representing this operation.
The following example demonstrates the use of the conj function:
|
inline |
Computes the cosine for each single element of the dense vector dv.
dv | The input vector. |
The cos() function computes the cosine for each element of the input vector dv. The function returns an expression representing this operation.
The following example demonstrates the use of the cos() function:
|
inline |
Computes the hyperbolic cosine for each single element of the dense vector dv.
dv | The input vector. |
The cosh() function computes the hyperbolic cosine for each element of the input vector dv. The function returns an expression representing this operation.
The following example demonstrates the use of the cosh() function:
|
inline |
Cross product of two dense vectors ( ).
lhs | The left-hand side dense vector for the cross product. |
rhs | The right-hand side dense vector for the cross product. |
std::invalid_argument | Invalid vector size for cross product. |
This function computes the cross product of two dense vectors:
The operator returns an expression representing a dense vector of the higher-order element type of the two involved vector element types VT1::ElementType and VT2::ElementType. Both vector types VT1 and VT2 as well as the two element types VT1::ElementType and VT2::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.
|
inline |
Cross product of two sparse vectors ( ).
lhs | The left-hand side sparse vector for the cross product. |
rhs | The right-hand side sparse vector for the cross product. |
std::invalid_argument | Invalid vector size for cross product. |
This function computes the cross product of two sparse vectors:
The operator returns a dense vector of the higher-order element type of the two involved vector element types VT1::ElementType and VT2::ElementType. Both vector types VT1 and VT2 as well as the two element types VT1::ElementType and VT2::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.
|
inline |
Cross product of a dense vector and a sparse vector ( ).
lhs | The left-hand side dense vector for the cross product. |
rhs | The right-hand side sparse vector for the cross product. |
std::invalid_argument | Invalid vector size for cross product. |
This function computes the cross product of a dense vector and a sparse vector:
The operator returns an expression representing a dense vector of the higher-order element type of the two involved vector element types VT1::ElementType and VT2::ElementType. Both vector types VT1 and VT2 as well as the two element types VT1::ElementType and VT2::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.
|
inline |
Cross product of a sparse vector and a dense vector ( ).
lhs | The left-hand side sparse vector for the cross product. |
rhs | The right-hand side dense vector for the cross product. |
std::invalid_argument | Invalid vector size for cross product. |
This function computes the cross product of a sparse vector and a dense vector:
The operator returns an expression representing a dense vector of the higher-order element type of the two involved vector element types VT1::ElementType and VT2::ElementType. Both vector types VT1 and VT2 as well as the two element types VT1::ElementType and VT2::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.
|
inline |
Returns the conjugate transpose vector of dv.
dv | The input vector. |
The ctrans function returns an expression representing the conjugate transpose (also called adjoint matrix, Hermitian conjugate matrix or transjugate matrix) of the given input vector dv.
The following example demonstrates the use of the ctrans function:
Note that the ctrans function has the same effect as manually applying the conj and trans function in any order:
|
inline |
Computes the error function for each single element of the dense vector dv.
dv | The input vector. |
The erf() function computes the error function for each element of the input vector dv. The function returns an expression representing this operation.
The following example demonstrates the use of the erf() function:
|
inline |
Computes the complementary error function for each single element of the dense vector dv.
dv | The input vector. |
The erfc() function computes the complementary error function for each element of the input vector dv. The function returns an expression representing this operation.
The following example demonstrates the use of the erfc() function:
|
inline |
Forces the evaluation of the given dense vector expression dv.
dv | The input 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:
|
inline |
Computes for each single element of the dense vector dv.
dv | The input vector. |
The exp() function computes for each element of the input vector dv. The function returns an expression representing this operation.
The following example demonstrates the use of the exp() function:
|
inline |
Computes for each single element of the dense vector dv.
dv | The input vector. |
The exp10() function computes for each element of the input vector dv. The function returns an expression representing this operation.
The following example demonstrates the use of the exp10() function:
|
inline |
Computes for each single element of the dense vector dv.
dv | The input vector. |
The exp2() function computes for each element of the input vector dv. The function returns an expression representing this operation.
The following example demonstrates the use of the exp2() function:
|
inline |
Applies the floor() function to each single element of the dense vector dv.
dv | The input vector. |
This function applies the floor() function to each element of the input vector dv. The function returns an expression representing this operation.
The following example demonstrates the use of the floor() function:
|
inline |
Evaluates the given custom operation on each single element of the dense vector dv.
dv | The input vector. |
op | The custom operation. |
The forEach() function evaluates the given custom operation on each element of the input vector dv. The function returns an expression representing this operation.
The following example demonstrates the use of the forEach() function:
|
inline |
Returns a vector containing the imaginary part of each single element of dv.
dv | The input vector. |
The imag function calculates the imaginary part of each element of the input vector dv. The function returns an expression representing this operation.
The following example demonstrates the use of the imag function:
|
inline |
Computes the inverse cubic root of each single element of the dense vector dv.
dv | The input vector; all elements must be in the range ![]() |
The invcbrt() function computes the inverse cubic root of each element of the input vector dv. The function returns an expression representing this operation.
The following example demonstrates the use of the invcbrt() function:
|
inline |
Computes the inverse square root of each single element of the dense vector dv.
dv | The input vector; all elements must be in the range ![]() |
The invsqrt() function computes the inverse square root of each element of the input vector dv. The function returns an expression representing this operation.
The following example demonstrates the use of the invsqrt() function:
bool blaze::isDivisor | ( | const DenseVector< VT, TF > & | dv | ) |
Returns whether the given dense vector is a valid divisor.
dv | The dense vector to be tested. |
This function checks if the given dense vector is a valid divisor. If all elements of the vector are valid divisors the function returns true, if at least one element of the vector is not a valid divisor, the function returns false.
bool blaze::isnan | ( | const DenseVector< VT, TF > & | dv | ) |
Checks the given dense vector for not-a-number elements.
dv | The vector to be checked for not-a-number elements. |
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.
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.
bool blaze::isUniform | ( | const DenseVector< VT, TF > & | dv | ) |
Checks if the given dense vector is a uniform vector.
dv | The dense vector to be checked. |
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:
It is also possible to check if a vector expression results in a uniform vector:
However, note that this might require the complete evaluation of the expression, including the generation of a temporary vector.
|
inline |
Calculation of the length (magnitude) of the dense vector .
dv | The given dense vector. |
This function calculates the actual length (magnitude) of the dense vector. The return type of the length() function depends on the actual element type of the vector instance:
Type | LengthType |
float | float |
integral data types and double | double |
long double | long double |
complex<T> | complex<T> |
|
inline |
Computes the natural logarithm for each single element of the dense vector dv.
dv | The input vector; all elements must be in the range ![]() |
The log() function computes natural logarithm for each element of the input vector dv. The function returns an expression representing this operation.
The following example demonstrates the use of the log() function:
|
inline |
Computes the common logarithm for each single element of the dense vector dv.
dv | The input vector; all elements must be in the range ![]() |
The log10() function computes common logarithm for each element of the input vector dv. The function returns an expression representing this operation.
The following example demonstrates the use of the log10() function:
|
inline |
Computes the binary logarithm for each single element of the dense vector dv.
dv | The input vector; all elements must be in the range ![]() |
The log2() function computes binary logarithm for each element of the input vector dv. The function returns an expression representing this operation.
The following example demonstrates the use of the log2() function:
|
inline |
Evaluates the given binary operation on each single element of the dense vectors lhs and rhs.
lhs | The left-hand side dense vector operand. |
rhs | The right-hand side dense vector operand. |
op | The custom, binary operation. |
std::invalid_argument | Vector sizes do not match. |
The map() function evaluates the given binary operation on each element of the input vectors lhs and rhs. The function returns an expression representing this operation.
The following example demonstrates the use of the map() function:
|
inline |
Evaluates the given custom operation on each single element of the dense vector dv.
dv | The input vector. |
op | The custom operation. |
The map() function evaluates the given custom operation on each element of the input vector dv. The function returns an expression representing this operation.
The following example demonstrates the use of the map() function:
const ElementType_< VT > blaze::max | ( | const DenseVector< VT, TF > & | dv | ) |
Returns the largest element of the dense vector.
dv | The given dense vector. |
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).
|
inline |
Computes the componentwise maximum of the dense vectors lhs and rhs.
lhs | The left-hand side dense vector operand. |
rhs | The right-hand side dense vector operand. |
This function computes the componentwise maximum of the two dense vectors lhs and rhs. The function returns an expression representing this operation.
The following example demonstrates the use of the max() function:
const ElementType_< VT > blaze::min | ( | const DenseVector< VT, TF > & | dv | ) |
Returns the smallest element of the dense vector.
dv | The given dense vector. |
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).
|
inline |
Computes the componentwise minimum of the dense vectors lhs and rhs.
lhs | The left-hand side dense vector operand. |
rhs | The right-hand side dense vector operand. |
This function computes the componentwise minimum of the two dense vectors lhs and rhs. The function returns an expression representing this operation.
The following example demonstrates the use of the min() function:
|
inline |
Inequality operator for the comparison of two dense vectors.
lhs | The left-hand side dense vector for the comparison. |
rhs | The right-hand side dense vector for the comparison. |
|
inline |
Inequality operator for the comparison of a dense vector and a sparse vector.
lhs | The left-hand side dense vector for the comparison. |
rhs | The right-hand side sparse vector for the comparison. |
|
inline |
Inequality operator for the comparison of a sparse vector and a dense vector.
lhs | The left-hand side sparse vector for the comparison. |
rhs | The right-hand side dense vector for the comparison. |
|
inline |
Inequality operator for the comparison of a dense vector and a scalar value.
vec | The left-hand side dense vector for the comparison. |
scalar | The right-hand side scalar value for the comparison. |
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!
|
inline |
Inequality operator for the comparison of a scalar value and a dense vector.
scalar | The left-hand side scalar value for the comparison. |
vec | The right-hand side dense vector for the comparison. |
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!
decltype(auto) blaze::operator% | ( | const SparseVector< VT1, TF > & | lhs, |
const DenseVector< VT2, TF > & | rhs | ||
) |
Operator for the cross product of a sparse vector and a dense vector ( ).
lhs | The left-hand side sparse vector for the cross product. |
rhs | The right-hand side dense vector for the cross product. |
std::invalid_argument | Invalid vector size for cross product. |
This operator represents the cross product of a sparse vector and a dense vector:
The operator returns an expression representing a dense vector of the higher-order element type of the two involved vector element types VT1::ElementType and VT2::ElementType. Both vector types VT1 and VT2 as well as the two element types VT1::ElementType and VT2::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.
decltype(auto) blaze::operator% | ( | const SparseVector< VT1, TF > & | lhs, |
const SparseVector< VT2, TF > & | rhs | ||
) |
Operator for the cross product of two sparse vectors ( ).
lhs | The left-hand side sparse vector for the cross product. |
rhs | The right-hand side sparse vector for the cross product. |
std::invalid_argument | Invalid vector size for cross product. |
This operator represents the cross product of two sparse vectors:
The operator returns a dense vector of the higher-order element type of the two involved vector element types VT1::ElementType and VT2::ElementType. Both vector types VT1 and VT2 as well as the two element types VT1::ElementType and VT2::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.
|
inline |
Operator for the cross product of two dense vectors ( ).
lhs | The left-hand side dense vector for the cross product. |
rhs | The right-hand side dense vector for the cross product. |
std::invalid_argument | Invalid vector size for cross product. |
This operator represents the cross product of two dense vectors:
The operator returns an expression representing a dense vector of the higher-order element type of the two involved vector element types VT1::ElementType and VT2::ElementType. Both vector types VT1 and VT2 as well as the two element types VT1::ElementType and VT2::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.
|
inline |
Operator for the cross product of a dense vector and a sparse vector ( ).
lhs | The left-hand side dense vector for the cross product. |
rhs | The right-hand side sparse vector for the cross product. |
std::invalid_argument | Invalid vector size for cross product. |
This operator represents the cross product of a dense vector and a sparse vector:
The operator returns an expression representing a dense vector of the higher-order element type of the two involved vector element types VT1::ElementType and VT2::ElementType. Both vector types VT1 and VT2 as well as the two element types VT1::ElementType and VT2::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.
|
inline |
Multiplication operator for the scalar product (inner product) of two dense vectors ( ).
lhs | The left-hand side dense vector for the inner product. |
rhs | The right-hand side dense vector for the inner product. |
std::invalid_argument | Vector sizes do not match. |
This operator represents the scalar product (inner product) of two dense vectors:
The operator returns a scalar value of the higher-order element type of the two involved vector element types VT1::ElementType and VT2::ElementType. Both vector types VT1 and VT2 as well as the two element types VT1::ElementType and VT2::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.
decltype(auto) blaze::operator* | ( | const DenseMatrix< MT, true > & | mat, |
const DenseVector< VT, false > & | vec | ||
) |
Multiplication operator for the multiplication of a column-major dense matrix and a dense vector ( ).
mat | The left-hand side column-major dense matrix for the multiplication. |
vec | The right-hand side dense vector for the multiplication. |
std::invalid_argument | Matrix 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 MT::ElementType and VT::ElementType. Both the dense matrix type MT and the dense vector type VT as well as the two element types MT::ElementType and VT::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.
decltype(auto) blaze::operator* | ( | const DenseMatrix< MT, true > & | mat, |
const SparseVector< VT, false > & | vec | ||
) |
Multiplication operator for the multiplication of a column-major dense matrix and a sparse vector ( ).
mat | The left-hand side column-major dense matrix for the multiplication. |
vec | The right-hand side sparse vector for the multiplication. |
std::invalid_argument | Matrix 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 MT::ElementType and VT::ElementType. Both the dense matrix type MT and the sparse vector type VT as well as the two element types MT::ElementType and VT::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.
decltype(auto) blaze::operator* | ( | const SparseMatrix< MT, false > & | mat, |
const DenseVector< VT, false > & | vec | ||
) |
Multiplication operator for the multiplication of a row-major sparse matrix and a dense vector ( ).
mat | The left-hand side row-major sparse matrix for the multiplication. |
vec | The right-hand side dense vector for the multiplication. |
std::invalid_argument | Matrix 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 MT::ElementType and VT::ElementType. Both the sparse matrix type MT and the dense vector type VT as well as the two element types MT::ElementType and VT::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.
decltype(auto) blaze::operator* | ( | const SparseMatrix< MT, true > & | mat, |
const DenseVector< VT, false > & | vec | ||
) |
Multiplication operator for the multiplication of a column-major sparse matrix and a dense vector ( ).
mat | The left-hand side column-major sparse matrix for the multiplication. |
vec | The right-hand side dense vector for the multiplication. |
std::invalid_argument | Matrix 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 MT::ElementType and VT::ElementType. Both the sparse matrix type MT and the dense vector type VT as well as the two element types MT::ElementType and VT::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.
decltype(auto) blaze::operator* | ( | const DenseVector< VT, true > & | vec, |
const DenseMatrix< MT, false > & | mat | ||
) |
Multiplication operator for the multiplication of a transpose dense vector and a row-major dense matrix ( ).
vec | The left-hand side transpose dense vector for the multiplication. |
mat | The right-hand side row-major dense matrix for the multiplication. |
std::invalid_argument | Vector and matrix sizes do not match. |
This operator represents the multiplication between a transpose dense vector and a row-major dense matrix:
The operator returns an expression representing a transpose dense vector of the higher-order element type of the two involved element types VT::ElementType and MT::ElementType. Both the dense matrix type VT and the dense vector type MT as well as the two element types VT::ElementType and MT::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.
decltype(auto) blaze::operator* | ( | const DenseVector< VT, true > & | vec, |
const SparseMatrix< MT, false > & | mat | ||
) |
Multiplication operator for the multiplication of a transpose dense vector and a row-major sparse matrix ( ).
vec | The left-hand side transpose dense vector for the multiplication. |
mat | The right-hand side row-major sparse matrix for the multiplication. |
std::invalid_argument | Vector and matrix sizes do not match. |
This operator represents the multiplication between a transpose dense vector and a row-major sparse matrix:
The operator returns an expression representing a transpose dense vector of the higher-order element type of the two involved element types VT::ElementType and MT::ElementType. Both the sparse matrix type VT and the dense vector type MT as well as the two element types VT::ElementType and MT::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.
decltype(auto) blaze::operator* | ( | const SparseVector< VT, true > & | vec, |
const DenseMatrix< MT, true > & | mat | ||
) |
Multiplication operator for the multiplication of a transpose sparse vector and a column-major dense matrix ( ).
vec | The left-hand side transpose sparse vector for the multiplication. |
mat | The right-hand side column-major dense matrix for the multiplication. |
std::invalid_argument | Vector 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 VT::ElementType and MT::ElementType. Both the dense matrix type VT and the dense vector type MT as well as the two element types VT::ElementType and MT::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.
|
inline |
Multiplication operator for the multiplication of a row-major dense matrix and a sparse vector ( ).
mat | The left-hand side row-major dense matrix for the multiplication. |
vec | The right-hand side sparse vector for the multiplication. |
std::invalid_argument | Matrix 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 MT::ElementType and VT::ElementType. Both the dense matrix type MT and the sparse vector type VT as well as the two element types MT::ElementType and VT::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.
|
inline |
Multiplication operator for the multiplication of a dense vector and a scalar value ( ).
vec | The left-hand side dense vector for the multiplication. |
scalar | The right-hand side scalar value for the multiplication. |
This operator represents the multiplication between a dense vector and a scalar value:
The operator returns an expression representing a dense vector of the higher-order element type of the involved data types VT::ElementType and ST. Both data types VT::ElementType and ST have to be supported by the MultTrait class template. Note that this operator only works for scalar values of built-in data type.
|
inline |
Multiplication operator for the componentwise product of two dense vectors ( ).
lhs | The left-hand side dense vector for the component product. |
rhs | The right-hand side dense vector for the component product. |
std::invalid_argument | Vector sizes do not match. |
This operator represents the component product of two dense vectors:
The operator returns an expression representing a dense vector of the higher-order element type of the two involved vector element types VT1::ElementType and VT2::ElementType. Both vector types VT1 and VT2 as well as the two element types T1::ElementType and VT2::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.
|
inline |
Multiplication operator for the multiplication of a scalar value and a dense vector ( ).
scalar | The left-hand side scalar value for the multiplication. |
vec | The right-hand side vector for the multiplication. |
This operator represents the multiplication between a a scalar value and dense vector:
The operator returns an expression representing a dense vector of the higher-order element type of the involved data types ST and VT::ElementType. Both data types ST and VT::ElementType have to be supported by the MultTrait class template. Note that this operator only works for scalar values of built-in data type.
|
inline |
Multiplication operator for the multiplication of a row-major dense matrix and a dense vector ( ).
mat | The left-hand side row-major dense matrix for the multiplication. |
vec | The right-hand side dense vector for the multiplication. |
std::invalid_argument | Matrix 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 MT::ElementType and VT::ElementType. Both the dense matrix type MT and the dense vector type VT as well as the two element types MT::ElementType and VT::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.
|
inline |
Addition operator for the addition of a dense vector and a sparse vector ( ).
lhs | The left-hand side dense vector for the vector addition. |
rhs | The right-hand side sparse vector for the vector addition. |
std::invalid_argument | Vector sizes do not match. |
This operator represents the addition of a dense vector and a sparse vector:
The operator returns an expression representing a dense vector of the higher-order element type of the two involved vector element types VT1::ElementType and VT2::ElementType. Both vector types VT1 and VT2 as well as the two element types VT1::ElementType and VT2::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.
|
inline |
Addition operator for the addition of a sparse vector and a dense vector ( ).
lhs | The left-hand side sparse vector for the vector addition. |
rhs | The right-hand side dense vector for the vector addition. |
std::invalid_argument | Vector sizes do not match. |
This operator represents the addition of a sparse vector and a dense vector:
The operator returns an expression representing a dense vector of the higher-order element type of the two involved vector element types VT1::ElementType and VT2::ElementType. Both vector types VT1 and VT2 as well as the two element types VT1::ElementType and VT2::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.
|
inline |
Addition operator for the addition of two dense vectors ( ).
lhs | The left-hand side dense vector for the vector addition. |
rhs | The right-hand side dense vector for the vector addition. |
std::invalid_argument | Vector sizes do not match. |
This operator represents the addition of two dense vectors:
The operator returns an expression representing a dense vector of the higher-order element type of the two involved vector element types VT1::ElementType and VT2::ElementType. Both vector types VT1 and VT2 as well as the two element types VT1::ElementType and VT2::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.
|
inline |
Subtraction operator for the subtraction of a sparse vector and a dense vector ( ).
lhs | The left-hand side sparse vector for the vector subtraction. |
rhs | The right-hand side dense vector to be subtracted from the sparse vector. |
std::invalid_argument | Vector sizes do not match. |
This operator represents the subtraction of a sparse vector and a dense vector:
The operator returns an expression representing a dense vector of the higher-order element type of the two involved vector element types VT1::ElementType and VT2::ElementType. Both vector types VT1 and VT2 as well as the two element types VT1::ElementType and VT2::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.
|
inline |
Subtraction operator for the subtraction of a dense vector and a sparse vector ( ).
lhs | The left-hand side dense vector for the vector subtraction. |
rhs | The right-hand side sparse vector to be subtracted from the dense vector. |
std::invalid_argument | Vector sizes do not match. |
This operator represents the subtraction of a dense vector and a sparse vector:
The operator returns an expression representing a dense vector of the higher-order element type of the two involved vector element types VT1::ElementType and VT2::ElementType. Both vector types VT1 and VT2 as well as the two element types VT1::ElementType and VT2::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.
|
inline |
Unary minus operator for the negation of a dense vector ( ).
dv | The dense vector to be negated. |
This operator represents the negation of a dense vector:
The operator returns an expression representing the negation of the given dense vector.
|
inline |
Subtraction operator for the subtraction of two dense vectors ( ).
lhs | The left-hand side dense vector for the vector subtraction. |
rhs | The right-hand side dense vector to be subtracted from the vector. |
std::invalid_argument | Vector sizes do not match. |
This operator represents the subtraction of two dense vectors:
The operator returns an expression representing a dense vector of the higher-order element type of the two involved vector element types VT1::ElementType and VT2::ElementType. Both vector types VT1 and VT2 as well as the two element types VT1::ElementType and VT2::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.
|
inline |
Division operator for the componentwise product of two dense vectors ( ).
lhs | The left-hand side dense vector for the component product. |
rhs | The right-hand side dense vector for the component product. |
std::invalid_argument | Vector sizes do not match. |
This operator represents the component quotient of two dense vectors:
The operator returns an expression representing a dense vector of the higher-order element type of the two involved vector element types VT1::ElementType and VT2::ElementType. Both vector types VT1 and VT2 as well as the two element types VT1::ElementType and VT2::ElementType have to be supported by the DivTrait class template.
In case the current sizes of the two given vectors don't match, a std::invalid_argument is thrown.
|
inline |
Division operator for the divison of a dense vector by a scalar value ( ).
vec | The left-hand side dense vector for the division. |
scalar | The right-hand side scalar value for the division. |
This operator represents the division of a dense vector by a scalar value:
The operator returns an expression representing a dense vector of the higher-order element type of the involved data types VT::ElementType and ST. Both data types VT::ElementType and ST have to be supported by the DivTrait class template. Note that this operator only works for scalar values of built-in data type.
|
inline |
Equality operator for the comparison of two dense vectors.
lhs | The left-hand side dense vector for the comparison. |
rhs | The right-hand side dense vector for the comparison. |
|
inline |
Equality operator for the comparison of a dense vector and a sparse vector.
lhs | The left-hand side dense vector for the comparison. |
rhs | The right-hand side sparse vector for the comparison. |
|
inline |
Equality operator for the comparison of a sparse vector and a dense vector.
lhs | The left-hand side sparse vector for the comparison. |
rhs | The right-hand side dense vector for the comparison. |
|
inline |
Equality operator for the comparison of a dense vector and a scalar value.
vec | The left-hand side dense vector for the comparison. |
scalar | The right-hand side scalar value for the comparison. |
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!
|
inline |
Equality operator for the comparison of a scalar value and a dense vector.
scalar | The left-hand side scalar value for the comparison. |
vec | The right-hand side dense vector for the comparison. |
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!
|
inline |
Computes the exponential value for each single element of the dense vector dv.
dv | The input vector. |
exp | The exponent. |
The pow() function computes the exponential value for each element of the input vector dv. The function returns an expression representing this operation.
The following example demonstrates the use of the pow() function:
|
inline |
Returns a vector containing the real part of each single element of dv.
dv | The input vector. |
The real function calculates the real part of each element of the input vector dv. The function returns an expression representing this operation.
The following example demonstrates the use of the real function:
|
inline |
Applies the round() function to each single element of the dense vector dv.
dv | The input vector. |
This function applies the round() function to each element of the input vector dv. The function returns an expression representing this operation.
The following example demonstrates the use of the round() function:
|
inline |
Forces the serial evaluation of the given dense vector expression dv.
dv | The input 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:
|
inline |
Computes the sine for each single element of the dense vector dv.
dv | The input vector. |
The sin() function computes the sine for each element of the input vector dv. The function returns an expression representing this operation.
The following example demonstrates the use of the sin() function:
|
inline |
Computes the hyperbolic sine for each single element of the dense vector dv.
dv | The input vector. |
The sinh() function computes the hyperbolic sine for each element of the input vector dv. The function returns an expression representing this operation.
The following example demonstrates the use of the sinh() function:
const ElementType_< VT > blaze::sqrLength | ( | const DenseVector< VT, TF > & | dv | ) |
Calculation of the square length (magnitude) of the dense vector .
dv | The given dense vector. |
This function calculates the actual square length (magnitude) of the dense vector.
|
inline |
Computes the square root of each single element of the dense vector dv.
dv | The input vector; all elements must be in the range ![]() |
The sqrt() function computes the square root of each element of the input vector dv. The function returns an expression representing this operation.
The following example demonstrates the use of the sqrt() function:
|
inline |
Computes the tangent for each single element of the dense vector dv.
dv | The input vector. |
The tan() function computes the tangent for each element of the input vector dv. The function returns an expression representing this operation.
The following example demonstrates the use of the tan() function:
|
inline |
Computes the hyperbolic tangent for each single element of the dense vector dv.
dv | The input vector; all elements must be in the range ![]() |
The tanh() function computes the hyperbolic tangent for each element of the input vector dv. The function returns an expression representing this operation.
The following example demonstrates the use of the tanh() function:
|
inline |
Calculation of the transpose of the given dense vector.
dv | The dense vector to be transposed. |
This function returns an expression representing the transpose of the given dense vector:
|
inline |
Applies the trunc() function to each single element of the dense vector dv.
dv | The input vector. |
This function applies the trunc() function to each element of the input vector dv. The function returns an expression representing this operation.
The following example demonstrates the use of the trunc() function:
|
friend |
Addition assignment of a transpose dense vector-transpose sparse matrix multiplication to a dense vector ( ).
lhs | The target left-hand side dense vector. |
rhs | The right-hand side multiplication expression to be added. |
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.
|
friend |
Addition assignment of a transpose dense vector-sparse matrix multiplication to a dense vector ( ).
lhs | The target left-hand side dense vector. |
rhs | The right-hand side multiplication expression to be added. |
This function implements the performance optimized addition assignment of a transpose dense vector-sparse matrix multiplication expression to a dense vector.
|
friend |
Addition assignment of a transpose sparse vector-transpose dense matrix multiplication to a dense vector ( ).
lhs | The target left-hand side dense vector. |
rhs | The right-hand side multiplication expression to be added. |
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.
|
friend |
Addition assignment of a transpose sparse vector-dense matrix multiplication to a dense vector ( ).
lhs | The target left-hand side dense vector. |
rhs | The right-hand side multiplication expression to be added. |
This function implements the performance optimized addition assignment of a transpose sparse vector-dense matrix multiplication expression to a dense vector.
|
friend |
Assignment of a transpose dense vector-sparse matrix multiplication to a dense vector ( ).
lhs | The target left-hand side dense vector. |
rhs | The right-hand side multiplication expression to be assigned. |
This function implements the performance optimized assignment of a transpose dense vector- sparse matrix multiplication expression to a dense vector.
|
friend |
Assignment of a transpose dense vector-transpose sparse matrix multiplication to a dense vector ( ).
lhs | The target left-hand side dense vector. |
rhs | The right-hand side multiplication expression to be assigned. |
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.
|
friend |
Assignment of a transpose dense vector-transpose sparse matrix multiplication to a sparse vector ( ).
lhs | The target left-hand side sparse vector. |
rhs | The right-hand side multiplication expression to be assigned. |
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.
|
friend |
Assignment of a transpose dense vector-sparse matrix multiplication to a sparse vector ( ).
lhs | The target left-hand side sparse vector. |
rhs | The right-hand side multiplication expression to be assigned. |
This function implements the performance optimized assignment of a transpose dense vector- sparse matrix multiplication expression to a sparse vector.
|
friend |
Division assignment of a transpose dense vector-transpose sparse matrix multiplication to a dense vector ( ).
lhs | The target left-hand side dense vector. |
rhs | The right-hand side multiplication expression divisor. |
This function implements the performance optimized division 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.
|
friend |
Division assignment of a transpose sparse vector-transpose dense matrix multiplication to a dense vector ( ).
lhs | The target left-hand side dense vector. |
rhs | The right-hand side multiplication expression divisor. |
This function implements the performance optimized division 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.
|
friend |
Division assignment of a transpose dense vector-sparse matrix multiplication to a dense vector ( ).
lhs | The target left-hand side dense vector. |
rhs | The right-hand side multiplication expression divisor. |
This function implements the performance optimized division assignment of a transpose dense vector-sparse matrix multiplication expression to a dense vector.
|
friend |
Division assignment of a transpose sparse vector-dense matrix multiplication to a dense vector ( ).
lhs | The target left-hand side dense vector. |
rhs | The right-hand side multiplication expression divisor. |
This function implements the performance optimized division assignment of a transpose sparse vector-dense matrix multiplication expression to a dense vector.
|
friend |
Multiplication assignment of a transpose dense vector-transpose sparse matrix multiplication to a dense vector ( ).
lhs | The target left-hand side dense vector. |
rhs | The right-hand side multiplication expression to be multiplied. |
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.
|
friend |
Multiplication assignment of a transpose sparse vector-transpose dense matrix multiplication to a dense vector ( ).
lhs | The target left-hand side dense vector. |
rhs | The right-hand side multiplication expression to be multiplied. |
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.
|
friend |
Multiplication assignment of a transpose dense vector-sparse matrix multiplication to a dense vector ( ).
lhs | The target left-hand side dense vector. |
rhs | The right-hand side multiplication expression to be multiplied. |
This function implements the performance optimized multiplication assignment of a transpose dense vector-sparse matrix multiplication expression to a dense vector.
|
friend |
Multiplication assignment of a transpose sparse vector-dense matrix multiplication to a dense vector ( ).
lhs | The target left-hand side dense vector. |
rhs | The right-hand side multiplication expression to be multiplied. |
This function implements the performance optimized multiplication assignment of a transpose sparse vector-dense matrix multiplication expression to a dense vector.
|
friend |
SMP addition assignment of a transpose dense vector-transpose sparse matrix multiplication to a dense vector ( ).
lhs | The target left-hand side dense vector. |
rhs | The right-hand side multiplication expression to be added. |
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.
|
friend |
SMP addition assignment of a transpose sparse vector-transpose dense matrix multiplication to a dense vector ( ).
lhs | The target left-hand side dense vector. |
rhs | The right-hand side multiplication expression to be added. |
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.
|
friend |
Addition assignment of a transpose dense vector-sparse matrix multiplication to a dense vector ( ).
lhs | The target left-hand side dense vector. |
rhs | The right-hand side multiplication expression to be added. |
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.
|
friend |
SMP addition assignment of a transpose sparse vector-dense matrix multiplication to a dense vector ( ).
lhs | The target left-hand side dense vector. |
rhs | The right-hand side multiplication expression to be added. |
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.
|
friend |
SMP assignment of a transpose dense vector-transpose sparse matrix multiplication to a dense vector ( ).
lhs | The target left-hand side dense vector. |
rhs | The right-hand side multiplication expression to be assigned. |
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.
|
friend |
SMP assignment of a transpose dense vector-transpose sparse matrix multiplication to a sparse vector ( ).
lhs | The target left-hand side sparse vector. |
rhs | The right-hand side multiplication expression to be assigned. |
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.
|
friend |
SMP assignment of a transpose dense vector-sparse matrix multiplication to a dense vector ( ).
lhs | The target left-hand side dense vector. |
rhs | The right-hand side multiplication expression to be assigned. |
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.
|
friend |
SMP assignment of a transpose dense vector-sparse matrix multiplication to a sparse vector ( ).
lhs | The target left-hand side sparse vector. |
rhs | The right-hand side multiplication expression to be assigned. |
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.
|
friend |
SMP division assignment of a transpose dense vector-transpose sparse matrix multiplication to a dense vector ( ).
lhs | The target left-hand side dense vector. |
rhs | The right-hand side multiplication expression divisor. |
This function implements the performance optimized SMP division 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.
|
friend |
SMP division assignment of a transpose sparse vector-transpose dense matrix multiplication to a dense vector ( ).
lhs | The target left-hand side dense vector. |
rhs | The right-hand side multiplication expression divisor. |
This function implements the performance optimized SMP division 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.
|
friend |
SMP division assignment of a transpose dense vector-sparse matrix multiplication to a dense vector ( ).
lhs | The target left-hand side dense vector. |
rhs | The right-hand side multiplication expression divisor. |
This function implements the performance optimized SMP division 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.
|
friend |
SMP division assignment of a transpose sparse vector-dense matrix multiplication to a dense vector ( ).
lhs | The target left-hand side dense vector. |
rhs | The right-hand side multiplication expression divisor. |
This function implements the performance optimized SMP division 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.
|
friend |
SMP multiplication assignment of a transpose dense vector-transpose sparse matrix multiplication to a dense vector ( ).
lhs | The target left-hand side dense vector. |
rhs | The right-hand side multiplication expression to be multiplied. |
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.
|
friend |
SMP multiplication assignment of a transpose sparse vector-transpose dense matrix multiplication to a dense vector ( ).
lhs | The target left-hand side dense vector. |
rhs | The right-hand side multiplication expression to be multiplied. |
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.
|
friend |
SMP multiplication assignment of a transpose dense vector-sparse matrix multiplication to a dense vector ( ).
lhs | The target left-hand side dense vector. |
rhs | The right-hand side multiplication expression to be multiplied. |
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.
|
friend |
SMP multiplication assignment of a transpose sparse vector-dense matrix multiplication to a dense vector ( ).
lhs | The target left-hand side dense vector. |
rhs | The right-hand side multiplication expression to be multiplied. |
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.
|
friend |
SMP subtraction assignment of a transpose dense vector-transpose sparse matrix multiplication to a dense vector ( ).
lhs | The target left-hand side dense vector. |
rhs | The right-hand side multiplication expression to be subtracted. |
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.
|
friend |
SMP subtraction assignment of a transpose sparse vector-transpose dense matrix multiplication to a dense vector ( ).
lhs | The target left-hand side dense vector. |
rhs | The right-hand side multiplication expression to be subtracted. |
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.
|
friend |
SMP subtraction assignment of a transpose dense vector-sparse matrix multiplication to a dense vector ( ).
lhs | The target left-hand side dense vector. |
rhs | The right-hand side multiplication expression to be subtracted. |
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.
|
friend |
SMP subtraction assignment of a transpose sparse vector-dense matrix multiplication to a dense vector ( ).
lhs | The target left-hand side dense vector. |
rhs | The right-hand side multiplication expression to be subtracted. |
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.
|
friend |
Subtraction assignment of a transpose dense vector-transpose sparse matrix multiplication to a dense vector ( ).
lhs | The target left-hand side dense vector. |
rhs | The right-hand side multiplication expression to be subtracted. |
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.
|
friend |
Subtraction assignment of a transpose sparse vector-transpose dense matrix multiplication to a dense vector ( ).
lhs | The target left-hand side dense vector. |
rhs | The right-hand side multiplication expression to be subtracted. |
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.
|
friend |
Subtraction assignment of a transpose dense vector-sparse matrix multiplication to a dense vector ( ).
lhs | The target left-hand side dense vector. |
rhs | The right-hand side multiplication expression to be subtracted. |
This function implements the performance optimized subtraction assignment of a transpose dense vector-sparse matrix multiplication expression to a dense vector.
|
friend |
Subtraction assignment of a transpose sparse vector-dense matrix multiplication to a dense vector ( ).
lhs | The target left-hand side dense vector. |
rhs | The right-hand side multiplication expression to be subtracted. |
This function implements the performance optimized subtraction assignment of a transpose sparse vector-dense matrix multiplication expression to a dense vector.