Modules | Classes | Functions | Friends
Dense Vectors

Modules

 CustomVector
 
 DynamicVector
 
 HybridVector
 
 InitializerVector
 
 StaticVector
 
 UniforVector
 
 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<bool RF, typename VT , bool TF>
bool blaze::isZero (const DenseVector< VT, TF > &dv)
 Checks if the given dense vector is a zero vector. More...
 
template<typename VT , bool TF>
BLAZE_ALWAYS_INLINE VT::ElementType * blaze::data (DenseVector< VT, TF > &dv) noexcept
 Low-level data access to the dense vector elements. More...
 
template<typename VT , bool TF>
BLAZE_ALWAYS_INLINE const VT::ElementType * blaze::data (const DenseVector< VT, TF > &dv) noexcept
 Low-level data access to the dense vector elements. More...
 
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 ( $ \vec{y}=A*\vec{x} $). More...
 
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 ( $ \vec{y}=A*\vec{x} $). More...
 
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 ( $ \vec{a}=\vec{b}+\vec{c} $). More...
 
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 ( $ \vec{a}=\vec{b} \times \vec{c} $). More...
 
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 ( $ \vec{a}=\vec{b} \times \vec{c} $). More...
 
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 quotient of two dense vectors ( $ \vec{a}=\vec{b}/\vec{c} $). More...
 
template<typename VT1 , bool TF1, typename VT2 , bool TF2>
bool blaze::operator== (const DenseVector< VT1, TF1 > &lhs, const DenseVector< VT2, TF2 > &rhs)
 Equality operator for the comparison of two dense vectors. More...
 
template<typename VT1 , bool TF1, typename VT2 , bool TF2>
bool blaze::operator!= (const DenseVector< VT1, TF1 > &lhs, const DenseVector< VT2, TF2 > &rhs)
 Inequality operator for the comparison of two dense vectors. More...
 
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 ( $ s=\vec{a}*\vec{b} $). More...
 
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::hypot (const DenseVector< VT1, TF > &lhs, const DenseVector< VT2, TF > &rhs)
 Computes the componentwise hypotenous for the dense vectors lhs and rhs. More...
 
template<typename VT1 , typename VT2 , bool TF>
decltype(auto) blaze::pow (const DenseVector< VT1, TF > &lhs, const DenseVector< VT2, TF > &rhs)
 Computes the componentwise exponential value for the dense vectors lhs and rhs. More...
 
template<typename VT1 , typename VT2 , bool TF>
decltype(auto) blaze::atan2 (const DenseVector< VT1, TF > &lhs, const DenseVector< VT2, TF > &rhs)
 Computes the multi-valued inverse tangent 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 ( $ \vec{a}=\vec{b}*\vec{c} $). More...
 
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 ( $ \vec{a}=\vec{b}-\vec{c} $). More...
 
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>
decltype(auto) blaze::expand (const DenseVector< VT, TF > &dv, size_t expansion)
 Expansion of the given dense vector. More...
 
template<size_t E, typename VT , bool TF>
decltype(auto) blaze::expand (const DenseVector< VT, TF > &dv)
 Expansion of the given dense vector. 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::sign (const DenseVector< VT, TF > &dv)
 Applies the sign() 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 $[min..max]$. More...
 
