![]() |
Blaze 3.9
|
Modules | |
CustomVector | |
DynamicVector | |
HybridVector | |
InitializerVector | |
StaticVector | |
UniformVector | |
Expressions | |
Classes | |
class | blaze::DenseVector< VT, TF > |
Base class for N-dimensional dense vectors. More... | |
Functions | |
template<typename MT , typename VT > | |
decltype(auto) | blaze::operator* (const DenseMatrix< MT, false > &mat, const DenseVector< VT, false > &vec) |
Multiplication operator for the multiplication of a row-major dense matrix and a dense vector ( ![]() | |
template<typename MT , bool SO, typename VT , bool TF> | |
decltype(auto) | blaze::solve (const DenseMatrix< MT, SO > &A, const DenseVector< VT, TF > &b) |
Solving the given ![]() ![]() | |
template<typename MT , bool SO> | |
decltype(auto) | blaze::eigen (const DenseMatrix< MT, SO > &dm) |
Calculation of the eigenvalues of the given dense matrix. More... | |
template<typename MT , bool SO> | |
decltype(auto) | blaze::svd (const DenseMatrix< MT, SO > &dm) |
Calculation of the singular values of the given dense matrix. 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 ( ![]() | |
template<typename VT1 , typename VT2 , bool TF> | |
decltype(auto) | blaze::operator+ (const DenseVector< VT1, TF > &lhs, const DenseVector< VT2, TF > &rhs) |
Addition operator for the addition of two dense vectors ( ![]() | |
template<typename VT1 , typename VT2 , bool TF> | |
decltype(auto) | blaze::operator% (const DenseVector< VT1, TF > &lhs, const DenseVector< VT2, TF > &rhs) |
Operator for the cross product of two dense vectors ( ![]() | |
template<typename VT1 , typename VT2 , bool TF> | |
decltype(auto) | blaze::operator/ (const DenseVector< VT1, TF > &lhs, const DenseVector< VT2, TF > &rhs) |
Division operator for the componentwise quotient of two dense vectors ( ![]() | |
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 ( ![]() | |
template<typename VT1 , typename VT2 , bool TF> | |
decltype(auto) | blaze::kron (const DenseVector< VT1, TF > &lhs, const DenseVector< VT2, TF > &rhs) |
Computes the Kronecker product of two dense vectors ( ![]() | |
template<typename VT1 , typename VT2 , bool TF, typename OP > | |
decltype(auto) | blaze::map (const DenseVector< VT1, TF > &lhs, const DenseVector< VT2, TF > &rhs, OP op) |
Elementwise evaluation of the given binary operation on each single element of the dense vectors lhs and rhs. More... | |
template<typename VT1 , typename VT2 , typename VT3 , bool TF, typename OP > | |
decltype(auto) | blaze::map (const DenseVector< VT1, TF > &dv1, const DenseVector< VT2, TF > &dv2, const DenseVector< VT3, TF > &dv3, OP op) |
Elementwise evaluation of the given ternary operation on each single element of the dense vectors dv1, dv2, and dv3. More... | |
template<typename VT1 , typename VT2 , typename VT3 , typename VT4 , bool TF, typename OP > | |
decltype(auto) | blaze::map (const DenseVector< VT1, TF > &dv1, const DenseVector< VT2, TF > &dv2, const DenseVector< VT3, TF > &dv3, const DenseVector< VT4, TF > &dv4, OP op) |
Elementwise evaluation of the given 4-ary operation on each single element of the dense vectors dv1, dv2, dv3, and dv4. More... | |
template<typename VT1 , typename VT2 , typename VT3 , typename VT4 , typename VT5 , bool TF, typename OP > | |
decltype(auto) | blaze::map (const DenseVector< VT1, TF > &dv1, const DenseVector< VT2, TF > &dv2, const DenseVector< VT3, TF > &dv3, const DenseVector< VT4, TF > &dv4, const DenseVector< VT5, TF > &dv5, OP op) |
Elementwise evaluation of the given 5-ary operation on each single element of the dense vectors dv1, dv2, dv3, dv4, and dv5. More... | |
template<typename VT1 , typename VT2 , typename VT3 , typename VT4 , typename VT5 , typename VT6 , bool TF, typename OP > | |
decltype(auto) | blaze::map (const DenseVector< VT1, TF > &dv1, const DenseVector< VT2, TF > &dv2, const DenseVector< VT3, TF > &dv3, const DenseVector< VT4, TF > &dv4, const DenseVector< VT5, TF > &dv5, const DenseVector< VT6, TF > &dv6, OP op) |
Elementwise evaluation of the given 6-ary operation on each single element of the dense vectors dv1, dv2, dv3, dv4, dv5, and dv6. 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 , typename VT3 , bool TF> | |
decltype(auto) | blaze::select (const DenseVector< VT1, TF > &cond, const DenseVector< VT2, TF > &lhs, const DenseVector< VT3, TF > &rhs) |
Elementwise conditional selection of values from 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) |
Left-shift operator for the elementwise left-shift of a dense vector. More... | |
template<typename VT1 , typename VT2 , bool TF> | |
decltype(auto) | blaze::operator>> (const DenseVector< VT1, TF > &lhs, const DenseVector< VT2, TF > &rhs) |
Right-shift operator for the elementwise right-shift of a dense vector. More... | |
template<typename VT1 , typename VT2 , bool TF> | |
decltype(auto) | blaze::operator& (const DenseVector< VT1, TF > &lhs, const DenseVector< VT2, TF > &rhs) |
Bitwise AND operator for two dense vectors. More... | |
template<typename VT1 , typename VT2 , bool TF> | |
decltype(auto) | blaze::operator| (const DenseVector< VT1, TF > &lhs, const DenseVector< VT2, TF > &rhs) |
Bitwise OR operator for two dense vectors. More... | |
template<typename VT1 , typename VT2 , bool TF> | |
decltype(auto) | blaze::operator^ (const DenseVector< VT1, TF > &lhs, const DenseVector< VT2, TF > &rhs) |
Bitwise XOR operator for two dense vectors. More... | |
template<typename VT1 , typename VT2 , bool TF> | |
decltype(auto) | blaze::operator&& (const DenseVector< VT1, TF > &lhs, const DenseVector< VT2, TF > &rhs) |
Logical AND operator for two dense vectors. More... | |
template<typename VT1 , typename VT2 , bool TF> | |
decltype(auto) | blaze::operator|| (const DenseVector< VT1, TF > &lhs, const DenseVector< VT2, TF > &rhs) |
Logical OR operator for two dense vectors. More... | |
template<typename VT1 , typename VT2 , bool TF> | |
decltype(auto) | blaze::operator* (const DenseVector< VT1, TF > &lhs, const DenseVector< VT2, TF > &rhs) |
Multiplication operator for the componentwise product of two dense vectors ( ![]() | |
template<typename VT1 , typename VT2 , bool TF> | |
decltype(auto) | blaze::operator- (const DenseVector< VT1, TF > &lhs, const DenseVector< VT2, TF > &rhs) |
Subtraction operator for the subtraction of two dense vectors ( ![]() | |
template<typename VT , bool TF> | |
decltype(auto) | blaze::eval (const DenseVector< VT, TF > &dv) |
Forces the evaluation of the given dense vector expression dv. More... | |
template<typename VT , bool TF> | |
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> | |
decltype(auto) | blaze::fix (DenseVector< VT, TF > &dv) noexcept |
Fixing the size of the given dense vector. More... | |
template<bool TF = defaultTransposeFlag, typename OP > | |
decltype(auto) | blaze::generate (size_t size, OP op) |
Generates a new dense vector filled via the given custom unary operation. More... | |
template<bool TF = defaultTransposeFlag, typename T > | |
decltype(auto) | blaze::linspace (size_t size, T start, T end) |
Generates a new dense vector filled with linearly spaced elements. More... | |
template<bool TF = defaultTransposeFlag, typename T > | |
decltype(auto) | blaze::logspace (size_t size, T start, T end) |
Generates a new dense vector filled with logarithmically spaced elements. 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, typename ST , EnableIf_t< IsScalar_v< ST > > * = nullptr> | |
decltype(auto) | blaze::min (const DenseVector< VT, TF > &dv, ST scalar) |
Computes the componentwise minimum of a dense vector dv and a scalar. More... | |
template<typename ST , typename VT , bool TF, EnableIf_t< IsScalar_v< ST > > * = nullptr> | |
decltype(auto) | blaze::min (ST scalar, const DenseVector< VT, TF > &dv) |
Computes the componentwise minimum of a scalar and a dense vector dv. More... | |
template<typename VT , bool TF, typename ST , EnableIf_t< IsScalar_v< ST > > * = nullptr> | |
decltype(auto) | blaze::max (const DenseVector< VT, TF > &dv, ST scalar) |
Computes the componentwise maximum of a dense vector dv and a scalar. More... | |
template<typename ST , typename VT , bool TF, EnableIf_t< IsScalar_v< ST > > * = nullptr> | |
decltype(auto) | blaze::max (ST scalar, const DenseVector< VT, TF > &dv) |
Computes the componentwise maximum of a scalar and a 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::arg (const DenseVector< VT, TF > &dv) |
Returns a vector containing the phase angle of each single element of dv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | blaze::sqrt (const DenseVector< VT, TF > &dv) |
Computes the square root of each single element of the dense vector dv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | blaze::invsqrt (const DenseVector< VT, TF > &dv) |
Computes the inverse square root of each single element of the dense vector dv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | blaze::cbrt (const DenseVector< VT, TF > &dv) |
Computes the cubic root of each single element of the dense vector dv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | blaze::invcbrt (const DenseVector< VT, TF > &dv) |
Computes the inverse cubic root of each single element of the dense vector dv. More... | |
template<typename VT , bool TF, typename DT > | |
decltype(auto) | blaze::clamp (const DenseVector< VT, TF > &dv, const DT &min, const DT &max) |
Restricts each single element of the dense vector dv to the range ![]() | |
template<typename VT , bool TF, typename ST , EnableIf_t< IsScalar_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 ![]() | |
template<typename VT , bool TF> | |
decltype(auto) | blaze::exp2 (const DenseVector< VT, TF > &dv) |
Computes ![]() | |
template<typename VT , bool TF> | |
decltype(auto) | blaze::exp10 (const DenseVector< VT, TF > &dv) |
Computes ![]() | |
template<typename VT , bool TF> | |
decltype(auto) | blaze::log (const DenseVector< VT, TF > &dv) |
Computes the natural logarithm for each single element of the dense vector dv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | blaze::log2 (const DenseVector< VT, TF > &dv) |
Computes the binary logarithm for each single element of the dense vector dv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | blaze::log10 (const DenseVector< VT, TF > &dv) |
Computes the common logarithm for each single element of the dense vector dv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | blaze::log1p (const DenseVector< VT, TF > &dv) |
Computes the natural logarithm of x+1 for each single element of the dense vector dv. More... | |
template<typename VT , bool SO> | |
decltype(auto) | blaze::lgamma (const DenseVector< VT, SO > &dv) |
Computes the natural logarithm of the absolute value of the gamma function 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, typename ST , EnableIf_t< IsScalar_v< ST > > * = nullptr> | |
decltype(auto) | blaze::operator+ (const DenseVector< VT, TF > &vec, ST scalar) |
Addition operator for the addition of a dense vector and a scalar value ( ![]() | |
template<typename ST , typename VT , bool TF, EnableIf_t< IsScalar_v< ST > > * = nullptr> | |
decltype(auto) | blaze::operator+ (ST scalar, const DenseVector< VT, TF > &vec) |
Addition operator for the addition of a scalar value and a dense vector ( ![]() | |
template<typename VT , bool TF, typename ST , EnableIf_t< IsScalar_v< ST > > * = nullptr> | |
decltype(auto) | blaze::operator- (const DenseVector< VT, TF > &vec, ST scalar) |
Subtraction operator for the subtraction of a dense vector and a scalar value ( ![]() | |
template<typename ST , typename VT , bool TF, EnableIf_t< IsScalar_v< ST > > * = nullptr> | |
decltype(auto) | blaze::operator- (ST scalar, const DenseVector< VT, TF > &vec) |
Subtraction operator for the subtraction of a scalar value and a dense vector ( ![]() | |
template<typename ST , typename VT , bool TF, EnableIf_t< IsScalar_v< ST > > * = nullptr> | |
decltype(auto) | blaze::operator/ (ST scalar, const DenseVector< VT, TF > &vec) |
Division operator for the division of a scalar value and a dense vector ( ![]() | |
template<typename VT , bool TF> | |
decltype(auto) | blaze::operator<< (const DenseVector< VT, TF > &vec, int count) |
Left-shift operator for the uniform left-shift of a dense vector. More... | |
template<typename VT , bool TF> | |
decltype(auto) | blaze::operator>> (const DenseVector< VT, TF > &vec, int count) |
Right-shift operator for the uniform right-shift of a dense vector. More... | |
template<typename VT , bool TF, typename ST , EnableIf_t< IsScalar_v< ST > > * = nullptr> | |
decltype(auto) | blaze::operator& (const DenseVector< VT, TF > &vec, ST scalar) |
Bitwise AND operator for the bitwise AND of a dense vector and a scalar value. More... | |
template<typename VT , bool TF, typename ST , EnableIf_t< IsScalar_v< ST > > * = nullptr> | |
decltype(auto) | blaze::operator| (const DenseVector< VT, TF > &vec, ST scalar) |
Bitwise OR operator for the bitwise OR of a dense vector and a scalar value. More... | |
template<typename VT , bool TF, typename ST , EnableIf_t< IsScalar_v< ST > > * = nullptr> | |
decltype(auto) | blaze::operator^ (const DenseVector< VT, TF > &vec, ST scalar) |
Bitwise XOR operator for the bitwise XOR of a dense vector and a scalar value. More... | |
template<typename VT , bool TF> | |
decltype(auto) | blaze::operator! (const DenseVector< VT, TF > &vec) |
Logical NOT operator for the logical NOT of a dense vector. More... | |
template<typename VT , bool TF> | |
decltype(auto) | blaze::mean (const DenseVector< VT, TF > &dv) |
Computes the (arithmetic) mean for the given dense vector. More... | |
template<typename VT , bool TF> | |
decltype(auto) | blaze::noalias (const DenseVector< VT, TF > &dv) |
Forces the non-aliased evaluation of the given dense vector expression 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::linfNorm (const DenseVector< VT, TF > &dv) |
Computes the infinity 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> | |
decltype(auto) | blaze::minNorm (const DenseVector< VT, TF > &dv) |
Computes the minimum norm for the given dense vector. More... | |
template<typename VT , bool TF> | |
decltype(auto) | blaze::sqrLength (const DenseVector< VT, TF > &dv) |
Calculation of the square length (magnitude) of the dense vector ![]() | |
template<typename VT , bool TF> | |
decltype(auto) | blaze::length (const DenseVector< VT, TF > &dv) |
Calculation of the length (magnitude) of the dense vector ![]() | |
template<typename VT , bool TF> | |
decltype(auto) | blaze::nosimd (const DenseVector< VT, TF > &dv) |
Disables the SIMD evaluation of the given dense vector expression dv. 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 , bool TF> | |
size_t | blaze::argmin (const DenseVector< VT, TF > &dv) |
Returns the index of the first smallest element of the dense vector. More... | |
template<typename VT , bool TF> | |
size_t | blaze::argmax (const DenseVector< VT, TF > &dv) |
Returns the index of the first largest element of the dense vector. More... | |
template<typename VT , bool TF> | |
decltype(auto) | blaze::repeat (const DenseVector< VT, TF > &dv, size_t repetitions) |
Repeats the given dense vector. More... | |
template<size_t R0, typename VT , bool TF> | |
decltype(auto) | blaze::repeat (const DenseVector< VT, TF > &dv) |
Repeats the given dense vector. More... | |
template<typename VT , typename ST , bool TF, EnableIf_t< IsScalar_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 ( ![]() | |
template<typename VT , bool TF> | |
decltype(auto) | blaze::operator- (const DenseVector< VT, TF > &dv) |
Unary minus operator for the negation of a dense vector ( ![]() | |
template<typename VT , typename ST , bool TF, EnableIf_t< IsScalar_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 ( ![]() | |
template<typename ST , typename VT , bool TF, EnableIf_t< IsScalar_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 ( ![]() | |
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 VT , bool TF> | |
decltype(auto) | blaze::stddev (const DenseVector< VT, TF > &dv) |
Computes the standard deviation 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 ( ![]() | |
template<typename VT1 , typename VT2 , bool TF> | |
decltype(auto) | blaze::operator+ (const SparseVector< VT1, TF > &lhs, const DenseVector< VT2, TF > &rhs) |
Addition operator for the addition of a sparse vector and a dense vector ( ![]() | |
template<typename VT1 , typename VT2 , bool TF> | |
decltype(auto) | blaze::operator% (const DenseVector< VT1, TF > &lhs, const SparseVector< VT2, TF > &rhs) |
Operator for the cross product of a dense vector and a sparse vector ( ![]() | |
template<typename VT1 , 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 ( ![]() | |
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 VT , bool TF> | |
decltype(auto) | blaze::var (const DenseVector< VT, TF > &dv) |
Computes the variance for the given dense vector. More... | |
template<typename MT , typename VT > | |
decltype(auto) | blaze::operator* (const SparseMatrix< MT, false > &mat, const DenseVector< VT, false > &vec) |
Multiplication operator for the multiplication of a row-major sparse matrix and a dense vector ( ![]() | |
template<typename VT1 , typename VT2 , bool TF> | |
decltype(auto) | blaze::operator% (const SparseVector< VT1, TF > &lhs, const DenseVector< VT2, TF > &rhs) |
Operator for the cross product of a sparse vector and a dense vector ( ![]() | |
template<typename VT1 , typename VT2 , bool TF> | |
decltype(auto) | blaze::operator- (const SparseVector< VT1, TF > &lhs, const DenseVector< VT2, TF > &rhs) |
Subtraction operator for the subtraction of a sparse vector and a dense vector ( ![]() | |
template<typename VT1 , typename VT2 , bool TF> | |
decltype(auto) | blaze::operator% (const SparseVector< VT1, TF > &lhs, const SparseVector< VT2, TF > &rhs) |
Operator for the cross product of two sparse vectors ( ![]() | |
template<typename MT , typename VT > | |
decltype(auto) | blaze::operator* (const DenseMatrix< MT, true > &mat, const DenseVector< VT, false > &vec) |
Multiplication operator for the multiplication of a column-major dense matrix and a dense vector ( ![]() | |
template<typename MT , typename VT > | |
decltype(auto) | blaze::operator* (const DenseMatrix< MT, true > &mat, const SparseVector< VT, false > &vec) |
Multiplication operator for the multiplication of a column-major dense matrix and a sparse vector ( ![]() | |
template<typename VT , typename MT > | |
decltype(auto) | blaze::operator* (const DenseVector< VT, true > &vec, const DenseMatrix< MT, false > &mat) |
Multiplication operator for the multiplication of a transpose dense vector and a row-major dense matrix ( ![]() | |
template<typename VT , typename MT > | |
decltype(auto) | blaze::operator* (const DenseVector< VT, true > &vec, const SparseMatrix< MT, false > &mat) |
Multiplication operator for the multiplication of a transpose dense vector and a row-major sparse matrix ( ![]() | |
template<typename 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 ( ![]() | |
template<typename MT , typename VT > | |
decltype(auto) | blaze::operator* (const SparseMatrix< MT, true > &mat, const DenseVector< VT, false > &vec) |
Multiplication operator for the multiplication of a column-major sparse matrix and a dense vector ( ![]() | |
template<typename VT , typename MT > | |
decltype(auto) | blaze::operator* (const SparseVector< VT, true > &vec, const DenseMatrix< MT, true > &mat) |
Multiplication operator for the multiplication of a transpose sparse vector and a column-major dense matrix ( ![]() | |
DenseVector operators | |
template<typename T1 , typename T2 , bool TF> | |
auto | blaze::operator== (const DenseVector< T1, TF > &vec, T2 scalar) -> EnableIf_t< IsScalar_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< IsScalar_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< IsScalar_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< IsScalar_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< IsScalar_v< ST >, VT & > |
Addition assignment operator for the addition of a dense vector and a scalar value ( ![]() | |
template<typename VT , bool TF, typename ST > | |
auto | blaze::operator+= (DenseVector< VT, TF > &&vec, ST scalar) -> EnableIf_t< IsScalar_v< ST >, VT & > |
Addition assignment operator for the addition of a temporary dense vector and a scalar value ( ![]() | |
template<typename VT , bool TF, typename ST > | |
auto | blaze::operator-= (DenseVector< VT, TF > &vec, ST scalar) -> EnableIf_t< IsScalar_v< ST >, VT & > |
Subtraction assignment operator for the subtraction of a dense vector and a scalar value ( ![]() | |
template<typename VT , bool TF, typename ST > | |
auto | blaze::operator-= (DenseVector< VT, TF > &&vec, ST scalar) -> EnableIf_t< IsScalar_v< ST >, VT & > |
Subtraction assignment operator for the subtraction of a temporary dense vector and a scalar value ( ![]() | |
template<typename VT , bool TF, typename ST > | |
auto | blaze::operator*= (DenseVector< VT, TF > &vec, ST scalar) -> EnableIf_t< IsScalar_v< ST >, VT & > |
Multiplication assignment operator for the multiplication of a dense vector and a scalar value ( ![]() | |
template<typename VT , bool TF, typename ST > | |
auto | blaze::operator*= (DenseVector< VT, TF > &&vec, ST scalar) -> EnableIf_t< IsScalar_v< ST >, VT & > |
Multiplication assignment operator for the multiplication of a temporary dense vector and a scalar value ( ![]() | |
template<typename VT , bool TF, typename ST > | |
auto | blaze::operator/= (DenseVector< VT, TF > &vec, ST scalar) -> EnableIf_t< IsScalar_v< ST >, VT & > |
Division assignment operator for the division of a dense vector by a scalar value ( ![]() | |
template<typename VT , bool TF, typename ST > | |
auto | blaze::operator/= (DenseVector< VT, TF > &&vec, ST scalar) -> EnableIf_t< IsScalar_v< ST >, VT & > |
Division assignment operator for the division of a temporary dense vector by a scalar value ( ![]() | |
template<typename VT , bool TF> | |
VT & | blaze::operator<<= (DenseVector< VT, TF > &vec, int count) |
Left-shift assignment operator for the uniform left-shift of a dense vector. More... | |
template<typename VT , bool TF> | |
VT & | blaze::operator<<= (DenseVector< VT, TF > &&vec, int count) |
Left-shift assignment operator for the uniform shift of a temporary dense vector. More... | |
template<typename VT1 , typename VT2 , bool TF> | |
VT1 & | blaze::operator<<= (DenseVector< VT1, TF > &lhs, const DenseVector< VT2, TF > &rhs) |
Left-shift assignment operator for the elementwise left-shift of a dense vector. More... | |
template<typename VT1 , typename VT2 , bool TF> | |
VT1 & | blaze::operator<<= (DenseVector< VT1, TF > &&lhs, const DenseVector< VT2, TF > &rhs) |
Left-shift assignment operator for the elementwise left-shift of a temporary dense vector. More... | |
template<typename VT , bool TF> | |
VT & | blaze::operator>>= (DenseVector< VT, TF > &vec, int count) |
Right-shift assignment operator for the uniform right-shift of a dense vector. More... | |
template<typename VT , bool TF> | |
VT & | blaze::operator>>= (DenseVector< VT, TF > &&vec, int count) |
Right-shift assignment operator for the uniform shift of a temporary dense vector. More... | |
template<typename VT1 , typename VT2 , bool TF> | |
VT1 & | blaze::operator>>= (DenseVector< VT1, TF > &lhs, const DenseVector< VT2, TF > &rhs) |
Right-shift assignment operator for the elementwise right-shift of a dense vector. More... | |
template<typename VT1 , typename VT2 , bool TF> | |
VT1 & | blaze::operator>>= (DenseVector< VT1, TF > &&lhs, const DenseVector< VT2, TF > &rhs) |
Right-shift assignment operator for the elementwise right-shift of a temporary dense. More... | |
template<typename VT , bool TF, typename ST > | |
auto | blaze::operator&= (DenseVector< VT, TF > &vec, ST scalar) -> EnableIf_t< IsScalar_v< ST >, VT & > |
Bitwise AND assignment operator for the bitwise AND of a dense vector and a scalar value. More... | |
template<typename VT , bool TF, typename ST > | |
auto | blaze::operator&= (DenseVector< VT, TF > &&vec, ST scalar) -> EnableIf_t< IsScalar_v< ST >, VT & > |
Bitwise AND assignment operator for the bitwise AND of a temporary dense vector and a scalar value. More... | |
template<typename VT1 , typename VT2 , bool TF> | |
VT1 & | blaze::operator&= (DenseVector< VT1, TF > &lhs, const DenseVector< VT2, TF > &rhs) |
Bitwise AND assignment operator for the bitwise AND of a dense vector. More... | |
template<typename VT1 , typename VT2 , bool TF> | |
VT1 & | blaze::operator&= (DenseVector< VT1, TF > &&lhs, const DenseVector< VT2, TF > &rhs) |
Bitwise AND assignment operator for the bitwise AND of a temporary dense vector. More... | |
template<typename VT , bool TF, typename ST > | |
auto | blaze::operator|= (DenseVector< VT, TF > &vec, ST scalar) -> EnableIf_t< IsScalar_v< ST >, VT & > |
Bitwise OR assignment operator for the bitwise OR of a dense vector and a scalar value. More... | |
template<typename VT , bool TF, typename ST > | |
auto | blaze::operator|= (DenseVector< VT, TF > &&vec, ST scalar) -> EnableIf_t< IsScalar_v< ST >, VT & > |
Bitwise OR assignment operator for the bitwise OR of a temporary dense vector and a scalar value. More... | |
template<typename VT1 , typename VT2 , bool TF> | |
VT1 & | blaze::operator|= (DenseVector< VT1, TF > &lhs, const DenseVector< VT2, TF > &rhs) |
Bitwise OR assignment operator for the bitwise OR of a dense vector. More... | |
template<typename VT1 , typename VT2 , bool TF> | |
VT1 & | blaze::operator|= (DenseVector< VT1, TF > &&lhs, const DenseVector< VT2, TF > &rhs) |
Bitwise OR assignment operator for the bitwise OR of a temporary dense vector. More... | |
template<typename VT , bool TF, typename ST > | |
auto | blaze::operator^= (DenseVector< VT, TF > &vec, ST scalar) -> EnableIf_t< IsScalar_v< ST >, VT & > |
Bitwise XOR assignment operator for the bitwise XOR of a dense vector and a scalar value. More... | |
template<typename VT , bool TF, typename ST > | |
auto | blaze::operator^= (DenseVector< VT, TF > &&vec, ST scalar) -> EnableIf_t< IsScalar_v< ST >, VT & > |
Bitwise XOR assignment operator for the bitwise XOR of a temporary dense vector and a scalar value. More... | |
template<typename VT1 , typename VT2 , bool TF> | |
VT1 & | blaze::operator^= (DenseVector< VT1, TF > &lhs, const DenseVector< VT2, TF > &rhs) |
Bitwise XOR assignment operator for the bitwise XOR of a dense vector. More... | |
template<typename VT1 , typename VT2 , bool TF> | |
VT1 & | blaze::operator^= (DenseVector< VT1, TF > &&lhs, const DenseVector< VT2, TF > &rhs) |
Bitwise XOR assignment operator for the bitwise XOR of a temporary dense vector. More... | |
DenseVector functions | |
template<typename VT , bool TF> | |
bool | blaze::isnan (const DenseVector< VT, TF > &dv) |
Checks the given dense vector for not-a-number elements. More... | |
template<typename VT , bool TF> | |
bool | blaze::isinf (const DenseVector< VT, TF > &dv) |
Checks the given dense vector for infinite elements. More... | |
template<typename VT , bool TF> | |
bool | blaze::isfinite (const DenseVector< VT, TF > &dv) |
Checks the given dense vector for finite 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<RelaxationFlag 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<RelaxationFlag RF, typename VT , bool TF> | |
bool | blaze::isZero (const DenseVector< VT, TF > &dv) |
Checks if the given dense vector is a zero vector. More... | |
DenseVector global functions | |
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... | |
|
inline |
Applies the abs() function to each single element of the dense vector dv.
dv | The input vector. |
This function applies the abs() function to each element of the input vector dv. The function returns an expression representing this operation.
The following example demonstrates the use of the abs() function:
|
inline |
Computes the inverse cosine for each single element of the dense vector dv.
dv | The input vector; all elements must be in the range ![]() |
The acos() function computes the inverse cosine for each element of the input vector dv. The function returns an expression representing this operation.
The following example demonstrates the use of the acos() function:
|
inline |
Computes the inverse hyperbolic cosine for each single element of the dense vector dv.
dv | The input vector; all elements must be in the range ![]() |
The acosh() function computes the inverse hyperbolic cosine for each element of the input vector dv. The function returns an expression representing this operation.
The following example demonstrates the use of the acosh() function:
|
inline |
Returns a vector containing the phase angle of each single element of dv.
dv | The input vector. |
The arg() function calculates the phase angle of each element of the input vector dv. The function returns an expression representing this operation.
The following example demonstrates the use of the arg() function:
|
inline |
Returns the index of the first largest element of the dense vector.
dv | The given dense vector. |
This function returns the index of the first 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 index is 0.
|
inline |
Returns the index of the first smallest element of the dense vector.
dv | The given dense vector. |
This function returns the index of the first 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 index is 0.
|
inline |
Computes the inverse sine for each single element of the dense vector dv.
dv | The input vector; all elements must be in the range ![]() |
The asin() function computes the inverse sine for each element of the input vector dv. The function returns an expression representing this operation.
The following example demonstrates the use of the asin() function:
|
inline |
Computes the inverse hyperbolic sine for each single element of the dense vector dv.
dv | The input vector. |
The asinh() function computes the inverse hyperbolic sine for each element of the input vector dv. The function returns an expression representing this operation.
The following example demonstrates the use of the asinh() function:
|
inline |
Computes the inverse tangent for each single element of the dense vector dv.
dv | The input vector. |
The atan() function computes the inverse tangent for each element of the input vector dv. The function returns an expression representing this operation.
The following example demonstrates the use of the atan() function:
|
inline |
Computes the multi-valued inverse tangent of the dense vectors lhs and rhs.
lhs | The left-hand side dense vector operand. |
rhs | The right-hand side dense vector operand. |
std::invalid_argument | Vector sizes do not match. |
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:
In case the current sizes of the two given vectors don't match, a std::invalid_argument is thrown.
|
inline |
Computes the inverse hyperbolic tangent for each single element of the dense vector dv.
dv | The input vector; all elements must be in the range ![]() |
The atanh() function computes the inverse hyperbolic tangent for each element of the input vector dv. The function returns an expression representing this operation.
The following example demonstrates the use of the atanh() function:
|
inline |
Computes the cubic root of each single element of the dense vector dv.
dv | The input vector; all elements must be in the range ![]() |
The cbrt() function computes the cubic root of each element of the input vector dv. The function returns an expression representing this operation.
The following example demonstrates the use of the cbrt() function:
|
inline |
Applies the ceil() function to each single element of the dense vector dv.
dv | The input vector. |
This function applies the ceil() function to each element of the input vector dv. The function returns an expression representing this operation.
The following example demonstrates the use of the ceil() function:
|
inline |
Restricts each single element of the dense vector dv to the range .
dv | The input vector. |
min | The lower delimiter. |
max | The upper delimiter. |
The clamp() function restricts each element of the input vector dv to the range . The function returns an expression representing this operation.
The following example demonstrates the use of the clamp() function:
|
inline |
Returns a vector containing the complex conjugate of each single element of dv.
dv | The input vector. |
The conj() function calculates the complex conjugate of each element of the input vector dv. The function returns an expression representing this operation.
The following example demonstrates the use of the conj() function:
|
inline |
Computes the cosine for each single element of the dense vector dv.
dv | The input vector. |
The cos() function computes the cosine for each element of the input vector dv. The function returns an expression representing this operation.
The following example demonstrates the use of the cos() function:
|
inline |
Computes the hyperbolic cosine for each single element of the dense vector dv.
dv | The input vector. |
The cosh() function computes the hyperbolic cosine for each element of the input vector dv. The function returns an expression representing this operation.
The following example demonstrates the use of the cosh() function:
|
inline |
Returns the conjugate transpose vector of dv.
dv | The input vector. |
The ctrans() function returns an expression representing the conjugate transpose (also called adjoint matrix, Hermitian conjugate matrix or transjugate matrix) of the given input vector dv.
The following example demonstrates the use of the ctrans() function:
Note that the ctrans() function has the same effect as manually applying the conj() and trans function in any order:
|
noexcept |
Low-level data access to the dense vector elements.
dv | The given dense vector. |
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
.
|
noexcept |
Low-level data access to the dense vector elements.
dv | The given dense vector. |
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
.
|
inline |
Calculation of the eigenvalues of the given dense matrix.
dm | The given general matrix. |
std::invalid_argument | Invalid non-square matrix provided. |
This function returns an expression representing the eigenvalues of the given dense matrix:
eigen()
function can only be used for dense matrices with float
, double
, complex<float>
or complex<double>
element type. The attempt to call the function with matrices of any other element type results in a compile time error!eigen()
function. Also, it is not possible to access individual elements via the subscript operator on the expression object:
|
inline |
Computes the error function for each single element of the dense vector dv.
dv | The input vector. |
The erf() function computes the error function for each element of the input vector dv. The function returns an expression representing this operation.
The following example demonstrates the use of the erf() function:
|
inline |
Computes the complementary error function for each single element of the dense vector dv.
dv | The input vector. |
The erfc() function computes the complementary error function for each element of the input vector dv. The function returns an expression representing this operation.
The following example demonstrates the use of the erfc() function:
|
inline |
Forces the evaluation of the given dense vector expression dv.
dv | The input vector. |
The eval function forces the evaluation of the given dense vector expression dv. The function returns an expression representing this operation.
The following example demonstrates the use of the eval function:
|
inline |
Computes for each single element of the dense vector dv.
dv | The input vector. |
The exp() function computes for each element of the input vector dv. The function returns an expression representing this operation.
The following example demonstrates the use of the exp() function:
|
inline |
Computes for each single element of the dense vector dv.
dv | The input vector. |
The exp10() function computes for each element of the input vector dv. The function returns an expression representing this operation.
The following example demonstrates the use of the exp10() function:
|
inline |
Computes for each single element of the dense vector dv.
dv | The input vector. |
The exp2() function computes for each element of the input vector dv. The function returns an expression representing this operation.
The following example demonstrates the use of the exp2() function:
|
inline |
Expansion of the given dense vector.
dv | The dense vector to be expanded. |
This function returns an expression representing the expansion of the given dense vector:
|
inline |
Expansion of the given dense vector.
dv | The dense vector to be expanded. |
expansion | The expansion. |
This function returns an expression representing the expansion of the given dense vector:
|
noexcept |
Fixing the size of the given dense vector.
dv | The dense vector to be size-fixed. |
This function returns an expression representing the size-fixed given dense vector:
|
inline |
Applies the floor() function to each single element of the dense vector dv.
dv | The input vector. |
This function applies the floor() function to each element of the input vector dv. The function returns an expression representing this operation.
The following example demonstrates the use of the floor() function:
|
inline |
Evaluates the given custom operation on each single element of the dense vector dv.
dv | The input vector. |
op | The custom operation. |
The forEach() function evaluates the given custom operation on each element of the input vector dv. The function returns an expression representing this operation.
The following example demonstrates the use of the forEach() function:
|
inline |
Generates a new dense vector filled via the given custom unary operation.
size | The size/dimension of the vector. |
op | The custom unary operation. |
The generate()
function returns a dense vector filled elementwise via the given custom unary operation. By default, the returned vector is a column vector, but this setting can be changed via the BLAZE_DEFAULT_TRANSPOSE_FLAG
switch. Alternatively it is possible to specify the transpose flag explicitly.
The following example demonstrates the use of the generate() function:
|
inline |
Computes the componentwise hypotenous for the dense vectors lhs and rhs.
lhs | The left-hand side dense vector operand. |
rhs | The right-hand side dense vector operand. |
std::invalid_argument | Vector sizes do not match. |
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:
In case the current sizes of the two given vectors don't match, a std::invalid_argument is thrown.
|
inline |
Returns a vector containing the imaginary part of each single element of dv.
dv | The input vector. |
The imag() function calculates the imaginary part of each element of the input vector dv. The function returns an expression representing this operation.
The following example demonstrates the use of the imag() function:
|
inline |
Computes the inverse cubic root of each single element of the dense vector dv.
dv | The input vector; all elements must be in the range ![]() |
The invcbrt() function computes the inverse cubic root of each element of the input vector dv. The function returns an expression representing this operation.
The following example demonstrates the use of the invcbrt() function:
|
inline |
Computes the inverse square root of each single element of the dense vector dv.
dv | The input vector; all elements must be in the range ![]() |
The invsqrt() function computes the inverse square root of each element of the input vector dv. The function returns an expression representing this operation.
The following example demonstrates the use of the invsqrt() function:
bool blaze::isDivisor | ( | const DenseVector< VT, TF > & | dv | ) |
Returns whether the given dense vector is a valid divisor.
dv | The dense vector to be tested. |
This function checks if the given dense vector is a valid divisor. If all elements of the vector are valid divisors the function returns true, if at least one element of the vector is not a valid divisor, the function returns false.
bool blaze::isfinite | ( | const DenseVector< VT, TF > & | dv | ) |
Checks the given dense vector for finite elements.
dv | The dense vector to be checked for finite elements. |
This function checks if all elements of the N-dimensional dense vector are finite elements (i.e. normal, subnormal or zero elements, but not infinite or NaN). If all elements of the vector are finite, the function returns true, otherwise it returns false.
bool blaze::isinf | ( | const DenseVector< VT, TF > & | dv | ) |
Checks the given dense vector for infinite elements.
dv | The dense vector to be checked for infinite elements. |
This function checks the N-dimensional dense vector for infinite elements. If at least one element of the vector is infinite, the function returns true, otherwise it returns false.
bool blaze::isnan | ( | const DenseVector< VT, TF > & | dv | ) |
Checks the given dense vector for not-a-number elements.
dv | The dense vector to be checked for not-a-number elements. |
This function checks the N-dimensional dense vector for not-a-number (NaN) elements. If at least one element of the vector is not-a-number, the function returns true, otherwise it returns false.
bool blaze::isUniform | ( | const DenseVector< VT, TF > & | dv | ) |
Checks if the given dense vector is a uniform vector.
dv | The dense vector to be checked. |
This function checks if the given dense vector is a uniform vector. The vector is considered to be uniform if all its elements are identical. The following code example demonstrates the use of the function:
Optionally, it is possible to switch between strict semantics (blaze::strict) and relaxed semantics (blaze::relaxed):
It is also possible to check if a vector expression results is a uniform vector:
However, note that this might require the complete evaluation of the expression, including the generation of a temporary vector.
bool blaze::isZero | ( | const DenseVector< VT, TF > & | dv | ) |
Checks if the given dense vector is a zero vector.
dv | The dense vector to be checked. |
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:
Optionally, it is possible to switch between strict semantics (blaze::strict) and relaxed semantics (blaze::relaxed):
It is also possible to check if a vector expression results is a zero vector:
However, note that this might require the complete evaluation of the expression, including the generation of a temporary vector.
|
inline |
Computes the Kronecker product of two dense vectors ( ).
lhs | The left-hand side dense vector for the Kronecker product. |
rhs | The right-hand side dense vector for the Kronecker product. |
The kron() function computes the Kronecker product of the two given dense vectors:
The function 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 MultTrait class template.
|
inline |
Computes the L1 norm for the given dense vector.
dv | The given dense vector for the norm computation. |
This function computes the L1 norm of the given dense vector:
|
inline |
Computes the L2 norm for the given dense vector.
dv | The given dense vector for the norm computation. |
This function computes the L2 norm of the given dense vector:
|
inline |
Computes the L3 norm for the given dense vector.
dv | The given dense vector for the norm computation. |
This function computes the L3 norm of the given dense vector:
|
inline |
Computes the L4 norm for the given dense vector.
dv | The given dense vector for the norm computation. |
This function computes the L4 norm of the given dense vector:
|
inline |
Calculation of the length (magnitude) of the dense vector .
dv | The given dense vector. |
This function calculates the actual length (magnitude) of the dense vector. The function has the same effect as calling the norm() function on the dense vector.
|
inline |
Computes the natural logarithm of the absolute value of the gamma function for each single element of the dense vector dv.
dv | The input vector; all elements must be in the range ![]() |
The lgamma() function computes the natural logarithm of the absolute value of the gamma 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 lgamma() function:
|
inline |
Computes the infinity norm for the given dense vector.
dv | The given dense vector for the norm computation. |
This function computes the infinity norm of the given dense vector:
|
inline |
Generates a new dense vector filled with linearly spaced elements.
size | The size/dimension of the given vector. |
start | The value of the first element. |
end | The value of the last element. |
The linspace() function returns a dense vector filled with linearly spaced elements from start to end. By default, the returned vector is a column vector, but this setting can be changed via the BLAZE_DEFAULT_TRANSPOSE_FLAG
switch. Alternatively it is possible to specify the transpose flag explicitly.
The following example demonstrates the use of the linspace() function:
|
inline |
Computes the natural logarithm for each single element of the dense vector dv.
dv | The input vector; all elements must be in the range ![]() |
The log() function computes natural logarithm for each element of the input vector dv. The function returns an expression representing this operation.
The following example demonstrates the use of the log() function:
|
inline |
Computes the common logarithm for each single element of the dense vector dv.
dv | The input vector; all elements must be in the range ![]() |
The log10() function computes common logarithm for each element of the input vector dv. The function returns an expression representing this operation.
The following example demonstrates the use of the log10() function:
|
inline |
Computes the natural logarithm of x+1 for each single element of the dense vector dv.
dv | The input vector; all elements must be in the range ![]() |
The log1p() function computes the natural logarithm of x+1 for each element of the input vector dv. This may be preferred over the natural logarithm for higher precision computing the natural logarithm of a quantity very close to 1. The function returns an expression representing this operation.
The following example demonstrates the use of the log1p() function:
|
inline |
Computes the binary logarithm for each single element of the dense vector dv.
dv | The input vector; all elements must be in the range ![]() |
The log2() function computes binary logarithm for each element of the input vector dv. The function returns an expression representing this operation.
The following example demonstrates the use of the log2() function:
|
inline |
Generates a new dense vector filled with logarithmically spaced elements.
size | The size/dimension of the given vector. |
start | The value of the first element. |
end | The value of the last element. |
The logspace() function returns a dense vector filled with logarithmically spaced elements from start to end. By default, the returned vector is a column vector, but this setting can be changed via the BLAZE_DEFAULT_TRANSPOSE_FLAG
switch. Alternatively it is possible to specify the transpose flag explicitly.
The following example demonstrates the use of the logspace() function:
|
inline |
Computes the Lp norm for the given dense vector.
dv | The given dense vector for the norm computation. |
This function computes the Lp norm of the given dense vector, where the norm is specified by the runtime argument P:
|
inline |
Computes the Lp norm for the given dense vector.
dv | The given dense vector for the norm computation. |
p | The norm parameter (p > 0). |
This function computes the Lp norm of the given dense vector, where the norm is specified by the runtime argument p:
|
inline |
Evaluates the given custom operation on each single element of the dense vector dv.
dv | The input vector. |
op | The custom operation. |
The map() function evaluates the given custom operation on each element of the input vector dv. The function returns an expression representing this operation.
The following example demonstrates the use of the map() function:
|
inline |
Elementwise evaluation of the given 6-ary operation on each single element of the dense vectors dv1, dv2, dv3, dv4, dv5, and dv6.
dv1 | The first dense vector operand. |
dv2 | The second dense vector operand. |
dv3 | The third dense vector operand. |
dv4 | The fourth dense vector operand. |
dv5 | The fifth dense vector operand. |
dv6 | The sixth dense vector operand. |
op | The custom, 6-ary operation. |
std::invalid_argument | Vector sizes do not match. |
The map() function evaluates the given 6-ary operation on each single element of the input vectors dv1, dv2, dv3, dv4, dv5, and dv6. The function returns an expression representing this operation.
In case the current sizes of the six given vectors don't match, a std::invalid_argument is thrown.
|
inline |
Elementwise evaluation of the given 5-ary operation on each single element of the dense vectors dv1, dv2, dv3, dv4, and dv5.
dv1 | The first dense vector operand. |
dv2 | The second dense vector operand. |
dv3 | The third dense vector operand. |
dv4 | The fourth dense vector operand. |
dv5 | The fifth dense vector operand. |
op | The custom, 5-ary operation. |
std::invalid_argument | Vector sizes do not match. |
The map() function evaluates the given 5-ary operation on each single element of the input vectors dv1, dv2, dv3, dv4, and dv5. The function returns an expression representing this operation.
In case the current sizes of the five given vectors don't match, a std::invalid_argument is thrown.
|
inline |
Elementwise evaluation of the given 4-ary operation on each single element of the dense vectors dv1, dv2, dv3, and dv4.
dv1 | The first dense vector operand. |
dv2 | The second dense vector operand. |
dv3 | The third dense vector operand. |
dv4 | The fourth dense vector operand. |
op | The custom, 4-ary operation. |
std::invalid_argument | Vector sizes do not match. |
The map() function evaluates the given 4-ary operation on each single element of the input vectors dv1, dv2, dv3, and dv4. The function returns an expression representing this operation.
In case the current sizes of the four given vectors don't match, a std::invalid_argument is thrown.
|
inline |
Elementwise evaluation of the given ternary operation on each single element of the dense vectors dv1, dv2, and dv3.
dv1 | The first dense vector operand. |
dv2 | The second dense vector operand. |
dv3 | The third dense vector operand. |
op | The custom, ternary operation. |
std::invalid_argument | Vector sizes do not match. |
The map() function evaluates the given ternary operation on each single element of the input vectors dv1, dv2, and dv3. The function returns an expression representing this operation.
In case the current sizes of the three given vectors don't match, a std::invalid_argument is thrown.
|
inline |
Elementwise evaluation of the given binary operation on each single element of the dense vectors lhs and rhs.
lhs | The left-hand side dense vector operand. |
rhs | The right-hand side dense vector operand. |
op | The custom, binary operation. |
std::invalid_argument | Vector sizes do not match. |
The map() function evaluates the given binary operation on each single 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:
In case the current sizes of the two given vectors don't match, a std::invalid_argument is thrown.
|
inline |
Returns the largest element of the dense vector.
dv | The given dense vector. |
This function returns the largest element of the given dense vector. This function can only be used for element types that support the smaller-than relationship. In case the given vector currently has a size of 0, the returned value is the default value (e.g. 0 in case of fundamental data types).
decltype(auto) blaze::max | ( | const DenseVector< VT, TF > & | dv, |
ST | scalar | ||
) |
Computes the componentwise maximum of a dense vector dv and a scalar.
dv | The left-hand side dense vector operand. |
scalar | The right-hand side scalar value. |
This operator computes the componentwise maximum of a dense vector dv and a uniform vector represented by the scalar value scalar. The function returns an expression representing this operation.
The following example demonstrates the use of the max() function:
In case the current sizes of the two given vectors don't match, a std::invalid_argument is thrown.
|
inline |
Computes the componentwise maximum of the dense vectors lhs and rhs.
lhs | The left-hand side dense vector operand. |
rhs | The right-hand side dense vector operand. |
std::invalid_argument | Vector sizes do not match. |
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:
In case the current sizes of the two given vectors don't match, a std::invalid_argument is thrown.
decltype(auto) blaze::max | ( | ST | scalar, |
const DenseVector< VT, TF > & | dv | ||
) |
Computes the componentwise maximum of a scalar and a dense vector dv.
scalar | The left-hand side scalar value. |
dv | The right-hand side dense vector operand. |
This operator computes the componentwise maximum of a uniform vector represented by the scalar value scalar and a dense vector dv. The function returns an expression representing this operation.
The following example demonstrates the use of the max() function:
|
inline |
Computes the maximum norm for the given dense vector.
dv | The given dense vector for the norm computation. |
This function computes the maximum norm of the given dense vector:
|
inline |
Computes the (arithmetic) mean for the given dense vector.
dv | The given dense vector for the mean computation. |
std::invalid_argument | Invalid input vector. |
This function computes the (arithmetic) mean for the given dense vector dv. Example:
In case the size of the given vector is 0, a std::invalid_argument is thrown.
|
inline |
Returns the smallest element of the dense vector.
dv | The given dense vector. |
This function returns the smallest element of the given dense vector. This function can only be used for element types that support the smaller-than relationship. In case the given vector currently has a size of 0, the returned value is the default value (e.g. 0 in case of fundamental data types).
decltype(auto) blaze::min | ( | const DenseVector< VT, TF > & | dv, |
ST | scalar | ||
) |
Computes the componentwise minimum of a dense vector dv and a scalar.
dv | The left-hand side dense vector operand. |
scalar | The right-hand side scalar value. |
This operator computes the componentwise minimum of a dense vector dv and a uniform vector represented by the scalar value scalar. The function returns an expression representing this operation.
The following example demonstrates the use of the min() function:
|
inline |
Computes the componentwise minimum of the dense vectors lhs and rhs.
lhs | The left-hand side dense vector operand. |
rhs | The right-hand side dense vector operand. |
std::invalid_argument | Vector sizes do not match. |
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:
In case the current sizes of the two given vectors don't match, a std::invalid_argument is thrown.
decltype(auto) blaze::min | ( | ST | scalar, |
const DenseVector< VT, TF > & | dv | ||
) |
Computes the componentwise minimum of a scalar and a dense vector dv.
scalar | The left-hand side scalar value. |
dv | The right-hand side dense vector operand. |
This operator computes the componentwise minimum of a uniform vector represented by the scalar value scalar and a dense vector dv. The function returns an expression representing this operation.
The following example demonstrates the use of the min() function:
|
inline |
Computes the minimum norm for the given dense vector.
dv | The given dense vector for the norm computation. |
This function computes the minimum norm of the given dense vector:
|
inline |
Forces the non-aliased evaluation of the given dense vector expression dv.
dv | The input vector. |
The noalias function forces the non-aliased evaluation of the given dense vector expression dv. The function returns an expression representing this operation.
The following example demonstrates the use of the noalias function:
|
inline |
Computes the L2 norm for the given dense vector.
dv | The given dense vector for the norm computation. |
This function computes the L2 norm of the given dense vector:
|
inline |
Disables the SIMD evaluation of the given dense vector expression dv.
dv | The input vector. |
The nosimd function disables the SIMD evaluation of the given dense vector expression dv. The function returns an expression representing this operation.
The following example demonstrates the use of the nosimd function:
|
inline |
Logical NOT operator for the logical NOT of a dense vector.
vec | The dense vector for the logical NOT. |
This operator represents the logical NOT of all elements of a dense vector:
|
inline |
Inequality operator for the comparison of a dense vector and a scalar value.
vec | The left-hand side dense vector for the comparison. |
scalar | The right-hand side scalar value for the comparison. |
If one value of the vector is inequal to the scalar value, the inequality test returns true, otherwise false. Note that this function can only be used with built-in, numerical data types!
|
inline |
Inequality operator for the comparison of two dense vectors.
lhs | The left-hand side dense vector for the comparison. |
rhs | The right-hand side dense vector for the comparison. |
|
inline |
Inequality operator for the comparison of a dense vector and a sparse vector.
lhs | The left-hand side dense vector for the comparison. |
rhs | The right-hand side sparse vector for the comparison. |
|
inline |
Inequality operator for the comparison of a sparse vector and a dense vector.
lhs | The left-hand side sparse vector for the comparison. |
rhs | The right-hand side dense vector for the comparison. |
|
inline |
Inequality operator for the comparison of a scalar value and a dense vector.
scalar | The left-hand side scalar value for the comparison. |
vec | The right-hand side dense vector for the comparison. |
If one value of the vector is inequal to the scalar value, the inequality test returns true, otherwise false. Note that this function can only be used with built-in, numerical data types!
|
inline |
Operator for the cross product of two dense vectors ( ).
lhs | The left-hand side dense vector for the cross product. |
rhs | The right-hand side dense vector for the cross product. |
std::invalid_argument | Invalid vector size for cross product. |
This operator represents the cross product of two dense vectors:
The operator returns an expression representing a dense vector of the higher-order element type of the two involved vector element types VT1::ElementType and VT2::ElementType. Both vector types VT1 and VT2 as well as the two element types VT1::ElementType and VT2::ElementType have to be supported by the CrossTrait class template.
In case the current sizes of the two given vectors don't match, a std::invalid_argument is thrown.
|
inline |
Operator for the cross product of a dense vector and a sparse vector ( ).
lhs | The left-hand side dense vector for the cross product. |
rhs | The right-hand side sparse vector for the cross product. |
std::invalid_argument | Invalid vector size for cross product. |
This operator represents the cross product of a dense vector and a sparse vector:
The operator returns an expression representing a dense vector of the higher-order element type of the two involved vector element types VT1::ElementType and VT2::ElementType. Both vector types VT1 and VT2 as well as the two element types VT1::ElementType and VT2::ElementType have to be supported by the CrossTrait class template.
In case the current sizes of the two given vectors don't match, a std::invalid_argument is thrown.
|
inline |
Operator for the cross product of a sparse vector and a dense vector ( ).
lhs | The left-hand side sparse vector for the cross product. |
rhs | The right-hand side dense vector for the cross product. |
std::invalid_argument | Invalid vector size for cross product. |
This operator represents the cross product of a sparse vector and a dense vector:
The operator returns an expression representing a dense vector of the higher-order element type of the two involved vector element types VT1::ElementType and VT2::ElementType. Both vector types VT1 and VT2 as well as the two element types VT1::ElementType and VT2::ElementType have to be supported by the CrossTrait class template.
In case the current sizes of the two given vectors don't match, a std::invalid_argument is thrown.
|
inline |
Operator for the cross product of two sparse vectors ( ).
lhs | The left-hand side sparse vector for the cross product. |
rhs | The right-hand side sparse vector for the cross product. |
std::invalid_argument | Invalid vector size for cross product. |
This operator represents the cross product of two sparse vectors:
The operator returns a dense vector of the higher-order element type of the two involved vector element types VT1::ElementType and VT2::ElementType. Both vector types VT1 and VT2 as well as the two element types VT1::ElementType and VT2::ElementType have to be supported by the CrossTrait class template.
In case the current sizes of the two given vectors don't match, a std::invalid_argument is thrown.
|
inline |
Bitwise AND operator for the bitwise AND of a dense vector and a scalar value.
vec | The left-hand side dense vector for the bitwise AND. |
scalar | The right-hand side scalar value for the bitwise AND. |
This operator represents the bitwise AND of a scalar value with all elements of a dense vector:
|
inline |
Bitwise AND operator for two dense vectors.
lhs | The left-hand side dense vector for the bitwise AND operation. |
rhs | The right-hand side dense vector for the bitwise AND operation. |
std::invalid_argument | Vector sizes do not match. |
This operator represents the bitwise AND of the given two dense vectors:
In case the current sizes of the two given vectors don't match, a std::invalid_argument is thrown.
|
inline |
Logical AND operator for two dense vectors.
lhs | The left-hand side dense vector for the logical AND operation. |
rhs | The right-hand side dense vector for the logical AND operation. |
std::invalid_argument | Vector sizes do not match. |
This operator represents the logical AND of the given two dense vectors:
In case the current sizes of the two given vectors don't match, a std::invalid_argument is thrown.
|
inline |
Bitwise AND assignment operator for the bitwise AND of a temporary dense vector and a scalar value.
vec | The left-hand side temporary dense vector for the bitwise AND. |
scalar | The right-hand side scalar value for the bitwise AND. |
std::invalid_argument | Invalid bitwise AND 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.
|
inline |
Bitwise AND assignment operator for the bitwise AND of a dense vector and a scalar value.
vec | The left-hand side dense vector for the bitwise AND. |
scalar | The right-hand side scalar value for the bitwise AND. |
std::invalid_argument | Invalid bitwise AND 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.
|
inline |
Bitwise AND assignment operator for the bitwise AND of a temporary dense vector.
lhs | The left-hand side temporary dense vector for the bitwise AND operation. |
rhs | The right-hand side dense vector for the bitwise AND operation. |
std::invalid_argument | Invalid bitwise AND 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.
|
inline |
Bitwise AND assignment operator for the bitwise AND of a dense vector.
lhs | The left-hand side dense vector for the bitwise AND operation. |
rhs | The right-hand side dense vector for the bitwise AND operation. |
std::invalid_argument | Invalid bitwise AND 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.
|
inline |
Multiplication operator for the multiplication of a row-major dense matrix and a dense vector ( ).
mat | The left-hand side row-major dense matrix for the multiplication. |
vec | The right-hand side dense vector for the multiplication. |
std::invalid_argument | Matrix and vector sizes do not match. |
This operator represents the multiplication between a row-major dense matrix and a dense vector:
The operator returns an expression representing a dense vector of the higher-order element type of the two involved element types MT::ElementType and VT::ElementType. Both the dense matrix type MT and the dense vector type VT as well as the two element types MT::ElementType and VT::ElementType have to be supported by the MultTrait class template.
In case the current size of the vector vec doesn't match the current number of columns of the matrix mat, a std::invalid_argument is thrown.
|
inline |
Multiplication operator for the multiplication of a row-major dense matrix and a sparse vector ( ).
mat | The left-hand side row-major dense matrix for the multiplication. |
vec | The right-hand side sparse vector for the multiplication. |
std::invalid_argument | Matrix and vector sizes do not match. |
This operator represents the multiplication between a row-major dense matrix and a sparse vector:
The operator returns an expression representing a dense vector of the higher-order element type of the two involved element types MT::ElementType and VT::ElementType. Both the dense matrix type MT and the sparse vector type VT as well as the two element types MT::ElementType and VT::ElementType have to be supported by the MultTrait class template.
In case the current size of the vector vec doesn't match the current number of columns of the matrix mat, a std::invalid_argument is thrown.
|
inline |
Multiplication operator for the multiplication of a column-major dense matrix and a dense vector ( ).
mat | The left-hand side column-major dense matrix for the multiplication. |
vec | The right-hand side dense vector for the multiplication. |
std::invalid_argument | Matrix and vector sizes do not match. |
This operator represents the multiplication between a column-major dense matrix and a dense vector:
The operator returns an expression representing a dense vector of the higher-order element type of the two involved element types MT::ElementType and VT::ElementType. Both the dense matrix type MT and the dense vector type VT as well as the two element types MT::ElementType and VT::ElementType have to be supported by the MultTrait class template.
In case the current size of the vector vec doesn't match the current number of columns of the matrix mat, a std::invalid_argument is thrown.
|
inline |
Multiplication operator for the multiplication of a column-major dense matrix and a sparse vector ( ).
mat | The left-hand side column-major dense matrix for the multiplication. |
vec | The right-hand side sparse vector for the multiplication. |
std::invalid_argument | Matrix and vector sizes do not match. |
This operator represents the multiplication between a column-major dense matrix and a sparse vector:
The operator returns an expression representing a dense vector of the higher-order element type of the two involved element types MT::ElementType and VT::ElementType. Both the dense matrix type MT and the sparse vector type VT as well as the two element types MT::ElementType and VT::ElementType have to be supported by the MultTrait class template.
In case the current size of the vector vec doesn't match the current number of columns of the matrix mat, a std::invalid_argument is thrown.
|
inline |
Multiplication operator for the multiplication of a dense vector and a scalar value ( ).
vec | The left-hand side dense vector for the multiplication. |
scalar | The right-hand side scalar value for the multiplication. |
This operator represents the multiplication between a dense vector and a scalar value:
The operator returns an expression representing a dense vector of the higher-order element type of the involved data types VT::ElementType and ST. Both data types VT::ElementType and ST have to be supported by the MultTrait class template. Note that this operator only works for scalar values of built-in data type.
|
inline |
Multiplication operator for the multiplication of a transpose dense vector and a row-major dense matrix ( ).
vec | The left-hand side transpose dense vector for the multiplication. |
mat | The right-hand side row-major dense matrix for the multiplication. |
std::invalid_argument | Vector and matrix sizes do not match. |
This operator represents the multiplication between a transpose dense vector and a row-major dense matrix:
The operator returns an expression representing a transpose dense vector of the higher-order element type of the two involved element types VT::ElementType and MT::ElementType. Both the dense matrix type VT and the dense vector type MT as well as the two element types VT::ElementType and MT::ElementType have to be supported by the MultTrait class template.
In case the current size of the vector vec doesn't match the current number of rows of the matrix mat, a std::invalid_argument is thrown.
|
inline |
Multiplication operator for the multiplication of a transpose dense vector and a row-major sparse matrix ( ).
vec | The left-hand side transpose dense vector for the multiplication. |
mat | The right-hand side row-major sparse matrix for the multiplication. |
std::invalid_argument | Vector and matrix sizes do not match. |
This operator represents the multiplication between a transpose dense vector and a row-major sparse matrix:
The operator returns an expression representing a transpose dense vector of the higher-order element type of the two involved element types VT::ElementType and MT::ElementType. Both the sparse matrix type VT and the dense vector type MT as well as the two element types VT::ElementType and MT::ElementType have to be supported by the MultTrait class template.
In case the current size of the vector vec doesn't match the current number of rows of the matrix mat, a std::invalid_argument is thrown.
|
inline |
Multiplication operator for the multiplication of a transpose dense vector and a column-major sparse matrix ( ).
vec | The left-hand side transpose dense vector for the multiplication. |
mat | The right-hand side column-major sparse matrix for the multiplication. |
std::invalid_argument | Vector and matrix sizes do not match. |
This operator represents the multiplication between a transpose dense vector and a 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.
|
inline |
Multiplication operator for the componentwise product of two dense vectors ( ).
lhs | The left-hand side dense vector for the component product. |
rhs | The right-hand side dense vector for the component product. |
std::invalid_argument | Vector sizes do not match. |
This operator represents the component product of two dense vectors:
The operator returns an expression representing a dense vector of the higher-order element type of the two involved vector element types VT1::ElementType and VT2::ElementType. Both vector types VT1 and VT2 as well as the two element types T1::ElementType and VT2::ElementType have to be supported by the MultTrait class template.
In case the current sizes of the two given vectors don't match, a std::invalid_argument is thrown.
|
inline |
Multiplication operator for the scalar product (inner product) of two dense vectors ( ).
lhs | The left-hand side dense vector for the inner product. |
rhs | The right-hand side dense vector for the inner product. |
std::invalid_argument | Vector sizes do not match. |
This operator represents the scalar product (inner product) of two dense vectors:
The operator returns a scalar value of the higher-order element type of the two involved vector element types VT1::ElementType and VT2::ElementType. Both vector types VT1 and VT2 as well as the two element types VT1::ElementType and VT2::ElementType have to be supported by the MultTrait class template.
In case the current sizes of the two given vectors don't match, a std::invalid_argument is thrown.
|
inline |
Multiplication operator for the multiplication of a row-major sparse matrix and a dense vector ( ).
mat | The left-hand side row-major sparse matrix for the multiplication. |
vec | The right-hand side dense vector for the multiplication. |
std::invalid_argument | Matrix and vector sizes do not match. |
This operator represents the multiplication between a row-major sparse matrix and a dense vector:
The operator returns an expression representing a dense vector of the higher-order element type of the two involved element types MT::ElementType and VT::ElementType. Both the sparse matrix type MT and the dense vector type VT as well as the two element types MT::ElementType and VT::ElementType have to be supported by the MultTrait class template.
In case the current size of the vector vec doesn't match the current number of columns of the matrix mat, a std::invalid_argument is thrown.
|
inline |
Multiplication operator for the multiplication of a column-major sparse matrix and a dense vector ( ).
mat | The left-hand side column-major sparse matrix for the multiplication. |
vec | The right-hand side dense vector for the multiplication. |
std::invalid_argument | Matrix and vector sizes do not match. |
This operator represents the multiplication between a column-major sparse matrix and a dense vector:
The operator returns an expression representing a dense vector of the higher-order element type of the two involved element types MT::ElementType and VT::ElementType. Both the sparse matrix type MT and the dense vector type VT as well as the two element types MT::ElementType and VT::ElementType have to be supported by the MultTrait class template.
In case the current size of the vector vec doesn't match the current number of columns of the matrix mat, a std::invalid_argument is thrown.
|
inline |
Multiplication operator for the multiplication of a transpose sparse vector and a column-major dense matrix ( ).
vec | The left-hand side transpose sparse vector for the multiplication. |
mat | The right-hand side column-major dense matrix for the multiplication. |
std::invalid_argument | Vector and matrix sizes do not match. |
This operator represents the multiplication between a transpose sparse vector and a column-major dense matrix:
The operator returns an expression representing a transpose sparse vector of the higher-order element type of the two involved element types VT::ElementType and MT::ElementType. Both the dense matrix type VT and the dense vector type MT as well as the two element types VT::ElementType and MT::ElementType have to be supported by the MultTrait class template.
In case the current size of the vector vec doesn't match the current number of rows of the matrix mat, a std::invalid_argument is thrown.
|
inline |
Multiplication operator for the multiplication of a scalar value and a dense vector ( ).
scalar | The left-hand side scalar value for the multiplication. |
vec | The right-hand side vector for the multiplication. |
This operator represents the multiplication between a a scalar value and dense vector:
The operator returns an expression representing a dense vector of the higher-order element type of the involved data types ST and VT::ElementType. Both data types ST and VT::ElementType have to be supported by the MultTrait class template. Note that this operator only works for scalar values of built-in data type.
|
inline |
Multiplication assignment operator for the multiplication of a temporary dense vector and a scalar value ( ).
vec | The left-hand side temporary dense vector for the multiplication. |
scalar | The right-hand side scalar value for the multiplication. |
std::invalid_argument | Invalid 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.
|
inline |
Multiplication assignment operator for the multiplication of a dense vector and a scalar value ( ).
vec | The left-hand side dense vector for the multiplication. |
scalar | The right-hand side scalar value for the multiplication. |
std::invalid_argument | Invalid 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.
|
inline |
Addition operator for the addition of a dense vector and a scalar value ( ).
vec | The left-hand side dense vector for the addition. |
scalar | The right-hand side scalar value for the addition. |
This operator represents the elementwise addition of a dense vector and a uniform vector represented by a scalar value:
The operator returns an expression representing a dense vector of the higher-order element type of the involved data types VT::ElementType and ST. Both data types VT::ElementType and ST have to be supported by the AddTrait class template. Note that this operator only works for scalar values of built-in data type.
|
inline |
Addition operator for the addition of two dense vectors ( ).
lhs | The left-hand side dense vector for the vector addition. |
rhs | The right-hand side dense vector for the vector addition. |
std::invalid_argument | Vector sizes do not match. |
This operator represents the addition of two dense vectors:
The operator returns an expression representing a dense vector of the higher-order element type of the two involved vector element types VT1::ElementType and VT2::ElementType. Both vector types VT1 and VT2 as well as the two element types VT1::ElementType and VT2::ElementType have to be supported by the AddTrait class template.
In case the current sizes of the two given vectors don't match, a std::invalid_argument is thrown.
|
inline |
Addition operator for the addition of a dense vector and a sparse vector ( ).
lhs | The left-hand side dense vector for the vector addition. |
rhs | The right-hand side sparse vector for the vector addition. |
std::invalid_argument | Vector sizes do not match. |
This operator represents the addition of a dense vector and a sparse vector:
The operator returns an expression representing a dense vector of the higher-order element type of the two involved vector element types VT1::ElementType and VT2::ElementType. Both vector types VT1 and VT2 as well as the two element types VT1::ElementType and VT2::ElementType have to be supported by the AddTrait class template.
In case the current sizes of the two given vectors don't match, a std::invalid_argument is thrown.
|
inline |
Addition operator for the addition of a sparse vector and a dense vector ( ).
lhs | The left-hand side sparse vector for the vector addition. |
rhs | The right-hand side dense vector for the vector addition. |
std::invalid_argument | Vector sizes do not match. |
This operator represents the addition of a sparse vector and a dense vector:
The operator returns an expression representing a dense vector of the higher-order element type of the two involved vector element types VT1::ElementType and VT2::ElementType. Both vector types VT1 and VT2 as well as the two element types VT1::ElementType and VT2::ElementType have to be supported by the AddTrait class template.
In case the current sizes of the two given vectors don't match, a std::invalid_argument is thrown.
|
inline |
Addition operator for the addition of a scalar value and a dense vector ( ).
scalar | The left-hand side scalar value for the addition. |
vec | The right-hand side dense vector for the addition. |
This operator represents the elementwise addition of a uniform vector represented by a scalar value and a dense vector:
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 AddTrait class template. Note that this operator only works for scalar values of built-in data type.
|
inline |
Addition assignment operator for the addition of a temporary dense vector and a scalar value ( ).
vec | The left-hand side temporary dense vector for the addition. |
scalar | The right-hand side scalar value for the addition. |
std::invalid_argument | Invalid addition to 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.
|
inline |
Addition assignment operator for the addition of a dense vector and a scalar value ( ).
vec | The left-hand side dense vector for the addition. |
scalar | The right-hand side scalar value for the addition. |
std::invalid_argument | Invalid addition to 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.
|
inline |
Unary minus operator for the negation of a dense vector ( ).
dv | The dense vector to be negated. |
This operator represents the negation of a dense vector:
The operator returns an expression representing the negation of the given dense vector.
|
inline |
Subtraction operator for the subtraction of a dense vector and a scalar value ( ).
vec | The left-hand side dense vector for the subtraction. |
scalar | The right-hand side scalar value for the subtraction. |
This operator represents the elementwise subtraction of a uniform vector represented by a scalar value from a dense vector:
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 SubTrait class template. Note that this operator only works for scalar values of built-in data type.
|
inline |
Subtraction operator for the subtraction of two dense vectors ( ).
lhs | The left-hand side dense vector for the vector subtraction. |
rhs | The right-hand side dense vector to be subtracted from the vector. |
std::invalid_argument | Vector sizes do not match. |
This operator represents the subtraction of two dense vectors:
The operator returns an expression representing a dense vector of the higher-order element type of the two involved vector element types VT1::ElementType and VT2::ElementType. Both vector types VT1 and VT2 as well as the two element types VT1::ElementType and VT2::ElementType have to be supported by the SubTrait class template.
In case the current sizes of the two given vectors don't match, a std::invalid_argument is thrown.
|
inline |
Subtraction operator for the subtraction of a dense vector and a sparse vector ( ).
lhs | The left-hand side dense vector for the vector subtraction. |
rhs | The right-hand side sparse vector to be subtracted from the dense vector. |
std::invalid_argument | Vector sizes do not match. |
This operator represents the subtraction of a dense vector and a sparse vector:
The operator returns an expression representing a dense vector of the higher-order element type of the two involved vector element types VT1::ElementType and VT2::ElementType. Both vector types VT1 and VT2 as well as the two element types VT1::ElementType and VT2::ElementType have to be supported by the SubTrait class template.
In case the current sizes of the two given vectors don't match, a std::invalid_argument is thrown.
|
inline |
Subtraction operator for the subtraction of a sparse vector and a dense vector ( ).
lhs | The left-hand side sparse vector for the vector subtraction. |
rhs | The right-hand side dense vector to be subtracted from the sparse vector. |
std::invalid_argument | Vector sizes do not match. |
This operator represents the subtraction of a sparse vector and a dense vector:
The operator returns an expression representing a dense vector of the higher-order element type of the two involved vector element types VT1::ElementType and VT2::ElementType. Both vector types VT1 and VT2 as well as the two element types VT1::ElementType and VT2::ElementType have to be supported by the SubTrait class template.
In case the current sizes of the two given vectors don't match, a std::invalid_argument is thrown.
|
inline |
Subtraction operator for the subtraction of a scalar value and a dense vector ( ).
scalar | The left-hand side scalar value for the subtraction. |
vec | The right-hand side dense vector for the subtraction. |
This operator represents the elementwise subtraction of a dense vector from a uniform vector represented by a scalar value:
The operator returns an expression representing a dense vector of the higher-order element type of the involved data types VT::ElementType and ST. Both data types VT::ElementType and ST have to be supported by the SubTrait class template. Note that this operator only works for scalar values of built-in data type.
|
inline |
Subtraction assignment operator for the subtraction of a temporary dense vector and a scalar value ( ).
vec | The left-hand side temporary dense vector for the subtraction. |
scalar | The right-hand side scalar value for the subtraction. |
std::invalid_argument | Invalid subtraction from 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.
|
inline |
Subtraction assignment operator for the subtraction of a dense vector and a scalar value ( ).
vec | The left-hand side dense vector for the subtraction. |
scalar | The right-hand side scalar value for the subtraction. |
std::invalid_argument | Invalid subtraction from 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.
|
inline |
Division operator for the divison of a dense vector by a scalar value ( ).
vec | The left-hand side dense vector for the division. |
scalar | The right-hand side scalar value for the division. |
This operator represents the division of a dense vector by a scalar value:
The operator returns an expression representing a dense vector of the higher-order element type of the involved data types VT::ElementType and ST. Both data types VT::ElementType and ST have to be supported by the DivTrait class template. Note that this operator only works for scalar values of built-in data type.
|
inline |
Division operator for the componentwise quotient of two dense vectors ( ).
lhs | The left-hand side dense vector for the component quotient. |
rhs | The right-hand side dense vector for the component quotient. |
std::invalid_argument | Vector sizes do not match. |
This operator represents the component quotient of two dense vectors:
The operator returns an expression representing a dense vector of the higher-order element type of the two involved vector element types VT1::ElementType and VT2::ElementType. Both vector types VT1 and VT2 as well as the two element types VT1::ElementType and VT2::ElementType have to be supported by the DivTrait class template.
In case the current sizes of the two given vectors don't match, a std::invalid_argument is thrown.
|
inline |
Division operator for the division of a scalar value and a dense vector ( ).
scalar | The left-hand side scalar value for the division. |
vec | The right-hand side dense vector for the division. |
This operator represents the elementwise division of a uniform vector represented by a scalar value and a dense vector:
The operator returns an expression representing a dense vector of the higher-order element type of the involved data types VT::ElementType and ST. Both data types VT::ElementType and ST have to be supported by the DivTrait class template. Note that this operator only works for scalar values of built-in data type.
|
inline |
Division assignment operator for the division of a temporary dense vector by a scalar value ( ).
vec | The left-hand side temporary dense vector for the division. |
scalar | The right-hand side scalar value for the division. |
std::invalid_argument | Invalid 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.
|
inline |
Division assignment operator for the division of a dense vector by a scalar value ( ).
vec | The left-hand side dense vector for the division. |
scalar | The right-hand side scalar value for the division. |
std::invalid_argument | Invalid 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.
|
inline |
Left-shift operator for the uniform left-shift of a dense vector.
vec | The dense vector for the uniform left-shift operation. |
count | The number of bits to shift all vector elements. |
This operator represents the uniform left-shift of all elements of a dense vector:
|
inline |
Left-shift operator for the elementwise left-shift of a dense vector.
lhs | The left-hand side dense vector to be shifted. |
rhs | The right-hand side dense vector of bits to shift. |
std::invalid_argument | Vector sizes do not match. |
This operator represents the elementwise left-shift of a given dense vector:
In case the current sizes of the two given vectors don't match, a std::invalid_argument is thrown.
|
inline |
Left-shift assignment operator for the uniform shift of a temporary dense vector.
vec | The temporary dense vector for the uniform left-shift operation. |
count | The number of bits to shift all vector elements. |
std::invalid_argument | Invalid left-shift 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.
|
inline |
Left-shift assignment operator for the uniform left-shift of a dense vector.
vec | The dense vector for the uniform left-shift operation. |
count | The number of bits to shift all vector elements. |
std::invalid_argument | Invalid left-shift 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.
|
inline |
Left-shift assignment operator for the elementwise left-shift of a temporary dense vector.
lhs | The left-hand side temporary dense vector to be shifted. |
rhs | The right-hand side dense vector of bits to shift. |
std::invalid_argument | Invalid left-shift 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.
|
inline |
Left-shift assignment operator for the elementwise left-shift of a dense vector.
lhs | The left-hand side dense vector to be shifted. |
rhs | The right-hand side dense vector of bits to shift. |
std::invalid_argument | Invalid left-shift 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.
|
inline |
Equality operator for the comparison of a dense vector and a scalar value.
vec | The left-hand side dense vector for the comparison. |
scalar | The right-hand side scalar value for the comparison. |
If all values of the vector are equal to the scalar value, the equality test returns true, otherwise false. Note that this function can only be used with built-in, numerical data types!
|
inline |
Equality operator for the comparison of two dense vectors.
lhs | The left-hand side dense vector for the comparison. |
rhs | The right-hand side dense vector for the comparison. |
|
inline |
Equality operator for the comparison of a dense vector and a sparse vector.
lhs | The left-hand side dense vector for the comparison. |
rhs | The right-hand side sparse vector for the comparison. |
|
inline |
Equality operator for the comparison of a sparse vector and a dense vector.
lhs | The left-hand side sparse vector for the comparison. |
rhs | The right-hand side dense vector for the comparison. |
|
inline |
Equality operator for the comparison of a scalar value and a dense vector.
scalar | The left-hand side scalar value for the comparison. |
vec | The right-hand side dense vector for the comparison. |
If all values of the vector are equal to the scalar value, the equality test returns true, otherwise false. Note that this function can only be used with built-in, numerical data types!
|
inline |
Right-shift operator for the uniform right-shift of a dense vector.
vec | The dense vector for the uniform right-shift operation. |
count | The number of bits to shift all vector elements. |
This operator represents the uniform right-shift of all elements of a dense vector:
|
inline |
Right-shift operator for the elementwise right-shift of a dense vector.
lhs | The left-hand side dense vector to be shifted. |
rhs | The right-hand side dense vector of bits to shift. |
std::invalid_argument | Vector sizes do not match. |
This operator represents the elementwise right-shift of a given dense vector:
In case the current sizes of the two given vectors don't match, a std::invalid_argument is thrown.
|
inline |
Right-shift assignment operator for the uniform shift of a temporary dense vector.
vec | The temporary dense vector for the uniform right-shift operation. |
count | The number of bits to shift all vector elements. |
std::invalid_argument | Invalid right-shift 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.
|
inline |
Right-shift assignment operator for the uniform right-shift of a dense vector.
vec | The dense vector for the uniform right-shift operation. |
count | The number of bits to shift all vector elements. |
std::invalid_argument | Invalid right-shift 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.
|
inline |
Right-shift assignment operator for the elementwise right-shift of a temporary dense.
lhs | The left-hand side temporary dense vector to be shifted. |
rhs | The right-hand side dense vector of bits to shift. |
std::invalid_argument | Invalid right-shift 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.
|
inline |
Right-shift assignment operator for the elementwise right-shift of a dense vector.
lhs | The left-hand side dense vector to be shifted. |
rhs | The right-hand side dense vector of bits to shift. |
std::invalid_argument | Invalid right-shift 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.
|
inline |
Bitwise XOR operator for the bitwise XOR of a dense vector and a scalar value.
vec | The left-hand side dense vector for the bitwise XOR. |
scalar | The right-hand side scalar value for the bitwise XOR. |
This operator represents the bitwise XOR of a scalar value with all elements of a dense vector:
|
inline |
Bitwise XOR operator for two dense vectors.
lhs | The left-hand side dense vector for the bitwise XOR operation. |
rhs | The right-hand side dense vector for the bitwise XOR operation. |
std::invalid_argument | Vector sizes do not match. |
This operator represents the bitwise XOR of the given two dense vectors:
In case the current sizes of the two given vectors don't match, a std::invalid_argument is thrown.
|
inline |
Bitwise XOR assignment operator for the bitwise XOR of a temporary dense vector and a scalar value.
vec | The left-hand side temporary dense vector for the bitwise XOR. |
scalar | The right-hand side scalar value for the bitwise XOR. |
std::invalid_argument | Invalid bitwise XOR 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.
|
inline |
Bitwise XOR assignment operator for the bitwise XOR of a dense vector and a scalar value.
vec | The left-hand side dense vector for the bitwise XOR. |
scalar | The right-hand side scalar value for the bitwise XOR. |
std::invalid_argument | Invalid bitwise XOR 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.
|
inline |
Bitwise XOR assignment operator for the bitwise XOR of a temporary dense vector.
lhs | The left-hand side temporary dense vector for the bitwise XOR operation. |
rhs | The right-hand side dense vector for the bitwise XOR operation. |
std::invalid_argument | Invalid bitwise XOR 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.
|
inline |
Bitwise XOR assignment operator for the bitwise XOR of a dense vector.
lhs | The left-hand side dense vector for the bitwise XOR operation. |
rhs | The right-hand side dense vector for the bitwise XOR operation. |
std::invalid_argument | Invalid bitwise XOR 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.
|
inline |
Bitwise OR operator for the bitwise OR of a dense vector and a scalar value.
vec | The left-hand side dense vector for the bitwise OR. |
scalar | The right-hand side scalar value for the bitwise OR. |
This operator represents the bitwise OR of a scalar value with all elements of a dense vector:
|
inline |
Bitwise OR operator for two dense vectors.
lhs | The left-hand side dense vector for the bitwise OR operation. |
rhs | The right-hand side dense vector for the bitwise OR operation. |
std::invalid_argument | Vector sizes do not match. |
This operator represents the bitwise OR of the given two dense vectors:
In case the current sizes of the two given vectors don't match, a std::invalid_argument is thrown.
|
inline |
Bitwise OR assignment operator for the bitwise OR of a temporary dense vector and a scalar value.
vec | The left-hand side temporary dense vector for the bitwise OR. |
scalar | The right-hand side scalar value for the bitwise OR. |
std::invalid_argument | Invalid bitwise OR 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.
|
inline |
Bitwise OR assignment operator for the bitwise OR of a dense vector and a scalar value.
vec | The left-hand side dense vector for the bitwise OR. |
scalar | The right-hand side scalar value for the bitwise OR. |
std::invalid_argument | Invalid bitwise OR 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.
|
inline |
Bitwise OR assignment operator for the bitwise OR of a temporary dense vector.
lhs | The left-hand side temporary dense vector for the bitwise OR operation. |
rhs | The right-hand side dense vector for the bitwise OR operation. |
std::invalid_argument | Invalid bitwise OR 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.
|
inline |
Bitwise OR assignment operator for the bitwise OR of a dense vector.
lhs | The left-hand side dense vector for the bitwise OR operation. |
rhs | The right-hand side dense vector for the bitwise OR operation. |
std::invalid_argument | Invalid bitwise OR 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.
|
inline |
Logical OR operator for two dense vectors.
lhs | The left-hand side dense vector for the logical OR operation. |
rhs | The right-hand side dense vector for the logical OR operation. |
std::invalid_argument | Vector sizes do not match. |
This operator represents the logical OR of the given two dense vectors:
In case the current sizes of the two given vectors don't match, a std::invalid_argument is thrown.
|
inline |
Computes the exponential value for each single element of the dense vector dv.
dv | The input vector. |
exp | The scalar exponent. |
The pow() function computes the exponential value for each element of the input vector dv. The function returns an expression representing this operation.
The following example demonstrates the use of the pow() function:
|
inline |
Computes the componentwise exponential value for the dense vectors lhs and rhs.
lhs | The left-hand side dense vector operand. |
rhs | The right-hand side dense vector operand. |
std::invalid_argument | Vector sizes do not match. |
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:
In case the current sizes of the two given vectors don't match, a std::invalid_argument is thrown.
|
inline |
Reduces the given dense vector by means of multiplication.
dv | The given dense vector for the reduction operation. |
This function reduces the given dense vector dv by means of multiplication:
Please note that the evaluation order of the reduction operation is unspecified.
|
inline |
Returns a vector containing the real part of each single element of dv.
dv | The input vector. |
The real() function calculates the real part of each element of the input vector dv. The function returns an expression representing this operation.
The following example demonstrates the use of the real() function:
|
inline |
Performs a custom reduction operation on the given dense vector.
dv | The given dense vector for the reduction computation. |
op | The reduction operation. |
This function reduces the given dense vector dv by means of the given reduction operation op:
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.
|
inline |
Repeats the given dense vector.
dv | The dense vector to be repeated. |
This function returns an expression representing the repeated dense vector:
|
inline |
Repeats the given dense vector.
dv | The dense vector to be repeated. |
repetitions | The number of repetitions. |
This function returns an expression representing the repeated dense vector:
|
inline |
Applies the round() function to each single element of the dense vector dv.
dv | The input vector. |
This function applies the round() function to each element of the input vector dv. The function returns an expression representing this operation.
The following example demonstrates the use of the round() function:
|
inline |
Elementwise conditional selection of values from the dense vectors lhs and rhs.
cond | The dense vector containing the selection conditions. |
lhs | The true-case dense vector. |
rhs | The false-case dense vector. |
std::invalid_argument | Vector sizes do not match. |
This function performs an elementwise conditional selection of values from the two given dense vectors lhs and rhs. In case an element in the cond vector evaluates to true, the according element of lhs is selected, in case the cond element evaluates to false, the according element of rhs is selected. The function returns an expression representing this operation.
The following example demonstrates the use of the selec() function:
In case the current sizes of the three given vectors don't match, a std::invalid_argument is thrown.
|
inline |
Forces the serial evaluation of the given dense vector expression dv.
dv | The input vector. |
The serial function forces the serial evaluation of the given dense vector expression dv. The function returns an expression representing this operation.
The following example demonstrates the use of the serial function:
|
inline |
Applies the sign() function to each single element of the dense vector dv.
dv | The input 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:
|
inline |
Computes the sine for each single element of the dense vector dv.
dv | The input vector. |
The sin() function computes the sine for each element of the input vector dv. The function returns an expression representing this operation.
The following example demonstrates the use of the sin() function:
|
inline |
Computes the hyperbolic sine for each single element of the dense vector dv.
dv | The input vector. |
The sinh() function computes the hyperbolic sine for each element of the input vector dv. The function returns an expression representing this operation.
The following example demonstrates the use of the sinh() function:
auto blaze::softmax | ( | const DenseVector< VT, TF > & | dv | ) |
Computes the softmax function for the given dense vector.
dv | The given dense vector for the softmax computation. |
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.
|
inline |
Solving the given linear system of equations (
).
A | The NxN dense system matrix. |
b | The N-dimensional dense right-hand side vector. |
std::invalid_argument | Invalid non-square system matrix provided. |
std::invalid_argument | Invalid right-hand side vector provided. |
This function returns an expression representing the solution of the given dense linear system of equations (LSE):
The solve()
function will automatically select the most suited direct solver algorithm depending on the size and type of the given system matrix. For small matrices of up to 6x6, both functions use manually optimized kernels for maximum performance. For matrices larger than 6x6 the computation is performed by means of the most suited LAPACK solver method.
In case the type of the matrix does not provide additional compile time information about its structure (symmetric, lower, upper, diagonal, ...), the information can be provided manually by means of declaration operations when calling the solve()
function:
The function fails if ...
In all failure cases an exception is thrown.
float
, double
, complex<float>
or complex<double>
element type. The attempt to call the function with matrices and vectors of any other element type results in a compile time error!solve()
function. Also, it is not possible to access individual elements via the function call operator on the expression object:
|
inline |
Calculation of the square length (magnitude) of the dense vector .
dv | The given dense vector. |
This function calculates the actual square length (magnitude) of the dense vector. The function has the same effect as calling the sqrNorm() function on the dense vector.
|
inline |
Computes the squared L2 norm for the given dense vector.
dv | The given dense vector for the norm computation. |
This function computes the squared L2 norm of the given dense vector:
|
inline |
Computes the square root of each single element of the dense vector dv.
dv | The input vector; all elements must be in the range ![]() |
The sqrt() function computes the square root of each element of the input vector dv. The function returns an expression representing this operation.
The following example demonstrates the use of the sqrt() function:
decltype(auto) blaze::stddev | ( | const DenseVector< VT, TF > & | dv | ) |
Computes the standard deviation for the given dense vector.
dv | The given dense vector for the standard deviation computation. |
std::invalid_argument | Invalid input vector. |
This function computes the standard deviation for the given dense vector dv. Example:
In case the size of the given vector is smaller than 2, a std::invalid_argument is thrown.
|
inline |
Reduces the given dense vector by means of addition.
dv | The given dense vector for the reduction operation. |
This function reduces the given dense vector dv by means of addition:
Please note that the evaluation order of the reduction operation is unspecified.
|
inline |
Calculation of the singular values of the given dense matrix.
dm | The given general matrix. |
This function returns an expression representing the singular values of the given dense matrix:
svd()
function can only be used for dense matrices with float
, double
, complex<float>
or complex<double>
element type. The attempt to call the function with matrices of any other element type results in a compile time error!svd()
function. Also, it is not possible to access individual elements via the subscript operator on the expression object:
|
inline |
Computes the tangent for each single element of the dense vector dv.
dv | The input vector. |
The tan() function computes the tangent for each element of the input vector dv. The function returns an expression representing this operation.
The following example demonstrates the use of the tan() function:
|
inline |
Computes the hyperbolic tangent for each single element of the dense vector dv.
dv | The input vector; all elements must be in the range ![]() |
The tanh() function computes the hyperbolic tangent for each element of the input vector dv. The function returns an expression representing this operation.
The following example demonstrates the use of the tanh() function:
|
inline |
Calculation of the transpose of the given dense vector.
dv | The dense vector to be transposed. |
This function returns an expression representing the transpose of the given dense vector:
|
inline |
Conditional calculation of the transpose of the given dense vector.
dv | The dense vector to be transposed. |
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.
|
inline |
Applies the trunc() function to each single element of the dense vector dv.
dv | The input vector. |
This function applies the trunc() function to each element of the input vector dv. The function returns an expression representing this operation.
The following example demonstrates the use of the trunc() function:
decltype(auto) blaze::var | ( | const DenseVector< VT, TF > & | dv | ) |
Computes the variance for the given dense vector.
dv | The given dense vector for the variance computation. |
std::invalid_argument | Invalid input vector. |
This function computes the variance for the given dense vector dv. Example:
In case the size of the given vector is smaller than 2, a std::invalid_argument is thrown.