template<typename VT , bool TF, typename ST , EnableIf_t< IsNumeric_v< ST > > * = nullptr>
decltype(auto) blaze::pow (const DenseVector< VT, TF > &dv, ST 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 $ e^x $ for each single element of the dense vector dv. More...
 
template<typename VT , bool TF>
decltype(auto) blaze::exp2 (const DenseVector< VT, TF > &dv)
 Computes $ 2^x $ for each single element of the dense vector dv. More...
 
template<typename VT , bool TF>
decltype(auto) blaze::exp10 (const DenseVector< VT, TF > &dv)
 Computes $ 10^x $ for each single element of the dense vector dv. More...
 
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 , bool TF>
decltype(auto) blaze::norm (const DenseVector< VT, TF > &dv)
 Computes the L2 norm for the given dense vector. More...
 
template<typename VT , bool TF>
decltype(auto) blaze::sqrNorm (const DenseVector< VT, TF > &dv)
 Computes the squared L2 norm for the given dense vector. More...
 
template<typename VT , bool TF>
decltype(auto) blaze::l1Norm (const DenseVector< VT, TF > &dv)
 Computes the L1 norm for the given dense vector. More...
 
template<typename VT , bool TF>
decltype(auto) blaze::l2Norm (const DenseVector< VT, TF > &dv)
 Computes the L2 norm for the given dense vector. More...
 
template<typename VT , bool TF>
decltype(auto) blaze::l3Norm (const DenseVector< VT, TF > &dv)
 Computes the L3 norm for the given dense vector. More...
 
template<typename VT , bool TF>
decltype(auto) blaze::l4Norm (const DenseVector< VT, TF > &dv)
 Computes the L4 norm for the given dense vector. More...
 
template<typename VT , bool TF, typename ST >
decltype(auto) blaze::lpNorm (const DenseVector< VT, TF > &dv, ST p)
 Computes the Lp norm for the given dense vector. More...
 
template<size_t P, typename VT , bool TF>
decltype(auto) blaze::lpNorm (const DenseVector< VT, TF > &dv)
 Computes the Lp norm for the given dense vector. More...
 
template<typename VT , bool TF>
decltype(auto) blaze::maxNorm (const DenseVector< VT, TF > &dv)
 Computes the maximum norm for the given dense vector. More...
 
template<typename VT , bool TF, typename OP >
decltype(auto) blaze::reduce (const DenseVector< VT, TF > &dv, OP op)
 Performs a custom reduction operation on the given dense vector. More...
 
template<typename VT , bool TF>
decltype(auto) blaze::sum (const DenseVector< VT, TF > &dv)
 Reduces the given dense vector by means of addition. More...
 
template<typename VT , bool TF>
decltype(auto) blaze::prod (const DenseVector< VT, TF > &dv)
 Reduces the given dense vector by means of multiplication. More...
 
template<typename VT , bool TF>
decltype(auto) blaze::min (const DenseVector< VT, TF > &dv)
 Returns the smallest element of the dense vector. More...
 
template<typename VT , bool TF>
decltype(auto) blaze::max (const DenseVector< VT, TF > &dv)
 Returns the largest element of the dense vector. More...
 
template<typename VT , typename ST , bool TF, EnableIf_t< IsNumeric_v< ST > > * = nullptr>
decltype(auto) blaze::operator/ (const DenseVector< VT, TF > &vec, ST scalar)
 Division operator for the divison of a dense vector by a scalar value ( $ \vec{a}=\vec{b}/s $). More...
 
template<typename VT , bool TF>
decltype(auto) blaze::operator- (const DenseVector< VT, TF > &dv)
 Unary minus operator for the negation of a dense vector ( $ \vec{a} = -\vec{b} $). More...
 
template<typename VT , typename ST , bool TF, EnableIf_t< IsNumeric_v< ST > > * = nullptr>
decltype(auto) blaze::operator* (const DenseVector< VT, TF > &vec, ST scalar)
 Multiplication operator for the multiplication of a dense vector and a scalar value ( $ \vec{a}=\vec{b}*s $). More...
 
template<typename ST , typename VT , bool TF, EnableIf_t< IsNumeric_v< ST > > * = nullptr>
decltype(auto) blaze::operator* (ST scalar, const DenseVector< VT, TF > &vec)
 Multiplication operator for the multiplication of a scalar value and a dense vector ( $ \vec{a}=s*\vec{b} $). More...
 
template<typename VT , bool TF>
decltype(auto) blaze::serial (const DenseVector< VT, TF > &dv)
 Forces the serial evaluation of the given dense vector expression dv. More...
 
template<typename VT , bool TF>
auto blaze::softmax (const DenseVector< VT, TF > &dv)
 Computes the softmax function for the given dense vector. 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 ( $ \vec{a}=\vec{b}+\vec{c} $). More...
 
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 ( $ \vec{a}=\vec{b}+\vec{c} $). More...
 
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 ( $ \vec{a}=\vec{b} \times \vec{c} $). More...
 
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 ( $ \vec{a}=\vec{b} \times \vec{c} $). More...
 
template<typename VT1 , bool TF1, typename VT2 , bool TF2>
bool blaze::operator== (const DenseVector< VT1, TF1 > &lhs, const SparseVector< VT2, TF2 > &rhs)
 Equality operator for the comparison of a dense vector and a sparse vector. More...
 
template<typename VT1 , bool TF1, typename VT2 , bool TF2>
bool blaze::operator== (const SparseVector< VT1, TF1 > &lhs, const DenseVector< VT2, TF2 > &rhs)
 Equality operator for the comparison of a sparse vector and a dense vector. More...
 
template<typename VT1 , bool TF1, typename VT2 , bool TF2>
bool blaze::operator!= (const DenseVector< VT1, TF1 > &lhs, const SparseVector< VT2, TF2 > &rhs)
 Inequality operator for the comparison of a dense vector and a sparse vector. More...
 
template<typename VT1 , bool TF1, typename VT2 , bool TF2>
bool blaze::operator!= (const SparseVector< VT1, TF1 > &lhs, const DenseVector< VT2, TF2 > &rhs)
 Inequality operator for the comparison of a sparse vector and a dense vector. More...
 
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 ( $ \vec{a}=\vec{b}-\vec{c} $). More...
 
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<bool TTF, typename VT , bool TF>
decltype(auto) blaze::transTo (const DenseVector< VT, TF > &dv)
 Conditional 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 ( $ \vec{y}=A*\vec{x} $). More...
 
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 ( $ \vec{a}=\vec{b} \times \vec{c} $). More...
 
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 ( $ \vec{a}=\vec{b} \times \vec{c} $). More...
 
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 ( $ \vec{a}=\vec{b}-\vec{c} $). More...
 
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 ( $ \vec{a}=\vec{b} \times \vec{c} $). More...
 
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 ( $ \vec{a}=\vec{b} \times \vec{c} $). More...
 
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 ( $ \vec{y}=A*\vec{x} $). More...
 
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 ( $ \vec{y}=A*\vec{x} $). More...
 
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 ( $ \vec{y}^T=\vec{x}^T*A $). More...
 
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 ( $ \vec{y}^T=\vec{x}^T*A $). More...
 
template<typename VT , typename MT >
decltype(auto) blaze::operator* (const DenseVector< VT, true > &vec, const SparseMatrix< MT, true > &mat)
 Multiplication operator for the multiplication of a transpose dense vector and a column-major sparse matrix ( $ \vec{y}^T=\vec{x}^T*A $). More...
 
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 ( $ \vec{y}=A*\vec{x} $). More...
 
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 ( $ \vec{y}^T=\vec{x}^T*A $). More...
 

Friends

template<typename VT2 >
void blaze::TDVecSMatMultExpr< VT, MT >::assign (DenseVector< VT2, true > &lhs, const TDVecSMatMultExpr &rhs)
 Assignment of a transpose dense vector-sparse matrix multiplication to a dense vector ( $ \vec{y}^T=\vec{x}^T*A $). More...
 
template<typename VT2 >
void blaze::TDVecSMatMultExpr< VT, MT >::assign (SparseVector< VT2, true > &lhs, const TDVecSMatMultExpr &rhs)
 Assignment of a transpose dense vector-sparse matrix multiplication to a sparse vector ( $ \vec{y}^T=\vec{x}^T*A $). More...
 
template<typename VT2 >
void blaze::TDVecSMatMultExpr< VT, MT >::addAssign (DenseVector< VT2, true > &lhs, const TDVecSMatMultExpr &rhs)
 Addition assignment of a transpose dense vector-sparse matrix multiplication to a dense vector ( $ \vec{y}^T+=\vec{x}^T*A $). More...
 
template<typename VT2 >
void blaze::TDVecSMatMultExpr< VT, MT >::subAssign (DenseVector< VT2, true > &lhs, const TDVecSMatMultExpr &rhs)
 Subtraction assignment of a transpose dense vector-sparse matrix multiplication to a dense vector ( $ \vec{y}^T-=\vec{x}^T*A $). More...
 
template<typename VT2 >
void blaze::TDVecSMatMultExpr< VT, MT >::multAssign (DenseVector< VT2, true > &lhs, const TDVecSMatMultExpr &rhs)
 Multiplication assignment of a transpose dense vector-sparse matrix multiplication to a dense vector ( $ \vec{y}^T*=\vec{x}^T*A $). More...
 
template<typename VT2 >
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 ( $ \vec{y}^T/=\vec{x}^T*A $). More...
 
template<typename VT2 >
auto blaze::TDVecSMatMultExpr< VT, MT >::smpAssign (DenseVector< VT2, true > &lhs, const TDVecSMatMultExpr &rhs) -> EnableIf_t< UseSMPAssign_v< VT2 > >
 SMP assignment of a transpose dense vector-sparse matrix multiplication to a dense vector ( $ \vec{y}^T=\vec{x}^T*A $). More...
 
template<typename VT2 >
auto blaze::TDVecSMatMultExpr< VT, MT >::smpAssign (SparseVector< VT2, true > &lhs, const TDVecSMatMultExpr &rhs) -> EnableIf_t< UseSMPAssign_v< VT2 > >
 SMP assignment of a transpose dense vector-sparse matrix multiplication to a sparse vector ( $ \vec{y}^T=\vec{x}^T*A $). More...
 
template<typename VT2 >
auto blaze::TDVecSMatMultExpr< VT, MT >::smpAddAssign (DenseVector< VT2, true > &lhs, const TDVecSMatMultExpr &rhs) -> EnableIf_t< UseSMPAssign_v< VT2 > >
 Addition assignment of a transpose dense vector-sparse matrix multiplication to a dense vector ( $ \vec{y}^T+=\vec{x}^T*A $). More...
 
template<typename VT2 >
auto blaze::TDVecSMatMultExpr< VT, MT >::smpSubAssign (DenseVector< VT2, true > &lhs, const TDVecSMatMultExpr &rhs) -> EnableIf_t< UseSMPAssign_v< VT2 > >
 SMP subtraction assignment of a transpose dense vector-sparse matrix multiplication to a dense vector ( $ \vec{y}^T-=\vec{x}^T*A $). More...
 
template<typename VT2 >
auto blaze::TDVecSMatMultExpr< VT, MT >::smpMultAssign (DenseVector< VT2, true > &lhs, const TDVecSMatMultExpr &rhs) -> EnableIf_t< UseSMPAssign_v< VT2 > >
 SMP multiplication assignment of a transpose dense vector-sparse matrix multiplication to a dense vector ( $ \vec{y}^T*=\vec{x}^T*A $). More...
 
template<typename VT2 >
auto blaze::TDVecSMatMultExpr< VT, MT >::smpDivAssign (DenseVector< VT2, true > &lhs, const TDVecSMatMultExpr &rhs) -> EnableIf_t< UseSMPAssign_v< VT2 > >
 SMP division assignment of a transpose dense vector-sparse matrix multiplication to a dense vector ( $ \vec{y}^T/=\vec{x}^T*A $). More...
 
template<typename VT2 >
auto blaze::TDVecTSMatMultExpr< VT, MT >::assign (DenseVector< VT2, true > &lhs, const TDVecTSMatMultExpr &rhs) -> EnableIf_t< UseAssign_v< VT2 > >
 Assignment of a transpose dense vector-transpose sparse matrix multiplication to a dense vector ( $ \vec{y}^T=\vec{x}^T*A $). More...
 
template<typename VT2 >
auto blaze::TDVecTSMatMultExpr< VT, MT >::assign (SparseVector< VT2, true > &lhs, const TDVecTSMatMultExpr &rhs) -> EnableIf_t< UseAssign_v< VT2 > >
 Assignment of a transpose dense vector-transpose sparse matrix multiplication to a sparse vector ( $ \vec{y}^T=\vec{x}^T*A $). More...
 
template<typename VT2 >
auto blaze::TDVecTSMatMultExpr< VT, MT >::addAssign (DenseVector< VT2, true > &lhs, const TDVecTSMatMultExpr &rhs) -> EnableIf_t< UseAssign_v< VT2 > >
 Addition assignment of a transpose dense vector-transpose sparse matrix multiplication to a dense vector ( $ \vec{y}^T+=\vec{x}^T*A $). More...
 
template<typename VT2 >
auto blaze::TDVecTSMatMultExpr< VT, MT >::subAssign (DenseVector< VT2, true > &lhs, const TDVecTSMatMultExpr &rhs) -> EnableIf_t< UseAssign_v< VT2 > >
 Subtraction assignment of a transpose dense vector-transpose sparse matrix multiplication to a dense vector ( $ \vec{y}^T-=\vec{x}^T*A $). More...
 
template<typename VT2 >
auto blaze::TDVecTSMatMultExpr< VT, MT >::multAssign (DenseVector< VT2, true > &lhs, const TDVecTSMatMultExpr &rhs) -> EnableIf_t< UseAssign_v< VT2 > >
 Multiplication assignment of a transpose dense vector-transpose sparse matrix multiplication to a dense vector ( $ \vec{y}^T*=\vec{x}^T*A $). More...
 
template<typename VT2 >
auto blaze::TDVecTSMatMultExpr< VT, MT >::divAssign (DenseVector< VT2, true > &lhs, const TDVecTSMatMultExpr &rhs) -> EnableIf_t< UseAssign_v< VT2 > >
 Division assignment of a transpose dense vector-transpose sparse matrix multiplication to a dense vector ( $ \vec{y}^T/=\vec{x}^T*A $). More...
 
template<typename VT2 >
auto blaze::TDVecTSMatMultExpr< VT, MT >::smpAssign (DenseVector< VT2, true > &lhs, const TDVecTSMatMultExpr &rhs) -> EnableIf_t< UseSMPAssign_v< VT2 > >
 SMP assignment of a transpose dense vector-transpose sparse matrix multiplication to a dense vector ( $ \vec{y}^T=\vec{x}^T*A $). More...
 
template<typename VT2 >
auto blaze::TDVecTSMatMultExpr< VT, MT >::smpAssign (SparseVector< VT2, true > &lhs, const TDVecTSMatMultExpr &rhs) -> EnableIf_t< UseSMPAssign_v< VT2 > >
 SMP assignment of a transpose dense vector-transpose sparse matrix multiplication to a sparse vector ( $ \vec{y}^T=\vec{x}^T*A $). More...
 
template<typename VT2 >
auto blaze::TDVecTSMatMultExpr< VT, MT >::smpAddAssign (DenseVector< VT2, true > &lhs, const TDVecTSMatMultExpr &rhs) -> EnableIf_t< UseSMPAssign_v< VT2 > >
 SMP addition assignment of a transpose dense vector-transpose sparse matrix multiplication to a dense vector ( $ \vec{y}^T+=\vec{x}^T*A $). More...
 
template<typename VT2 >
auto blaze::TDVecTSMatMultExpr< VT, MT >::smpSubAssign (DenseVector< VT2, true > &lhs, const TDVecTSMatMultExpr &rhs) -> EnableIf_t< UseSMPAssign_v< VT2 > >
 SMP subtraction assignment of a transpose dense vector-transpose sparse matrix multiplication to a dense vector ( $ \vec{y}^T-=\vec{x}^T*A $). More...
 
template<typename VT2 >
auto blaze::TDVecTSMatMultExpr< VT, MT >::smpMultAssign (DenseVector< VT2, true > &lhs, const TDVecTSMatMultExpr &rhs) -> EnableIf_t< UseSMPAssign_v< VT2 > >
 SMP multiplication assignment of a transpose dense vector-transpose sparse matrix multiplication to a dense vector ( $ \vec{y}^T*=\vec{x}^T*A $). More...
 
template<typename VT2 >
auto blaze::TDVecTSMatMultExpr< VT, MT >::smpDivAssign (DenseVector< VT2, true > &lhs, const TDVecTSMatMultExpr &rhs) -> EnableIf_t< UseSMPAssign_v< VT2 > >
 SMP division assignment of a transpose dense vector-transpose sparse matrix multiplication to a dense vector ( $ \vec{y}^T/=\vec{x}^T*A $). More...
 
template<typename VT2 >
void blaze::TSVecDMatMultExpr< VT, MT >::addAssign (DenseVector< VT2, true > &lhs, const TSVecDMatMultExpr &rhs)
 Addition assignment of a transpose sparse vector-dense matrix multiplication to a dense vector ( $ \vec{y}^T+=\vec{x}^T*A $). More...
 
template<typename VT2 >
void blaze::TSVecDMatMultExpr< VT, MT >::subAssign (DenseVector< VT2, true > &lhs, const TSVecDMatMultExpr &rhs)
 Subtraction assignment of a transpose sparse vector-dense matrix multiplication to a dense vector ( $ \vec{y}^T-=\vec{x}^T*A $). More...
 
template<typename VT2 >
void blaze::TSVecDMatMultExpr< VT, MT >::multAssign (DenseVector< VT2, true > &lhs, const TSVecDMatMultExpr &rhs)
 Multiplication assignment of a transpose sparse vector-dense matrix multiplication to a dense vector ( $ \vec{y}^T*=\vec{x}^T*A $). More...
 
template<typename VT2 >
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 ( $ \vec{y}^T/=\vec{x}^T*A $). More...
 
template<typename VT2 >
auto blaze::TSVecDMatMultExpr< VT, MT >::smpAddAssign (DenseVector< VT2, true > &lhs, const TSVecDMatMultExpr &rhs) -> EnableIf_t< UseSMPAssign_v< VT2 > >
 SMP addition assignment of a transpose sparse vector-dense matrix multiplication to a dense vector ( $ \vec{y}^T+=\vec{x}^T*A $). More...
 
template<typename VT2 >
auto blaze::TSVecDMatMultExpr< VT, MT >::smpSubAssign (DenseVector< VT2, true > &lhs, const TSVecDMatMultExpr &rhs) -> EnableIf_t< UseSMPAssign_v< VT2 > >
 SMP subtraction assignment of a transpose sparse vector-dense matrix multiplication to a dense vector ( $ \vec{y}^T-=\vec{x}^T*A $). More...
 
template<typename VT2 >
auto blaze::TSVecDMatMultExpr< VT, MT >::smpMultAssign (DenseVector< VT2, true > &lhs, const TSVecDMatMultExpr &rhs) -> EnableIf_t< UseSMPAssign_v< VT2 > >
 SMP multiplication assignment of a transpose sparse vector-dense matrix multiplication to a dense vector ( $ \vec{y}^T*=\vec{x}^T*A $). More...
 
template<typename VT2 >
auto blaze::TSVecDMatMultExpr< VT, MT >::smpDivAssign (DenseVector< VT2, true > &lhs, const TSVecDMatMultExpr &rhs) -> EnableIf_t< UseSMPAssign_v< VT2 > >
 SMP division assignment of a transpose sparse vector-dense matrix multiplication to a dense vector ( $ \vec{y}^T/=\vec{x}^T*A $). More...
 
template<typename VT2 >
auto blaze::TSVecTDMatMultExpr< VT, MT >::addAssign (DenseVector< VT2, true > &lhs, const TSVecTDMatMultExpr &rhs) -> EnableIf_t< UseAssign_v< VT2 > >
 Addition assignment of a transpose sparse vector-transpose dense matrix multiplication to a dense vector ( $ \vec{y}^T+=\vec{x}^T*A $). More...
 
template<typename VT2 >
auto blaze::TSVecTDMatMultExpr< VT, MT >::subAssign (DenseVector< VT2, true > &lhs, const TSVecTDMatMultExpr &rhs) -> EnableIf_t< UseAssign_v< VT2 > >
 Subtraction assignment of a transpose sparse vector-transpose dense matrix multiplication to a dense vector ( $ \vec{y}^T-=\vec{x}^T*A $). More...
 
template<typename VT2 >
auto blaze::TSVecTDMatMultExpr< VT, MT >::multAssign (DenseVector< VT2, true > &lhs, const TSVecTDMatMultExpr &rhs) -> EnableIf_t< UseAssign_v< VT2 > >
 Multiplication assignment of a transpose sparse vector-transpose dense matrix multiplication to a dense vector ( $ \vec{y}^T*=\vec{x}^T*A $). More...
 
template<typename VT2 >
auto blaze::TSVecTDMatMultExpr< VT, MT >::divAssign (DenseVector< VT2, true > &lhs, const TSVecTDMatMultExpr &rhs) -> EnableIf_t< UseAssign_v< VT2 > >
 Division assignment of a transpose sparse vector-transpose dense matrix multiplication to a dense vector ( $ \vec{y}^T/=\vec{x}^T*A $). More...
 
template<typename VT2 >
auto blaze::TSVecTDMatMultExpr< VT, MT >::smpAddAssign (DenseVector< VT2, true > &lhs, const TSVecTDMatMultExpr &rhs) -> EnableIf_t< UseSMPAssign_v< VT2 > >
 SMP addition assignment of a transpose sparse vector-transpose dense matrix multiplication to a dense vector ( $ \vec{y}^T+=\vec{x}^T*A $). More...
 
template<typename VT2 >
auto blaze::TSVecTDMatMultExpr< VT, MT >::smpSubAssign (DenseVector< VT2, true > &lhs, const TSVecTDMatMultExpr &rhs) -> EnableIf_t< UseSMPAssign_v< VT2 > >
 SMP subtraction assignment of a transpose sparse vector-transpose dense matrix multiplication to a dense vector ( $ \vec{y}^T-=\vec{x}^T*A $). More...
 
template<typename VT2 >
auto blaze::TSVecTDMatMultExpr< VT, MT >::smpMultAssign (DenseVector< VT2, true > &lhs, const TSVecTDMatMultExpr &rhs) -> EnableIf_t< UseSMPAssign_v< VT2 > >
 SMP multiplication assignment of a transpose sparse vector-transpose dense matrix multiplication to a dense vector ( $ \vec{y}^T*=\vec{x}^T*A $). More...
 
template<typename VT2 >
auto blaze::TSVecTDMatMultExpr< VT, MT >::smpDivAssign (DenseVector< VT2, true > &lhs, const TSVecTDMatMultExpr &rhs) -> EnableIf_t< UseSMPAssign_v< VT2 > >
 SMP division assignment of a transpose sparse vector-transpose dense matrix multiplication to a dense vector ( $ \vec{y}^T/=\vec{x}^T*A $). More...
 

DenseVector operators

template<typename T1 , typename T2 , bool TF>
auto blaze::operator== (const DenseVector< T1, TF > &vec, T2 scalar) -> EnableIf_t< IsNumeric_v< T2 >, bool >
 Equality operator for the comparison of a dense vector and a scalar value. More...
 
template<typename T1 , typename T2 , bool TF>
auto blaze::operator== (T1 scalar, const DenseVector< T2, TF > &vec) -> EnableIf_t< IsNumeric_v< T1 >, bool >
 Equality operator for the comparison of a scalar value and a dense vector. More...
 
template<typename T1 , typename T2 , bool TF>
auto blaze::operator!= (const DenseVector< T1, TF > &vec, T2 scalar) -> EnableIf_t< IsNumeric_v< T2 >, bool >
 Inequality operator for the comparison of a dense vector and a scalar value. More...
 
template<typename T1 , typename T2 , bool TF>
auto blaze::operator!= (T1 scalar, const DenseVector< T2, TF > &vec) -> EnableIf_t< IsNumeric_v< T1 >, bool >
 Inequality operator for the comparison of a scalar value and a dense vector. More...
 
template<typename VT , bool TF, typename ST >
auto blaze::operator*= (DenseVector< VT, TF > &vec, ST scalar) -> EnableIf_t< IsNumeric_v< ST >, VT &>
 Multiplication assignment operator for the multiplication of a dense vector and a scalar value ( $ \vec{a}*=s $). More...
 
template<typename VT , bool TF, typename ST >
auto blaze::operator*= (DenseVector< VT, TF > &&vec, ST scalar) -> EnableIf_t< IsNumeric_v< ST >, VT &>
 Multiplication assignment operator for the multiplication of a temporary dense vector and a scalar ( $ v*=s $). More...
 
template<typename VT , bool TF, typename ST >
auto blaze::operator/= (DenseVector< VT, TF > &vec, ST scalar) -> EnableIf_t< IsNumeric_v< ST >, VT &>
 Division assignment operator for the division of a dense vector by a scalar value ( $ \vec{a}/=s $). More...
 
template<typename VT , bool TF, typename ST >
auto blaze::operator/= (DenseVector< VT, TF > &&vec, ST scalar) -> EnableIf_t< IsNumeric_v< ST >, VT &>
 Division assignment operator for the division of a temporary dense vector by a scalar value ( $ \vec{a}/=s $). 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<bool RF, 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_t< VT > blaze::sqrLength (const DenseVector< VT, TF > &dv)
 Calculation of the square length (magnitude) of the dense vector $|\vec{a}|^2$. More...
 
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 $|\vec{a}|$. More...
 

Detailed Description

Function Documentation

◆ abs()

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

Applies the abs() function to each single element of the dense vector dv.

Parameters
dvThe input vector.
Returns
The resulting dense 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:

// ... Resizing and initialization
b = abs( a );

◆ acos()

template<typename VT , bool TF>
decltype(auto) blaze::acos ( const DenseVector< VT, TF > &  dv)
inline

Computes the inverse cosine for each single element of the dense vector dv.

Parameters
dvThe input vector; all elements must be in the range $[-1..1]$.
Returns
The inverse cosine of each single element of dv.

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:

// ... Resizing and initialization
b = acos( a );
Note
All elements are expected to be in the range $[-1..1]$. No runtime checks are performed to assert this precondition!

◆ acosh()

template<typename VT , bool TF>
decltype(auto) blaze::acosh ( const DenseVector< VT, TF > &  dv)
inline

Computes the inverse hyperbolic cosine for each single element of the dense vector dv.

Parameters
dvThe input vector; all elements must be in the range $[1..\infty)$.
Returns
The inverse hyperbolic cosine of each single element of dv.

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:

// ... Resizing and initialization
b = acosh( a );
Note
All elements are expected to be in the range $[1..\infty)$. No runtime checks are performed to assert this precondition!

◆ asin()

template<typename VT , bool TF>
decltype(auto) blaze::asin ( const DenseVector< VT, TF > &  dv)
inline

Computes the inverse sine for each single element of the dense vector dv.

Parameters
dvThe input vector; all elements must be in the range $[-1..1]$.
Returns
The inverse sine of each single element of dv.

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:

// ... Resizing and initialization
b = asin( a );
Note
All elements are expected to be in the range $[-1..1]$. No runtime checks are performed to assert this precondition!

◆ asinh()

template<typename VT , bool TF>
decltype(auto) blaze::asinh ( const DenseVector< VT, TF > &  dv)
inline

Computes the inverse hyperbolic sine for each single element of the dense vector dv.

Parameters
dvThe input vector.
Returns
The inverse hyperbolic sine of each single element of dv.

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:

// ... Resizing and initialization
b = asinh( a );

◆ atan()

template<typename VT , bool TF>
decltype(auto) blaze::atan ( const DenseVector< VT, TF > &  dv)
inline

Computes the inverse tangent for each single element of the dense vector dv.

Parameters
dvThe input vector.
Returns
The inverse tangent of each single element of dv.

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:

// ... Resizing and initialization
b = atan( a );

◆ atan2()

template<typename VT1 , typename VT2 , bool TF>
decltype(auto) blaze::atan2 ( const DenseVector< VT1, TF > &  lhs,
const DenseVector< VT2, TF > &  rhs 
)
inline

Computes the multi-valued inverse tangent of the dense vectors lhs and rhs.

Parameters
lhsThe left-hand side dense vector operand.
rhsThe right-hand side dense vector operand.
Returns
The resulting dense vector.

This function computes the multi-valued inverse tangent of the two dense vectors lhs and rhs. The function returns an expression representing this operation.
The following example demonstrates the use of the atan2() function:

// ... Resizing and initialization
c = atan2( a, b );

◆ atanh()

template<typename VT , bool TF>
decltype(auto) blaze::atanh ( const DenseVector< VT, TF > &  dv)
inline

Computes the inverse hyperbolic tangent for each single element of the dense vector dv.

Parameters
dvThe input vector; all elements must be in the range $[-1..1]$.
Returns
The inverse hyperbolic tangent of each single element of dv.

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:

// ... Resizing and initialization
b = atanh( a );
Note
All elements are expected to be in the range $[-1..1]$. No runtime checks are performed to assert this precondition!

◆ cbrt()

template<typename VT , bool TF>
decltype(auto) blaze::cbrt ( const DenseVector< VT, TF > &  dv)
inline

Computes the cubic root of each single element of the dense vector dv.

Parameters
dvThe input vector; all elements must be in the range $[0..\infty)$.
Returns
The cubic root of each single element of dv.

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:

// ... Resizing and initialization
b = cbrt( a );
Note
All elements are expected to be in the range $[0..\infty)$. No runtime checks are performed to assert this precondition!

◆ ceil()

template<typename VT , bool TF>
decltype(auto) blaze::ceil ( const DenseVector< VT, TF > &  dv)
inline

Applies the ceil() function to each single element of the dense vector dv.

Parameters
dvThe input vector.
Returns
The resulting dense 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:

// ... Resizing and initialization
b = ceil( a );

◆ clamp()

template<typename VT , bool TF, typename DT >
decltype(auto) blaze::clamp ( const DenseVector< VT, TF > &  dv,
const DT &  min,
const DT &  max 
)
inline

Restricts each single element of the dense vector dv to the range $[min..max]$.

Parameters
dvThe input vector.
minThe lower delimiter.
maxThe upper delimiter.
Returns
The vector with restricted elements.

The clamp() function restricts each element of the input vector dv to the range $[min..max]$. The function returns an expression representing this operation.
The following example demonstrates the use of the clamp() function:

// ... Resizing and initialization
b = clamp( a, -1.0, 1.0 );

◆ conj()

template<typename VT , bool TF>
decltype(auto) blaze::conj ( const DenseVector< VT, TF > &  dv)
inline

Returns a vector containing the complex conjugate of each single element of dv.

Parameters
dvThe input vector.
Returns
The complex conjugate of each single element of dv.

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:

// ... Resizing and initialization
b = conj( a );

◆ cos()

template<typename VT , bool TF>
decltype(auto) blaze::cos ( const DenseVector< VT, TF > &  dv)
inline

Computes the cosine for each single element of the dense vector dv.

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

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:

// ... Resizing and initialization
b = cos( a );

◆ cosh()

template<typename VT , bool TF>
decltype(auto) blaze::cosh ( const DenseVector< VT, TF > &  dv)
inline

Computes the hyperbolic cosine for each single element of the dense vector dv.

Parameters
dvThe input vector.
Returns
The hyperbolic cosine of each single element of dv.

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:

// ... Resizing and initialization
b = cosh( a );

◆ cross() [1/4]

template<typename VT1 , typename VT2 , bool TF>
decltype(auto) blaze::cross ( const DenseVector< VT1, TF > &  lhs,
const DenseVector< VT2, TF > &  rhs 
)
inline

Cross product of two dense vectors ( $ \vec{a}=\vec{b} \times \vec{c} $).

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

This function computes the cross product of two dense vectors:

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

The operator returns an expression representing a dense vector of the higher-order element type of the two involved vector element types 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.

◆ cross() [2/4]

template<typename VT1 , typename VT2 , bool TF>
decltype(auto) blaze::cross ( const SparseVector< VT1, TF > &  lhs,
const SparseVector< VT2, TF > &  rhs 
)
inline

Cross product of two sparse vectors ( $ \vec{a}=\vec{b} \times \vec{c} $).

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

This function computes the cross product of two sparse vectors:

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

The operator returns a dense vector of the higher-order element type of the two involved vector element types 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.

◆ cross() [3/4]

template<typename VT1 , typename VT2 , bool TF>
decltype(auto) blaze::cross ( const DenseVector< VT1, TF > &  lhs,
const SparseVector< VT2, TF > &  rhs 
)
inline

Cross product of a dense vector and a sparse vector ( $ \vec{a}=\vec{b} \times \vec{c} $).

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

This function computes the cross product of a dense vector and a sparse vector:

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

The operator returns an expression representing a dense vector of the higher-order element type of the two involved vector element types 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.

◆ cross() [4/4]

template<typename VT1 , typename VT2 , bool TF>
decltype(auto) blaze::cross ( const SparseVector< VT1, TF > &  lhs,
const DenseVector< VT2, TF > &  rhs 
)
inline

Cross product of a sparse vector and a dense vector ( $ \vec{a}=\vec{b} \times \vec{c} $).

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

This function computes the cross product of a sparse vector and a dense vector:

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

The operator returns an expression representing a dense vector of the higher-order element type of the two involved vector element types 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.

◆ ctrans()

template<typename VT , bool TF>
decltype(auto) blaze::ctrans ( const DenseVector< VT, TF > &  dv)
inline

Returns the conjugate transpose vector of dv.

Parameters
dvThe input vector.
Returns
The conjugate transpose of dv.

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:

// ... Resizing and initialization
b = ctrans( a );

Note that the ctrans function has the same effect as manually applying the conj and trans function in any order:

b = trans( conj( a ) ); // Computing the conjugate transpose vector
b = conj( trans( a ) ); // Computing the conjugate transpose vector

◆ data() [1/2]

template<typename VT , bool TF>
BLAZE_ALWAYS_INLINE VT::ElementType* blaze::data ( DenseVector< VT, TF > &  dv)
noexcept

Low-level data access to the dense vector elements.

Parameters
dvThe given dense vector.
Returns
Pointer to the internal element storage.

This function provides a unified interface to access the given dense vector's internal element storage. In contrast to the data() member function, which is only available in case the vector has some internal storage, this function can be used on all kinds of dense vectors. In case the given dense vector does not provide low-level data access, the function returns nullptr.

◆ data() [2/2]

template<typename VT , bool TF>
BLAZE_ALWAYS_INLINE const VT::ElementType* blaze::data ( const DenseVector< VT, TF > &  dv)
noexcept

Low-level data access to the dense vector elements.

Parameters
dvThe given dense vector.
Returns
Pointer to the internal element storage.

This function provides a unified interface to access the given dense vector's internal element storage. In contrast to the data() member function, which is only available in case the vector has some internal storage, this function can be used on all kinds of dense vectors. In case the given dense vector does not provide low-level data access, the function returns nullptr.

◆ erf()

template<typename VT , bool TF>
decltype(auto) blaze::erf ( const DenseVector< VT, TF > &  dv)
inline

Computes the error function for each single element of the dense vector dv.

Parameters
dvThe input vector.
Returns
The error function of each single element of dv.

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:

// ... Resizing and initialization
b = erf( a );

◆ erfc()

template<typename VT , bool TF>
decltype(auto) blaze::erfc ( const DenseVector< VT, TF > &  dv)
inline

Computes the complementary error function for each single element of the dense vector dv.

Parameters
dvThe input vector.
Returns
The complementary error function of each single element of dv.

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:

// ... Resizing and initialization
b = erfc( a );

◆ eval()

template<typename VT , bool TF>
decltype(auto) blaze::eval ( const DenseVector< VT, TF > &  dv)
inline

Forces the evaluation of the given dense vector expression dv.

Parameters
dvThe input vector.
Returns
The evaluated dense vector.

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

// ... Resizing and initialization
b = eval( a );

◆ exp()

template<typename VT , bool TF>
decltype(auto) blaze::exp ( const DenseVector< VT, TF > &  dv)
inline

Computes $ e^x $ for each single element of the dense vector dv.

Parameters
dvThe input vector.
Returns
The resulting dense vector.

The exp() function computes $ e^x $ 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:

// ... Resizing and initialization
b = exp( a );

◆ exp10()

template<typename VT , bool TF>
decltype(auto) blaze::exp10 ( const DenseVector< VT, TF > &  dv)
inline

Computes $ 10^x $ for each single element of the dense vector dv.

Parameters
dvThe input vector.
Returns
The resulting dense vector.

The exp10() function computes $ 10^x $ 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:

// ... Resizing and initialization
b = exp10( a );

◆ exp2()

template<typename VT , bool TF>
decltype(auto) blaze::exp2 ( const DenseVector< VT, TF > &  dv)
inline

Computes $ 2^x $ for each single element of the dense vector dv.

Parameters
dvThe input vector.
Returns
The resulting dense vector.

The exp2() function computes $ 2^x $ 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:

// ... Resizing and initialization
b = exp2( a );

◆ expand() [1/2]

template<typename VT , bool TF>
decltype(auto) blaze::expand ( const DenseVector< VT, TF > &  dv,
size_t  expansion 
)
inline

Expansion of the given dense vector.

Parameters
dvThe dense vector to be expanded.
expansionThe expansion.
Returns
The expansion of the vector.

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

// ... Resizing and initialization
// Expansion of the column vector 'a' to 4x3 column-major matrix
//
// ( 1 1 1 )
// ( 5 5 5 )
// ( -2 -2 -2 )
// ( 4 4 4 )
//
A = expand( a, 3UL );
// Expansion of the row vector 'b' to a 3x4 row-major matrix
//
// ( 3, -1, 7, 0 )
// ( 3, -1, 7, 0 )
// ( 3, -1, 7, 0 )
//
B = expand( b, 3UL );

◆ expand() [2/2]

template<size_t E, typename VT , bool TF>
decltype(auto) blaze::expand ( const DenseVector< VT, TF > &  dv)
inline

Expansion of the given dense vector.

Parameters
dvThe dense vector to be expanded.
Returns
The expansion of the vector.

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

// ... Resizing and initialization
// Expansion of the column vector 'a' to 4x3 column-major matrix
//
// ( 1 1 1 )
// ( 5 5 5 )
// ( -2 -2 -2 )
// ( 4 4 4 )
//
A = expand<3UL>( a );
// Expansion of the row vector 'b' to a 3x4 row-major matrix
//
// ( 3, -1, 7, 0 )
// ( 3, -1, 7, 0 )
// ( 3, -1, 7, 0 )
//
B = expand<3UL>( b );

◆ floor()

template<typename VT , bool TF>
decltype(auto) blaze::floor ( const DenseVector< VT, TF > &  dv)
inline

Applies the floor() function to each single element of the dense vector dv.

Parameters
dvThe input vector.
Returns
The resulting dense 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:

// ... Resizing and initialization
b = floor( a );

◆ forEach()

template<typename VT , bool TF, typename OP >
decltype(auto) blaze::forEach ( const DenseVector< VT, TF > &  dv,
OP  op 
)
inline

Evaluates the given custom operation on each single element of the dense vector dv.

Parameters
dvThe input vector.
opThe custom operation.
Returns
The custom operation applied to each single element of dv.

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:

// ... Resizing and initialization
b = forEach( a, []( double a ){ return std::sqrt( a ); } );

◆ hypot()

template<typename VT1 , typename VT2 , bool TF>
decltype(auto) blaze::hypot ( const DenseVector< VT1, TF > &  lhs,
const DenseVector< VT2, TF > &  rhs 
)
inline

Computes the componentwise hypotenous for the dense vectors lhs and rhs.

Parameters
lhsThe left-hand side dense vector operand.
rhsThe right-hand side dense vector operand.
Returns
The resulting dense vector

The hypot() function computes the componentwise hypotenous for the two dense vectors lhs and rhs. The function returns an expression representing this operation.
The following example demonstrates the use of the hypot() function:

// ... Resizing and initialization
c = hypot( a, b );

◆ imag()

template<typename VT , bool TF>
decltype(auto) blaze::imag ( const DenseVector< VT, TF > &  dv)
inline

Returns a vector containing the imaginary part of each single element of dv.

Parameters
dvThe input vector.
Returns
The imaginary part of each single element of dv.

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:

// ... Resizing and initialization
b = imag( a );

◆ invcbrt()

template<typename VT , bool TF>
decltype(auto) blaze::invcbrt ( const DenseVector< VT, TF > &  dv)
inline

Computes the inverse cubic root of each single element of the dense vector dv.

Parameters
dvThe input vector; all elements must be in the range $(0..\infty)$.
Returns
The inverse cubic root of each single element of dv.

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:

// ... Resizing and initialization
b = invcbrt( a );
Note
All elements are expected to be in the range $(0..\infty)$. No runtime checks are performed to assert this precondition!

◆ invsqrt()

template<typename VT , bool TF>
decltype(auto) blaze::invsqrt ( const DenseVector< VT, TF > &  dv)
inline

Computes the inverse square root of each single element of the dense vector dv.

Parameters
dvThe input vector; all elements must be in the range $(0..\infty)$.
Returns
The inverse square root of each single element of dv.

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:

// ... Resizing and initialization
b = invsqrt( a );
Note
All elements are expected to be in the range $(0..\infty)$. No runtime checks are performed to assert this precondition!

◆ isDivisor()

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

Returns whether the given dense vector is a valid divisor.

Parameters
dvThe dense vector to be tested.
Returns
true in case the given vector is a valid divisor, false otherwise.

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.

StaticVector<int,3UL> a{ 1, -1, 2 }; // isDivisor( a ) returns true
StaticVector<int,3UL> b{ 1, -1, 0 }; // isDivisor( b ) returns false

◆ isnan()

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

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

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

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

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

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

◆ isUniform()

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

Checks if the given dense vector is a uniform vector.

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

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

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

Optionally, it is possible to switch between strict semantics (blaze::strict) and relaxed semantics (blaze::relaxed):

if( isUniform<relaxed>( a ) ) { ... }

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

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

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

◆ isZero()

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

Checks if the given dense vector is a zero vector.

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

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

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

Optionally, it is possible to switch between strict semantics (blaze::strict) and relaxed semantics (blaze::relaxed):

if( isZero<relaxed>( a ) ) { ... }

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

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

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

◆ l1Norm()

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

Computes the L1 norm for the given dense vector.

Parameters
dvThe given dense vector for the norm computation.
Returns
The L1 norm of the given dense vector.

This function computes the L1 norm of the given dense vector:

// ... Resizing and initialization
const double l1 = l1Norm( a );

◆ l2Norm()

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

Computes the L2 norm for the given dense vector.

Parameters
dvThe given dense vector for the norm computation.
Returns
The L2 norm of the given dense vector.

This function computes the L2 norm of the given dense vector:

// ... Resizing and initialization
const double l2 = l2Norm( a );

◆ l3Norm()

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

Computes the L3 norm for the given dense vector.

Parameters
dvThe given dense vector for the norm computation.
Returns
The L3 norm of the given dense vector.

This function computes the L3 norm of the given dense vector:

// ... Resizing and initialization
const double l3 = l3Norm( a );

◆ l4Norm()

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

Computes the L4 norm for the given dense vector.

Parameters
dvThe given dense vector for the norm computation.
Returns
The L4 norm of the given dense vector.

This function computes the L4 norm of the given dense vector:

// ... Resizing and initialization
const double l4 = l4Norm( a );

◆ length()

template<typename VT , bool TF>
auto blaze::length ( const DenseVector< VT, TF > &  dv) -> decltype(sqrt(sqrLength(~dv)))
inline

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

Parameters
dvThe given dense vector.
Returns
The length (magnitude) of the 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>
Note
This operation is only defined for numeric data types. In case the element type is not a numeric data type (i.e. a user defined data type or boolean) the attempt to use the sqrLength() function results in a compile time error!

◆ log()

template<typename VT , bool TF>
decltype(auto) blaze::log ( const DenseVector< VT, TF > &  dv)
inline

Computes the natural logarithm for each single element of the dense vector dv.

Parameters
dvThe input vector; all elements must be in the range $[0..\infty)$.
Returns
The natural logarithm of each single element of dv.

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:

// ... Resizing and initialization
b = log( a );
Note
All elements are expected to be in the range $[0..\infty)$. No runtime checks are performed to assert this precondition!

◆ log10()

template<typename VT , bool TF>
decltype(auto) blaze::log10 ( const DenseVector< VT, TF > &  dv)
inline

Computes the common logarithm for each single element of the dense vector dv.

Parameters
dvThe input vector; all elements must be in the range $[0..\infty)$.
Returns
The common logarithm of each single element of dv.

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:

// ... Resizing and initialization
b = log10( a );
Note
All elements are expected to be in the range $[0..\infty)$. No runtime checks are performed to assert this precondition!

◆ log2()

template<typename VT , bool TF>
decltype(auto) blaze::log2 ( const DenseVector< VT, TF > &  dv)
inline

Computes the binary logarithm for each single element of the dense vector dv.

Parameters
dvThe input vector; all elements must be in the range $[0..\infty)$.
Returns
The binary logarithm of each single element of dv.

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:

// ... Resizing and initialization
b = log2( a );
Note
All elements are expected to be in the range $[0..\infty)$. No runtime checks are performed to assert this precondition!

◆ lpNorm() [1/2]

template<typename VT , bool TF, typename ST >
decltype(auto) blaze::lpNorm ( const DenseVector< VT, TF > &  dv,
ST  p 
)

Computes the Lp norm for the given dense vector.

Parameters
dvThe given dense vector for the norm computation.
pThe norm parameter (p > 0).
Returns
The Lp norm of the given dense vector.

This function computes the Lp norm of the given dense vector, where the norm is specified by the runtime argument p:

// ... Resizing and initialization
const double lp = lpNorm( a, 2.3 );
Note
The norm parameter p is expected to be larger than 0. This precondition is only checked by a user assertion.

◆ lpNorm() [2/2]

template<size_t P, typename VT , bool TF>
decltype(auto) blaze::lpNorm ( const DenseVector< VT, TF > &  dv)
inline

Computes the Lp norm for the given dense vector.

Parameters
dvThe given dense vector for the norm computation.
Returns
The Lp norm of the given dense vector.

This function computes the Lp norm of the given dense vector, where the norm is specified by the runtime argument P:

// ... Resizing and initialization
const double lp = lpNorm<2>( a );
Note
The norm parameter P is expected to be larger than 0. A value of 0 results in a compile time error!.

◆ map() [1/2]

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 
)
inline

Evaluates the given binary operation on each single element of the dense vectors lhs and rhs.

Parameters
lhsThe left-hand side dense vector operand.
rhsThe right-hand side dense vector operand.
opThe custom, binary operation.
Returns
The binary operation applied to each single element of lhs and rhs.
Exceptions
std::invalid_argumentVector 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:

// ... Resizing and initialization
c = map( a, b, []( double x, double y ){ return std::min( x, y ); } );

◆ map() [2/2]

template<typename VT , bool TF, typename OP >
decltype(auto) blaze::map ( const DenseVector< VT, TF > &  dv,
OP  op 
)
inline

Evaluates the given custom operation on each single element of the dense vector dv.

Parameters
dvThe input vector.
opThe custom operation.
Returns
The custom operation applied to each single element of dv.

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:

// ... Resizing and initialization
b = map( a, []( double a ){ return std::sqrt( a ); } );

◆ max() [1/2]

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

Returns the largest element of the dense vector.

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

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

blaze::DynamicVector<int> a{ 1, -2, 3, 0 };
const int totalmax = max( a ); // Results in 3

◆ max() [2/2]

template<typename VT1 , typename VT2 , bool TF>
decltype(auto) blaze::max ( const DenseVector< VT1, TF > &  lhs,
const DenseVector< VT2, TF > &  rhs 
)
inline

Computes the componentwise maximum of the dense vectors lhs and rhs.

Parameters
lhsThe left-hand side dense vector operand.
rhsThe right-hand side dense vector operand.
Returns
The resulting dense vector.

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:

// ... Resizing and initialization
c = max( a, b );

◆ maxNorm()

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

Computes the maximum norm for the given dense vector.

Parameters
dvThe given dense vector for the norm computation.
Returns
The maximum norm of the given dense vector.

This function computes the maximum norm of the given dense vector:

// ... Resizing and initialization
const double max = maxNorm( a );

◆ min() [1/2]

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

Returns the smallest element of the dense vector.

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

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

blaze::DynamicVector<int> a{ 1, -2, 3, 0 };
const int totalmin = min( a ); // Results in -2

◆ min() [2/2]

template<typename VT1 , typename VT2 , bool TF>
decltype(auto) blaze::min ( const DenseVector< VT1, TF > &  lhs,
const DenseVector< VT2, TF > &  rhs 
)
inline

Computes the componentwise minimum of the dense vectors lhs and rhs.

Parameters
lhsThe left-hand side dense vector operand.
rhsThe right-hand side dense vector operand.
Returns
The resulting dense vector.

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:

// ... Resizing and initialization
c = min( a, b );

◆ norm()

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

Computes the L2 norm for the given dense vector.

Parameters
dvThe given dense vector for the norm computation.
Returns
The L2 norm of the given dense vector.

This function computes the L2 norm of the given dense vector:

// ... Resizing and initialization
const double l2 = norm( a );

◆ operator!=() [1/5]

template<typename T1 , typename T2 , bool TF>
auto blaze::operator!= ( const DenseVector< T1, TF > &  vec,
T2  scalar 
) -> EnableIf_t< IsNumeric_v< T2 >, bool >
inline

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

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

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

◆ operator!=() [2/5]

template<typename T1 , typename T2 , bool TF>
auto blaze::operator!= ( T1  scalar,
const DenseVector< T2, TF > &  vec 
) -> EnableIf_t< IsNumeric_v< T1 >, bool >
inline

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

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

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

◆ operator!=() [3/5]

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

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

Parameters
lhsThe left-hand side dense vector for the comparison.
rhsThe right-hand side sparse vector for the comparison.
Returns
true if the two vectors are not equal, false if they are equal.

◆ operator!=() [4/5]

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

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

Parameters
lhsThe left-hand side sparse vector for the comparison.
rhsThe right-hand side dense vector for the comparison.
Returns
true if the two vectors are not equal, false if they are equal.

◆ operator!=() [5/5]

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

Inequality operator for the comparison of two dense vectors.

Parameters
lhsThe left-hand side dense vector for the comparison.
rhsThe right-hand side dense vector for the comparison.
Returns
true if the two vectors are not equal, false if they are equal.

◆ operator%() [1/4]

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 ( $ \vec{a}=\vec{b} \times \vec{c} $).

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

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

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

The operator returns an expression representing a dense vector of the higher-order element type of the two involved vector element types 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.

◆ operator%() [2/4]

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 ( $ \vec{a}=\vec{b} \times \vec{c} $).

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

This operator represents the cross product of two sparse vectors:

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

The operator returns a dense vector of the higher-order element type of the two involved vector element types 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.

◆ operator%() [3/4]

template<typename VT1 , typename VT2 , bool TF>
decltype(auto) blaze::operator% ( const DenseVector< VT1, TF > &  lhs,
const DenseVector< VT2, TF > &  rhs 
)
inline

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

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

This operator represents the cross product of two dense vectors:

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

The operator returns an expression representing a dense vector of the higher-order element type of the two involved vector element types 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.

◆ operator%() [4/4]

template<typename VT1 , typename VT2 , bool TF>
decltype(auto) blaze::operator% ( const DenseVector< VT1, TF > &  lhs,
const SparseVector< VT2, TF > &  rhs 
)
inline

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

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

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

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

The operator returns an expression representing a dense vector of the higher-order element type of the two involved vector element types 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.

◆ operator*() [1/14]

template<typename VT1 , typename VT2 >
decltype(auto) blaze::operator* ( const DenseVector< VT1, true > &  lhs,
const DenseVector< VT2, false > &  rhs 
)
inline

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

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

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

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

The operator returns a scalar value of the higher-order element type of the two involved vector element types 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.

◆ operator*() [2/14]

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 ( $ \vec{y}=A*\vec{x} $).

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

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

The operator returns an expression representing a dense vector of the higher-order element type of the two involved element types 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.

◆ operator*() [3/14]

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 ( $ \vec{y}=A*\vec{x} $).

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

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

The operator returns an expression representing a dense vector of the higher-order element type of the two involved element types 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.

◆ operator*() [4/14]

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 ( $ \vec{y}=A*\vec{x} $).

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

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

The operator returns an expression representing a dense vector of the higher-order element type of the two involved element types 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.

◆ operator*() [5/14]

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 ( $ \vec{y}=A*\vec{x} $).

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

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

The operator returns an expression representing a dense vector of the higher-order element type of the two involved element types 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.

◆ operator*() [6/14]

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 ( $ \vec{y}^T=\vec{x}^T*A $).

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

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

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.

◆ operator*() [7/14]

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 ( $ \vec{y}^T=\vec{x}^T*A $).

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

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

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.

◆ operator*() [8/14]

template<typename VT , typename MT >
decltype(auto) blaze::operator* ( const DenseVector< VT, true > &  vec,
const SparseMatrix< MT, true > &  mat 
)

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

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

This operator represents the multiplication between a transpose dense vector and a column-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 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.

◆ operator*() [9/14]

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 ( $ \vec{y}^T=\vec{x}^T*A $).

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

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

The operator returns an expression representing a transpose sparse vector of the higher-order element type of the two involved element types 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.

◆ operator*() [10/14]

template<typename MT , typename VT >
decltype(auto) blaze::operator* ( const DenseMatrix< MT, false > &  mat,
const SparseVector< VT, false > &  vec 
)
inline

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

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

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

The operator returns an expression representing a dense vector of the higher-order element type of the two involved element types 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.

◆ operator*() [11/14]

template<typename VT , typename ST , bool TF, EnableIf_t< IsNumeric_v< ST > > * = nullptr>
decltype(auto) blaze::operator* ( const DenseVector< VT, TF > &  vec,
ST  scalar 
)
inline

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

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

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

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

The operator returns an expression representing a dense vector of the higher-order element type of the involved data types 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.

◆ operator*() [12/14]

template<typename ST , typename VT , bool TF, EnableIf_t< IsNumeric_v< ST > > * = nullptr>
decltype(auto) blaze::operator* ( ST  scalar,
const DenseVector< VT, TF > &  vec 
)
inline

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

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

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

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

The operator returns an expression representing a dense vector of the higher-order element type of the involved data types 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.

◆ operator*() [13/14]

template<typename VT1 , typename VT2 , bool TF>
decltype(auto) blaze::operator* ( const DenseVector< VT1, TF > &  lhs,
const DenseVector< VT2, TF > &  rhs 
)
inline

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

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

This operator represents the component product of two dense vectors:

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

The operator returns an expression representing a dense vector of the higher-order element type of the two involved vector element types 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.

◆ operator*() [14/14]

template<typename MT , typename VT >
decltype(auto) blaze::operator* ( const DenseMatrix< MT, false > &  mat,
const DenseVector< VT, false > &  vec 
)
inline

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

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

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

The operator returns an expression representing a dense vector of the higher-order element type of the two involved element types 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.

◆ operator*=() [1/2]

template<typename VT , bool TF, typename ST >
auto blaze::operator*= ( DenseVector< VT, TF > &  vec,
ST  scalar 
) -> EnableIf_t< IsNumeric_v< ST >, VT &>
inline

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

Parameters
vecThe left-hand side dense vector for the multiplication.
scalarThe right-hand side scalar value for the multiplication.
Returns
Reference to the left-hand side dense vector.
Exceptions
std::invalid_argumentInvalid scaling of restricted vector.

In case the vector VT is restricted and the assignment would violate an invariant of the vector, a std::invalid_argument exception is thrown.

◆ operator*=() [2/2]

template<typename VT , bool TF, typename ST >
auto blaze::operator*= ( DenseVector< VT, TF > &&  vec,
ST  scalar 
) -> EnableIf_t< IsNumeric_v< ST >, VT &>
inline

Multiplication assignment operator for the multiplication of a temporary dense vector and a scalar ( $ v*=s $).

Parameters
vecThe left-hand side temporary dense vector for the multiplication.
scalarThe right-hand side scalar value for the multiplication.
Returns
Reference to the left-hand side dense vector.
Exceptions
std::invalid_argumentInvalid scaling of restricted vector.

In case the vector VT is restricted and the assignment would violate an invariant of the vector, a std::invalid_argument exception is thrown.

◆ operator+() [1/3]

template<typename VT1 , typename VT2 , bool TF>
decltype(auto) blaze::operator+ ( const DenseVector< VT1, TF > &  lhs,
const SparseVector< VT2, TF > &  rhs 
)
inline

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

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

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

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

The operator returns an expression representing a dense vector of the higher-order element type of the two involved vector element types 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.

◆ operator+() [2/3]

template<typename VT1 , typename VT2 , bool TF>
decltype(auto) blaze::operator+ ( const SparseVector< VT1, TF > &  lhs,
const DenseVector< VT2, TF > &  rhs 
)
inline

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

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

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

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

The operator returns an expression representing a dense vector of the higher-order element type of the two involved vector element types 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.

◆ operator+() [3/3]

template<typename VT1 , typename VT2 , bool TF>
decltype(auto) blaze::operator+ ( const DenseVector< VT1, TF > &  lhs,
const DenseVector< VT2, TF > &  rhs 
)
inline

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

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

This operator represents the addition of two dense vectors:

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

The operator returns an expression representing a dense vector of the higher-order element type of the two involved vector element types 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.

◆ operator-() [1/4]

template<typename VT1 , typename VT2 , bool TF>
decltype(auto) blaze::operator- ( const SparseVector< VT1, TF > &  lhs,
const DenseVector< VT2, TF > &  rhs 
)
inline

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

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

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

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

The operator returns an expression representing a dense vector of the higher-order element type of the two involved vector element types 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.

◆ operator-() [2/4]

template<typename VT1 , typename VT2 , bool TF>
decltype(auto) blaze::operator- ( const DenseVector< VT1, TF > &  lhs,
const SparseVector< VT2, TF > &  rhs 
)
inline

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

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

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

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

The operator returns an expression representing a dense vector of the higher-order element type of the two involved vector element types 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.

◆ operator-() [3/4]

template<typename VT , bool TF>
decltype(auto) blaze::operator- ( const DenseVector< VT, TF > &  dv)
inline

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

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

This operator represents the negation of a dense vector:

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

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

◆ operator-() [4/4]

template<typename VT1 , typename VT2 , bool TF>
decltype(auto) blaze::operator- ( const DenseVector< VT1, TF > &  lhs,
const DenseVector< VT2, TF > &  rhs 
)
inline

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

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

This operator represents the subtraction of two dense vectors:

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

The operator returns an expression representing a dense vector of the higher-order element type of the two involved vector element types 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.

◆ operator/() [1/2]

template<typename VT , typename ST , bool TF, EnableIf_t< IsNumeric_v< ST > > * = nullptr>
decltype(auto) blaze::operator/ ( const DenseVector< VT, TF > &  vec,
ST  scalar 
)
inline

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

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

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

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

The operator returns an expression representing a dense vector of the higher-order element type of the involved data types 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.

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

◆ operator/() [2/2]

template<typename VT1 , typename VT2 , bool TF>
decltype(auto) blaze::operator/ ( const DenseVector< VT1, TF > &  lhs,
const DenseVector< VT2, TF > &  rhs 
)
inline

Division operator for the componentwise quotient of two dense vectors ( $ \vec{a}=\vec{b}/\vec{c} $).

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

This operator represents the component quotient of two dense vectors:

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

The operator returns an expression representing a dense vector of the higher-order element type of the two involved vector element types 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.

◆ operator/=() [1/2]

template<typename VT , bool TF, typename ST >
auto blaze::operator/= ( DenseVector< VT, TF > &  vec,
ST  scalar 
) -> EnableIf_t< IsNumeric_v< ST >, VT &>
inline

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

Parameters
vecThe left-hand side dense vector for the division.
scalarThe right-hand side scalar value for the division.
Returns
Reference to the left-hand side dense vector.
Exceptions
std::invalid_argumentInvalid scaling of restricted vector.

In case the vector VT is restricted and the assignment would violate an invariant of the vector, a std::invalid_argument exception is thrown.

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

◆ operator/=() [2/2]

template<typename VT , bool TF, typename ST >
auto blaze::operator/= ( DenseVector< VT, TF > &&  vec,
ST  scalar 
) -> EnableIf_t< IsNumeric_v< ST >, VT &>
inline

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

Parameters
vecThe left-hand side temporary dense vector for the division.
scalarThe right-hand side scalar value for the division.
Returns
Reference to the left-hand side dense vector.
Exceptions
std::invalid_argumentInvalid scaling of restricted vector.

In case the vector VT is restricted and the assignment would violate an invariant of the vector, a std::invalid_argument exception is thrown.

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

◆ operator==() [1/5]

template<typename T1 , typename T2 , bool TF>
auto blaze::operator== ( const DenseVector< T1, TF > &  vec,
T2  scalar 
) -> EnableIf_t< IsNumeric_v< T2 >, bool >
inline

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

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

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

◆ operator==() [2/5]

template<typename T1 , typename T2 , bool TF>
auto blaze::operator== ( T1  scalar,
const DenseVector< T2, TF > &  vec 
) -> EnableIf_t< IsNumeric_v< T1 >, bool >
inline

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

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

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

◆ operator==() [3/5]

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

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

Parameters
lhsThe left-hand side dense vector for the comparison.
rhsThe right-hand side sparse vector for the comparison.
Returns
true if the two vectors are equal, false if not.

◆ operator==() [4/5]

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

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

Parameters
lhsThe left-hand side sparse vector for the comparison.
rhsThe right-hand side dense vector for the comparison.
Returns
true if the two vectors are equal, false if not.

◆ operator==() [5/5]

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

Equality operator for the comparison of two dense vectors.

Parameters
lhsThe left-hand side dense vector for the comparison.
rhsThe right-hand side dense vector for the comparison.
Returns
true if the two vectors are equal, false if not.

◆ pow() [1/2]

template<typename VT1 , typename VT2 , bool TF>
decltype(auto) blaze::pow ( const DenseVector< VT1, TF > &  lhs,
const DenseVector< VT2, TF > &  rhs 
)
inline

Computes the componentwise exponential value for the dense vectors lhs and rhs.

Parameters
lhsThe left-hand side dense vector operand.
rhsThe right-hand side dense vector operand.
Returns
The resulting dense vector

The pow() function computes the componentwise exponential value for the two dense vectors lhs and rhs. The function returns an expression representing this operation.
The following example demonstrates the use of the pow() function:

// ... Resizing and initialization
c = pow( a, b );

◆ pow() [2/2]

template<typename VT , bool TF, typename ST , EnableIf_t< IsNumeric_v< ST > > * = nullptr>
decltype(auto) blaze::pow ( const DenseVector< VT, TF > &  dv,
ST  exp 
)
inline

Computes the exponential value for each single element of the dense vector dv.

Parameters
dvThe input vector.
expThe scalar exponent.
Returns
The exponential value of each single element of dv.

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:

// ... Resizing and initialization
b = pow( a, 4.2 );

◆ prod()

template<typename VT , bool TF>
decltype(auto) blaze::prod ( const DenseVector< VT, TF > &  dv)
inline

Reduces the given dense vector by means of multiplication.

Parameters
dvThe given dense vector for the reduction operation.
Returns
The result of the reduction operation.

This function reduces the given dense vector dv by means of multiplication:

blaze::DynamicVector<int> a{ 1, 2, 3, 4 };
const int totalprod = prod( a ); // Results in 24

Please note that the evaluation order of the reduction operation is unspecified.

◆ real()

template<typename VT , bool TF>
decltype(auto) blaze::real ( const DenseVector< VT, TF > &  dv)
inline

Returns a vector containing the real part of each single element of dv.

Parameters
dvThe input vector.
Returns
The real part of each single element of dv.

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:

// ... Resizing and initialization
b = real( a );

◆ reduce()

template<typename VT , bool TF, typename OP >
decltype(auto) blaze::reduce ( const DenseVector< VT, TF > &  dv,
OP  op 
)
inline

Performs a custom reduction operation on the given dense vector.

Parameters
dvThe given dense vector for the reduction computation.
opThe reduction operation.
Returns
The result of the reduction operation.

This function reduces the given dense vector dv by means of the given reduction operation op:

// ... Resizing and initialization
const double totalsum1 = reduce( a, blaze::Add() );
const double totalsum2 = reduce( a, []( double a, double b ){ return a + b; } );

As demonstrated in the example it is possible to pass any binary callable as custom reduction operation. However, for instance in the case of lambdas the vectorization of the reduction operation is compiler dependent and might not perform at peak performance. However, it is also possible to create vectorized custom operations. See Custom Operations for a detailed overview of the possibilities of custom operations.

Please note that the evaluation order of the reduction operation is unspecified. Thus the behavior is non-deterministic if op is not associative or not commutative. Also, the operation is undefined if the given reduction operation modifies the values.

◆ round()

template<typename VT , bool TF>
decltype(auto) blaze::round ( const DenseVector< VT, TF > &  dv)
inline

Applies the round() function to each single element of the dense vector dv.

Parameters
dvThe input vector.
Returns
The resulting dense 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:

// ... Resizing and initialization
b = round( a );

◆ serial()

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

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

Parameters
dvThe input vector.
Returns
The evaluated dense vector.

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

// ... Resizing and initialization
b = serial( a );

◆ sign()

template<typename VT , bool TF>
decltype(auto) blaze::sign ( const DenseVector< VT, TF > &  dv)
inline

Applies the sign() function to each single element of the dense vector dv.

Parameters
dvThe input vector.
Returns
The resulting dense vector.

This function applies the sign() 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 sign() function:

// ... Resizing and initialization
b = sign( a );

◆ sin()

template<typename VT , bool TF>
decltype(auto) blaze::sin ( const DenseVector< VT, TF > &  dv)
inline

Computes the sine for each single element of the dense vector dv.

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

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:

// ... Resizing and initialization
b = sin( a );

◆ sinh()

template<typename VT , bool TF>
decltype(auto) blaze::sinh ( const DenseVector< VT, TF > &  dv)
inline

Computes the hyperbolic sine for each single element of the dense vector dv.

Parameters
dvThe input vector.
Returns
The hyperbolic sine of each single element of dv.

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:

// ... Resizing and initialization
b = sinh( a );

◆ softmax()

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

Computes the softmax function for the given dense vector.

Parameters
dvThe given dense vector for the softmax computation.
Returns
The resulting dense vector.

This function computes the softmax function (i.e. the normalized exponential function) for the given dense vector dv (see also https://en.wikipedia.org/wiki/Softmax_function). The resulting dense vector consists of real values in the range (0..1], which add up to 1.

◆ sqrLength()

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

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

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

This function calculates the actual square length (magnitude) of the dense vector.

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

◆ sqrNorm()

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

Computes the squared L2 norm for the given dense vector.

Parameters
dvThe given dense vector for the norm computation.
Returns
The squared L2 norm of the given dense vector.

This function computes the squared L2 norm of the given dense vector:

// ... Resizing and initialization
const double l2 = sqrNorm( a );

◆ sqrt()

template<typename VT , bool TF>
decltype(auto) blaze::sqrt ( const DenseVector< VT, TF > &  dv)
inline

Computes the square root of each single element of the dense vector dv.

Parameters
dvThe input vector; all elements must be in the range $[0..\infty)$.
Returns
The square root of each single element of dv.

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:

// ... Resizing and initialization
b = sqrt( a );
Note
All elements are expected to be in the range $[0..\infty)$. No runtime checks are performed to assert this precondition!

◆ sum()

template<typename VT , bool TF>
decltype(auto) blaze::sum ( const DenseVector< VT, TF > &  dv)
inline

Reduces the given dense vector by means of addition.

Parameters
dvThe given dense vector for the reduction operation.
Returns
The result of the reduction operation.

This function reduces the given dense vector dv by means of addition:

blaze::DynamicVector<int> a{ 1, 2, 3, 4 };
const int totalsum = sum( a ); // Results in 10

Please note that the evaluation order of the reduction operation is unspecified.

◆ tan()

template<typename VT , bool TF>
decltype(auto) blaze::tan ( const DenseVector< VT, TF > &  dv)
inline

Computes the tangent for each single element of the dense vector dv.

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

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:

// ... Resizing and initialization
b = tan( a );

◆ tanh()

template<typename VT , bool TF>
decltype(auto) blaze::tanh ( const DenseVector< VT, TF > &  dv)
inline

Computes the hyperbolic tangent for each single element of the dense vector dv.

Parameters
dvThe input vector; all elements must be in the range $[-1..1]$.
Returns
The hyperbolic tangent of each single element of dv.

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:

// ... Resizing and initialization
b = tanh( a );
Note
All elements are expected to be in the range $[-1..1]$. No runtime checks are performed to assert this precondition!

◆ trans()

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

Calculation of the transpose of the given dense vector.

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

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

◆ transTo()

template<bool TTF, typename VT , bool TF>
decltype(auto) blaze::transTo ( const DenseVector< VT, TF > &  dv)
inline

Conditional calculation of the transpose of the given dense vector.

Parameters
dvThe dense vector to be transposed.
Returns
The dense vector with the specified transpose flag.

This function transposes the given dense vector in case the target transpose flag is different from the current transpose flag of the vector and performs no action if the two transpose flags match. It returns an expression representing the the given dense vector with the specified transpose flag.

◆ trunc()

template<typename VT , bool TF>
decltype(auto) blaze::trunc ( const DenseVector< VT, TF > &  dv)
inline

Applies the trunc() function to each single element of the dense vector dv.

Parameters
dvThe input vector.
Returns
The resulting dense 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:

// ... Resizing and initialization
b = trunc( a );

Friends

◆ addAssign [1/4]

template<typename VT , typename MT >
template<typename VT2 >
auto addAssign ( DenseVector< VT2, true > &  lhs,
const TDVecTSMatMultExpr< VT, MT > &  rhs 
) -> EnableIf_t< UseAssign_v<VT2> >
friend

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

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

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

◆ addAssign [2/4]

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

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

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

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

◆ addAssign [3/4]

template<typename VT , typename MT >
template<typename VT2 >
auto addAssign ( DenseVector< VT2, true > &  lhs,
const TSVecTDMatMultExpr< VT, MT > &  rhs 
) -> EnableIf_t< UseAssign_v<VT2> >
friend

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

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

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

◆ addAssign [4/4]

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

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

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

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

◆ assign [1/4]

template<typename VT , typename MT >
template<typename VT2 >
auto assign ( DenseVector< VT2, true > &  lhs,
const TDVecTSMatMultExpr< VT, MT > &  rhs 
) -> EnableIf_t< UseAssign_v<VT2> >
friend

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

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

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

◆ assign [2/4]

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

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

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

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

◆ assign [3/4]

template<typename VT , typename MT >
template<typename VT2 >
auto assign ( SparseVector< VT2, true > &  lhs,
const TDVecTSMatMultExpr< VT, MT > &  rhs 
) -> EnableIf_t< UseAssign_v<VT2> >
friend

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

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

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

◆ assign [4/4]

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

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

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

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

◆ divAssign [1/4]

template<typename VT , typename MT >
template<typename VT2 >
auto divAssign ( DenseVector< VT2, true > &  lhs,
const TDVecTSMatMultExpr< VT, MT > &  rhs 
) -> EnableIf_t< UseAssign_v<VT2> >
friend

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

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

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.

◆ divAssign [2/4]

template<typename VT , typename MT >
template<typename VT2 >
auto divAssign ( DenseVector< VT2, true > &  lhs,
const TSVecTDMatMultExpr< VT, MT > &  rhs 
) -> EnableIf_t< UseAssign_v<VT2> >
friend

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

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

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.

◆ divAssign [3/4]

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

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

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

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

◆ divAssign [4/4]

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

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

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

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

◆ multAssign [1/4]

template<typename VT , typename MT >
template<typename VT2 >
auto multAssign ( DenseVector< VT2, true > &  lhs,
const TDVecTSMatMultExpr< VT, MT > &  rhs 
) -> EnableIf_t< UseAssign_v<VT2> >
friend

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

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

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

◆ multAssign [2/4]

template<typename VT , typename MT >
template<typename VT2 >
auto multAssign ( DenseVector< VT2, true > &  lhs,
const TSVecTDMatMultExpr< VT, MT > &  rhs 
) -> EnableIf_t< UseAssign_v<VT2> >
friend

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

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

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

◆ multAssign [3/4]

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

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

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

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

◆ multAssign [4/4]

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

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

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

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

◆ smpAddAssign [1/4]

template<typename VT , typename MT >
template<typename VT2 >
auto smpAddAssign ( DenseVector< VT2, true > &  lhs,
const TDVecTSMatMultExpr< VT, MT > &  rhs 
) -> EnableIf_t< UseSMPAssign_v<VT2> >
friend

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

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

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

◆ smpAddAssign [2/4]

template<typename VT , typename MT >
template<typename VT2 >
auto smpAddAssign ( DenseVector< VT2, true > &  lhs,
const TSVecTDMatMultExpr< VT, MT > &  rhs 
) -> EnableIf_t< UseSMPAssign_v<VT2> >
friend

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

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

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

◆ smpAddAssign [3/4]

template<typename VT , typename MT >
template<typename VT2 >
auto smpAddAssign ( DenseVector< VT2, true > &  lhs,
const TDVecSMatMultExpr< VT, MT > &  rhs 
) -> EnableIf_t< UseSMPAssign_v<VT2> >
friend

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

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

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

◆ smpAddAssign [4/4]

template<typename VT , typename MT >
template<typename VT2 >
auto smpAddAssign ( DenseVector< VT2, true > &  lhs,
const TSVecDMatMultExpr< VT, MT > &  rhs 
) -> EnableIf_t< UseSMPAssign_v<VT2> >
friend

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

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

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

◆ smpAssign [1/4]

template<typename VT , typename MT >
template<typename VT2 >
auto smpAssign ( DenseVector< VT2, true > &  lhs,
const TDVecTSMatMultExpr< VT, MT > &  rhs 
) -> EnableIf_t< UseSMPAssign_v<VT2> >
friend

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

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

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

◆ smpAssign [2/4]

template<typename VT , typename MT >
template<typename VT2 >
auto smpAssign ( SparseVector< VT2, true > &  lhs,
const TDVecTSMatMultExpr< VT, MT > &  rhs 
) -> EnableIf_t< UseSMPAssign_v<VT2> >
friend

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

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

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

◆ smpAssign [3/4]

template<typename VT , typename MT >
template<typename VT2 >
auto smpAssign ( DenseVector< VT2, true > &  lhs,
const TDVecSMatMultExpr< VT, MT > &  rhs 
) -> EnableIf_t< UseSMPAssign_v<VT2> >
friend

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

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

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

◆ smpAssign [4/4]

template<typename VT , typename MT >
template<typename VT2 >
auto smpAssign ( SparseVector< VT2, true > &  lhs,
const TDVecSMatMultExpr< VT, MT > &  rhs 
) -> EnableIf_t< UseSMPAssign_v<VT2> >
friend

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

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

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

◆ smpDivAssign [1/4]

template<typename VT , typename MT >
template<typename VT2 >
auto smpDivAssign ( DenseVector< VT2, true > &  lhs,
const TDVecTSMatMultExpr< VT, MT > &  rhs 
) -> EnableIf_t< UseSMPAssign_v<VT2> >
friend

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

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

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.

◆ smpDivAssign [2/4]

template<typename VT , typename MT >
template<typename VT2 >
auto smpDivAssign ( DenseVector< VT2, true > &  lhs,
const TSVecTDMatMultExpr< VT, MT > &  rhs 
) -> EnableIf_t< UseSMPAssign_v<VT2> >
friend

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

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

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.

◆ smpDivAssign [3/4]

template<typename VT , typename MT >
template<typename VT2 >
auto smpDivAssign ( DenseVector< VT2, true > &  lhs,
const TDVecSMatMultExpr< VT, MT > &  rhs 
) -> EnableIf_t< UseSMPAssign_v<VT2> >
friend

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

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

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.

◆ smpDivAssign [4/4]

template<typename VT , typename MT >
template<typename VT2 >
auto smpDivAssign ( DenseVector< VT2, true > &  lhs,
const TSVecDMatMultExpr< VT, MT > &  rhs 
) -> EnableIf_t< UseSMPAssign_v<VT2> >
friend

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

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

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.

◆ smpMultAssign [1/4]

template<typename VT , typename MT >
template<typename VT2 >
auto smpMultAssign ( DenseVector< VT2, true > &  lhs,
const TDVecTSMatMultExpr< VT, MT > &  rhs 
) -> EnableIf_t< UseSMPAssign_v<VT2> >
friend

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

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

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

◆ smpMultAssign [2/4]

template<typename VT , typename MT >
template<typename VT2 >
auto smpMultAssign ( DenseVector< VT2, true > &  lhs,
const TSVecTDMatMultExpr< VT, MT > &  rhs 
) -> EnableIf_t< UseSMPAssign_v<VT2> >
friend

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

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

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

◆ smpMultAssign [3/4]

template<typename VT , typename MT >
template<typename VT2 >
auto smpMultAssign ( DenseVector< VT2, true > &  lhs,
const TDVecSMatMultExpr< VT, MT > &  rhs 
) -> EnableIf_t< UseSMPAssign_v<VT2> >
friend

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

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

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

◆ smpMultAssign [4/4]

template<typename VT , typename MT >
template<typename VT2 >
auto smpMultAssign ( DenseVector< VT2, true > &  lhs,
const TSVecDMatMultExpr< VT, MT > &  rhs 
) -> EnableIf_t< UseSMPAssign_v<VT2> >
friend

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

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

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

◆ smpSubAssign [1/4]

template<typename VT , typename MT >
template<typename VT2 >
auto smpSubAssign ( DenseVector< VT2, true > &  lhs,
const TDVecTSMatMultExpr< VT, MT > &  rhs 
) -> EnableIf_t< UseSMPAssign_v<VT2> >
friend

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

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

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

◆ smpSubAssign [2/4]

template<typename VT , typename MT >
template<typename VT2 >
auto smpSubAssign ( DenseVector< VT2, true > &  lhs,
const TSVecTDMatMultExpr< VT, MT > &  rhs 
) -> EnableIf_t< UseSMPAssign_v<VT2> >
friend

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

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

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

◆ smpSubAssign [3/4]

template<typename VT , typename MT >
template<typename VT2 >
auto smpSubAssign ( DenseVector< VT2, true > &  lhs,
const TDVecSMatMultExpr< VT, MT > &  rhs 
) -> EnableIf_t< UseSMPAssign_v<VT2> >
friend

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

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

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

◆ smpSubAssign [4/4]

template<typename VT , typename MT >
template<typename VT2 >
auto smpSubAssign ( DenseVector< VT2, true > &  lhs,
const TSVecDMatMultExpr< VT, MT > &  rhs 
) -> EnableIf_t< UseSMPAssign_v<VT2> >
friend

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

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

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

◆ subAssign [1/4]

template<typename VT , typename MT >
template<typename VT2 >
auto subAssign ( DenseVector< VT2, true > &  lhs,
const TDVecTSMatMultExpr< VT, MT > &  rhs 
) -> EnableIf_t< UseAssign_v<VT2> >
friend

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

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

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

◆ subAssign [2/4]

template<typename VT , typename MT >
template<typename VT2 >
auto subAssign ( DenseVector< VT2, true > &  lhs,
const TSVecTDMatMultExpr< VT, MT > &  rhs 
) -> EnableIf_t< UseAssign_v<VT2> >
friend

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

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

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

◆ subAssign [3/4]

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

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

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

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

◆ subAssign [4/4]

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

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

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

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