![]() |
Modules | |
CustomMatrix | |
DynamicMatrix | |
HybridMatrix | |
InitializerMatrix | |
StaticMatrix | |
UniformMatrix | |
Expressions | |
Classes | |
struct | blaze::DenseMatrix< MT, SO > |
Base class for dense matrices.The DenseMatrix class is a base class for all dense matrix classes. It provides an abstraction from the actual type of the dense matrix, but enables a conversion back to this type via the Matrix base class. More... | |
Functions | |
template<typename MT , bool SO> | |
BLAZE_ALWAYS_INLINE MT::ElementType * | blaze::data (DenseMatrix< MT, SO > &dm) noexcept |
Low-level data access to the dense matrix elements. More... | |
template<typename MT , bool SO> | |
BLAZE_ALWAYS_INLINE MT::ElementType * | blaze::data (const DenseMatrix< MT, SO > &dm) noexcept |
Low-level data access to the dense matrix elements. More... | |
template<typename MT , bool SO> | |
BLAZE_ALWAYS_INLINE size_t | blaze::spacing (const DenseMatrix< MT, SO > &dm) noexcept |
Returns the spacing between the beginning of two rows/columns. More... | |
template<typename MT , bool SO> | |
decltype(auto) | blaze::decldiag (const DenseMatrix< MT, SO > &dm) |
Declares the given dense matrix expression dm as diagonal. More... | |
template<typename MT , bool SO> | |
decltype(auto) | blaze::declherm (const DenseMatrix< MT, SO > &dm) |
Declares the given dense matrix expression dm as Hermitian. More... | |
template<typename MT , bool SO> | |
decltype(auto) | blaze::decllow (const DenseMatrix< MT, SO > &dm) |
Declares the given dense matrix expression dm as lower. More... | |
template<typename MT , bool SO> | |
decltype(auto) | blaze::declsym (const DenseMatrix< MT, SO > &dm) |
Declares the given dense matrix expression dm as symmetric. More... | |
template<typename MT , bool SO> | |
decltype(auto) | blaze::declupp (const DenseMatrix< MT, SO > &dm) |
Declares the given dense matrix expression dm as upper. More... | |
template<typename MT1 , typename MT2 , bool SO> | |
decltype(auto) | blaze::operator+ (const DenseMatrix< MT1, SO > &lhs, const DenseMatrix< MT2, SO > &rhs) |
Addition operator for the addition of two dense matrices with identical storage order ( ![]() | |
template<typename MT1 , bool SO1, typename MT2 , bool SO2> | |
bool | blaze::operator== (const DenseMatrix< MT1, SO1 > &lhs, const DenseMatrix< MT2, SO2 > &rhs) |
Equality operator for the comparison of two dense matrices. More... | |
template<typename MT1 , bool SO1, typename MT2 , bool SO2> | |
bool | blaze::operator!= (const DenseMatrix< MT1, SO1 > &lhs, const DenseMatrix< MT2, SO2 > &rhs) |
Inequality operator for the comparison of two dense matrices. More... | |
template<typename MT1 , typename MT2 , bool SO, typename OP > | |
decltype(auto) | blaze::map (const DenseMatrix< MT1, SO > &lhs, const DenseMatrix< MT2, SO > &rhs, OP op) |
Evaluates the given binary operation on each single element of the dense matrices lhs and rhs. More... | |
template<typename MT1 , bool SO1, typename MT2 , bool SO2> | |
decltype(auto) | blaze::min (const DenseMatrix< MT1, SO1 > &lhs, const DenseMatrix< MT2, SO2 > &rhs) |
Computes the componentwise minimum of the dense matrices lhs and rhs. More... | |
template<typename MT1 , bool SO1, typename MT2 , bool SO2> | |
decltype(auto) | blaze::max (const DenseMatrix< MT1, SO1 > &lhs, const DenseMatrix< MT2, SO2 > &rhs) |
Computes the componentwise maximum of the dense matrices lhs and rhs. More... | |
template<typename MT1 , bool SO1, typename MT2 , bool SO2> | |
decltype(auto) | blaze::hypot (const DenseMatrix< MT1, SO1 > &lhs, const DenseMatrix< MT2, SO2 > &rhs) |
Computes the componentwise hypotenous for the dense matrices lhs and rhs. More... | |
template<typename MT1 , bool SO1, typename MT2 , bool SO2> | |
decltype(auto) | blaze::pow (const DenseMatrix< MT1, SO1 > &lhs, const DenseMatrix< MT2, SO2 > &rhs) |
Computes the componentwise exponential value for the dense matrices lhs and rhs. More... | |
template<typename MT1 , bool SO1, typename MT2 , bool SO2> | |
decltype(auto) | blaze::atan2 (const DenseMatrix< MT1, SO1 > &lhs, const DenseMatrix< MT2, SO2 > &rhs) |
Computes the multi-valued inverse tangent of the dense matrices lhs and rhs. More... | |
template<typename MT1 , typename MT2 > | |
decltype(auto) | blaze::operator* (const DenseMatrix< MT1, false > &lhs, const DenseMatrix< MT2, false > &rhs) |
Multiplication operator for the multiplication of two row-major dense matrices ( ![]() | |
template<typename MT1 , typename MT2 , bool SO> | |
decltype(auto) | blaze::operator% (const DenseMatrix< MT1, SO > &lhs, const DenseMatrix< MT2, SO > &rhs) |
Operator for the Schur product of two dense matrices with identical storage order ( ![]() | |
template<typename MT1 , typename MT2 , bool SO> | |
decltype(auto) | blaze::operator- (const DenseMatrix< MT1, SO > &lhs, const DenseMatrix< MT2, SO > &rhs) |
Subtraction operator for the subtraction of two dense matrices with identical storage order ( ![]() | |
template<typename MT , bool SO> | |
decltype(auto) | blaze::eval (const DenseMatrix< MT, SO > &dm) |
Forces the evaluation of the given dense matrix expression dm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | blaze::inv (const DenseMatrix< MT, SO > &dm) |
Calculation of the inverse of the given dense matrix. More... | |
template<typename MT , bool SO, typename OP > | |
decltype(auto) | blaze::map (const DenseMatrix< MT, SO > &dm, OP op) |
Evaluates the given custom operation on each single element of the dense matrix dm. More... | |
template<typename MT , bool SO, typename OP > | |
decltype(auto) | blaze::forEach (const DenseMatrix< MT, SO > &dm, OP op) |
Evaluates the given custom operation on each single element of the dense matrix dm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | blaze::abs (const DenseMatrix< MT, SO > &dm) |
Applies the abs() function to each single element of the dense matrix dm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | blaze::sign (const DenseMatrix< MT, SO > &dm) |
Applies the sign() function to each single element of the dense matrix dm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | blaze::floor (const DenseMatrix< MT, SO > &dm) |
Applies the floor() function to each single element of the dense matrix dm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | blaze::ceil (const DenseMatrix< MT, SO > &dm) |
Applies the ceil() function to each single element of the dense matrix dm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | blaze::trunc (const DenseMatrix< MT, SO > &dm) |
Applies the trunc() function to each single element of the dense matrix dm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | blaze::round (const DenseMatrix< MT, SO > &dm) |
Applies the round() function to each single element of the dense matrix dm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | blaze::conj (const DenseMatrix< MT, SO > &dm) |
Returns a matrix containing the complex conjugate of each single element of dm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | blaze::ctrans (const DenseMatrix< MT, SO > &dm) |
Returns the conjugate transpose matrix of dm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | blaze::real (const DenseMatrix< MT, SO > &dm) |
Returns a matrix containing the real part of each single element of dm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | blaze::imag (const DenseMatrix< MT, SO > &dm) |
Returns a matrix containing the imaginary part of each single element of dm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | blaze::sqrt (const DenseMatrix< MT, SO > &dm) |
Computes the square root of each single element of the dense matrix dm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | blaze::invsqrt (const DenseMatrix< MT, SO > &dm) |
Computes the inverse square root of each single element of the dense matrix dm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | blaze::cbrt (const DenseMatrix< MT, SO > &dm) |
Computes the cubic root of each single element of the dense matrix dm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | blaze::invcbrt (const DenseMatrix< MT, SO > &dm) |
Computes the inverse cubic root of each single element of the dense matrix dm. More... | |
template<typename MT , bool SO, typename DT > | |
decltype(auto) | blaze::clamp (const DenseMatrix< MT, SO > &dm, const DT &min, const DT &max) |
Restricts each single element of the dense matrix dm to the range ![]() | |
template<typename MT , bool SO, typename ST , EnableIf_t< IsNumeric_v< ST > > * = nullptr> | |
decltype(auto) | blaze::pow (const DenseMatrix< MT, SO > &dm, ST exp) |
Computes the exponential value for each single element of the dense matrix dm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | blaze::exp (const DenseMatrix< MT, SO > &dm) |
Computes ![]() | |
template<typename MT , bool SO> | |
decltype(auto) | blaze::exp2 (const DenseMatrix< MT, SO > &dm) |
Computes ![]() | |
template<typename MT , bool SO> | |
decltype(auto) | blaze::exp10 (const DenseMatrix< MT, SO > &dm) |
Computes ![]() | |
template<typename MT , bool SO> | |
decltype(auto) | blaze::log (const DenseMatrix< MT, SO > &dm) |
Computes the natural logarithm for each single element of the dense matrix dm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | blaze::log2 (const DenseMatrix< MT, SO > &dm) |
Computes the binary logarithm for each single element of the dense matrix dm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | blaze::log10 (const DenseMatrix< MT, SO > &dm) |
Computes the common logarithm for each single element of the dense matrix dm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | blaze::sin (const DenseMatrix< MT, SO > &dm) |
Computes the sine for each single element of the dense matrix dm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | blaze::asin (const DenseMatrix< MT, SO > &dm) |
Computes the inverse sine for each single element of the dense matrix dm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | blaze::sinh (const DenseMatrix< MT, SO > &dm) |
Computes the hyperbolic sine for each single element of the dense matrix dm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | blaze::asinh (const DenseMatrix< MT, SO > &dm) |
Computes the inverse hyperbolic sine for each single element of the dense matrix dm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | blaze::cos (const DenseMatrix< MT, SO > &dm) |
Computes the cosine for each single element of the dense matrix dm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | blaze::acos (const DenseMatrix< MT, SO > &dm) |
Computes the inverse cosine for each single element of the dense matrix dm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | blaze::cosh (const DenseMatrix< MT, SO > &dm) |
Computes the hyperbolic cosine for each single element of the dense matrix dm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | blaze::acosh (const DenseMatrix< MT, SO > &dm) |
Computes the inverse hyperbolic cosine for each single element of the dense matrix dm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | blaze::tan (const DenseMatrix< MT, SO > &dm) |
Computes the tangent for each single element of the dense matrix dm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | blaze::atan (const DenseMatrix< MT, SO > &dm) |
Computes the inverse tangent for each single element of the dense matrix dm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | blaze::tanh (const DenseMatrix< MT, SO > &dm) |
Computes the hyperbolic tangent for each single element of the dense matrix dm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | blaze::atanh (const DenseMatrix< MT, SO > &dm) |
Computes the inverse hyperbolic tangent for each single element of the dense matrix dm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | blaze::erf (const DenseMatrix< MT, SO > &dm) |
Computes the error function for each single element of the dense matrix dm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | blaze::erfc (const DenseMatrix< MT, SO > &dm) |
Computes the complementary error function for each single element of the dense matrix dm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | blaze::norm (const DenseMatrix< MT, SO > &dm) |
Computes the L2 norm for the given dense matrix. More... | |
template<typename MT , bool SO> | |
decltype(auto) | blaze::sqrNorm (const DenseMatrix< MT, SO > &dm) |
Computes the squared L2 norm for the given dense matrix. More... | |
template<typename MT , bool SO> | |
decltype(auto) | blaze::l1Norm (const DenseMatrix< MT, SO > &dm) |
Computes the L1 norm for the given dense matrix. More... | |
template<typename MT , bool SO> | |
decltype(auto) | blaze::l2Norm (const DenseMatrix< MT, SO > &dm) |
Computes the L2 norm for the given dense matrix. More... | |
template<typename MT , bool SO> | |
decltype(auto) | blaze::l3Norm (const DenseMatrix< MT, SO > &dm) |
Computes the L3 norm for the given dense matrix. More... | |
template<typename MT , bool SO> | |
decltype(auto) | blaze::l4Norm (const DenseMatrix< MT, SO > &dm) |
Computes the L4 norm for the given dense matrix. More... | |
template<typename MT , bool SO, typename ST > | |
decltype(auto) | blaze::lpNorm (const DenseMatrix< MT, SO > &dm, ST p) |
Computes the Lp norm for the given dense matrix. More... | |
template<size_t P, typename MT , bool SO> | |
decltype(auto) | blaze::lpNorm (const DenseMatrix< MT, SO > &dm) |
Computes the Lp norm for the given dense matrix. More... | |
template<typename MT , bool SO> | |
decltype(auto) | blaze::maxNorm (const DenseMatrix< MT, SO > &dm) |
Computes the maximum norm for the given dense matrix. More... | |
template<typename MT , bool SO, typename OP > | |
decltype(auto) | blaze::reduce (const DenseMatrix< MT, SO > &dm, OP op) |
Performs a custom reduction operation on the given dense matrix. More... | |
template<size_t RF, typename MT , bool SO, typename OP > | |
decltype(auto) | blaze::reduce (const DenseMatrix< MT, SO > &dm, OP op) |
Performs a custom reduction operation on the given dense matrix. More... | |
template<typename MT , bool SO> | |
decltype(auto) | blaze::sum (const DenseMatrix< MT, SO > &dm) |
Reduces the given dense matrix by means of addition. More... | |
template<size_t RF, typename MT , bool SO> | |
decltype(auto) | blaze::sum (const DenseMatrix< MT, SO > &dm) |
Reduces the given dense matrix by means of addition. More... | |
template<typename MT , bool SO> | |
decltype(auto) | blaze::prod (const DenseMatrix< MT, SO > &dm) |
Reduces the given dense matrix by means of multiplication. More... | |
template<size_t RF, typename MT , bool SO> | |
decltype(auto) | blaze::prod (const DenseMatrix< MT, SO > &dm) |
Reduces the given dense matrix by means of multiplication. More... | |
template<typename MT , bool SO> | |
decltype(auto) | blaze::min (const DenseMatrix< MT, SO > &dm) |
Returns the smallest element of the dense matrix. More... | |
template<size_t RF, typename MT , bool SO> | |
decltype(auto) | blaze::min (const DenseMatrix< MT, SO > &dm) |
Returns the smallest element of each row/columns of the dense matrix. More... | |
template<typename MT , bool SO> | |
decltype(auto) | blaze::max (const DenseMatrix< MT, SO > &dm) |
Returns the largest element of the dense matrix. More... | |
template<size_t RF, typename MT , bool SO> | |
decltype(auto) | blaze::max (const DenseMatrix< MT, SO > &dm) |
Returns the largest element of each row/columns of the dense matrix. More... | |
template<typename MT , bool SO, typename ST , EnableIf_t< IsNumeric_v< ST > > * = nullptr> | |
decltype(auto) | blaze::operator/ (const DenseMatrix< MT, SO > &mat, ST scalar) |
Division operator for the division of a dense matrix by a scalar value ( ![]() | |
template<typename MT , bool SO> | |
decltype(auto) | blaze::operator- (const DenseMatrix< MT, SO > &dm) |
Unary minus operator for the negation of a dense matrix ( ![]() | |
template<typename MT , bool SO, typename ST , EnableIf_t< IsNumeric_v< ST > > * = nullptr> | |
decltype(auto) | blaze::operator* (const DenseMatrix< MT, SO > &mat, ST scalar) |
Multiplication operator for the multiplication of a dense matrix and a scalar value ( ![]() | |
template<typename ST , typename MT , bool SO, EnableIf_t< IsNumeric_v< ST > > * = nullptr> | |
decltype(auto) | blaze::operator* (ST scalar, const DenseMatrix< MT, SO > &mat) |
Multiplication operator for the multiplication of a scalar value and a dense matrix ( ![]() | |
template<typename MT , bool SO> | |
decltype(auto) | blaze::serial (const DenseMatrix< MT, SO > &dm) |
Forces the serial evaluation of the given dense matrix expression dm. More... | |
template<typename MT1 , typename MT2 , bool SO> | |
decltype(auto) | blaze::operator+ (const DenseMatrix< MT1, SO > &lhs, const SparseMatrix< MT2, SO > &rhs) |
Addition operator for the addition of a dense matrix and a sparse matrix with identical storage order ( ![]() | |
template<typename MT1 , typename MT2 , bool SO> | |
decltype(auto) | blaze::operator+ (const SparseMatrix< MT1, SO > &lhs, const DenseMatrix< MT2, SO > &rhs) |
Addition operator for the addition of a sparse matrix and a dense matrix ( ![]() | |
template<typename MT1 , bool SO1, typename MT2 , bool SO2> | |
bool | blaze::operator== (const DenseMatrix< MT1, SO1 > &lhs, const SparseMatrix< MT2, SO2 > &rhs) |
Equality operator for the comparison of a dense matrix and a sparse matrix. More... | |
template<typename MT1 , bool SO1, typename MT2 , bool SO2> | |
bool | blaze::operator== (const SparseMatrix< MT1, SO1 > &lhs, const DenseMatrix< MT2, SO2 > &rhs) |
Equality operator for the comparison of a sparse matrix and a dense matrix. More... | |
template<typename MT1 , bool SO1, typename MT2 , bool SO2> | |
bool | blaze::operator!= (const DenseMatrix< MT1, SO1 > &lhs, const SparseMatrix< MT2, SO2 > &rhs) |
Inequality operator for the comparison of a dense matrix and a sparse matrix. More... | |
template<typename MT1 , bool SO1, typename MT2 , bool SO2> | |
bool | blaze::operator!= (const SparseMatrix< MT1, SO1 > &lhs, const DenseMatrix< MT2, SO2 > &rhs) |
Inequality operator for the comparison of a sparse matrix and a dense matrix. More... | |
template<typename MT1 , typename MT2 > | |
decltype(auto) | blaze::operator* (const DenseMatrix< MT1, false > &lhs, const SparseMatrix< MT2, false > &rhs) |
Multiplication operator for the multiplication of a row-major dense matrix and a row-major sparse matrix ( ![]() | |
template<typename MT1 , typename MT2 , bool SO> | |
decltype(auto) | blaze::operator- (const DenseMatrix< MT1, SO > &lhs, const SparseMatrix< MT2, SO > &rhs) |
Subtraction operator for the subtraction of a dense matrix and a sparse matrix with identical storage order ( ![]() | |
template<typename MT , bool SO> | |
auto | blaze::softmax (const DenseMatrix< MT, SO > &dm) |
Computes the softmax function for the given dense matrix. More... | |
template<bool RF, typename MT , bool SO> | |
auto | blaze::softmax (const DenseMatrix< MT, SO > &dm) |
Computes the row-/columnwise softmax function for the given dense matrix. More... | |
template<typename MT1 , typename MT2 > | |
decltype(auto) | blaze::operator+ (const DenseMatrix< MT1, false > &lhs, const DenseMatrix< MT2, true > &rhs) |
Addition operator for the addition of a row-major and a colum-major dense matrix ( ![]() | |
template<typename MT1 , typename MT2 > | |
decltype(auto) | blaze::operator+ (const DenseMatrix< MT1, true > &lhs, const DenseMatrix< MT2, false > &rhs) |
Addition operator for the addition of a column-major and a row-major dense matrix ( ![]() | |
template<typename MT1 , typename MT2 , typename OP > | |
decltype(auto) | blaze::map (const DenseMatrix< MT1, false > &lhs, const DenseMatrix< MT2, true > &rhs, OP op) |
Evaluates the given binary operation on each single element of the row-major dense matrix lhs and the column-major dense matrix rhs. More... | |
template<typename MT1 , typename MT2 , typename OP > | |
decltype(auto) | blaze::map (const DenseMatrix< MT1, true > &lhs, const DenseMatrix< MT2, false > &rhs, OP op) |
Evaluates the given binary operation on each single element of the column-major dense matrix lhs and the row-major dense matrix rhs. More... | |
template<typename MT1 , typename MT2 > | |
decltype(auto) | blaze::operator* (const DenseMatrix< MT1, false > &lhs, const DenseMatrix< MT2, true > &rhs) |
Multiplication operator for the multiplication of a row-major dense matrix and a column-major dense matrix ( ![]() | |
template<typename MT1 , typename MT2 > | |
decltype(auto) | blaze::operator% (const DenseMatrix< MT1, false > &lhs, const DenseMatrix< MT2, true > &rhs) |
Operator for the Schur product of a row-major and a column-major dense matrix ( ![]() | |
template<typename MT1 , typename MT2 > | |
decltype(auto) | blaze::operator% (const DenseMatrix< MT1, true > &lhs, const DenseMatrix< MT2, false > &rhs) |
Operator for the Schur product of a column-major and a row-major dense matrix ( ![]() | |
template<typename MT1 , typename MT2 > | |
decltype(auto) | blaze::operator- (const DenseMatrix< MT1, false > &lhs, const DenseMatrix< MT2, true > &rhs) |
Subtraction operator for the subtraction of a row-major and a column-major dense matrix ( ![]() | |
template<typename MT1 , typename MT2 > | |
decltype(auto) | blaze::operator- (const DenseMatrix< MT1, true > &lhs, const DenseMatrix< MT2, false > &rhs) |
Subtraction operator for the subtraction of a column-major and a row-major dense matrix ( ![]() | |
template<typename MT , bool SO> | |
decltype(auto) | blaze::trans (const DenseMatrix< MT, SO > &dm) |
Calculation of the transpose of the given dense matrix. More... | |
template<typename MT1 , typename MT2 > | |
decltype(auto) | blaze::operator+ (const DenseMatrix< MT1, false > &lhs, const SparseMatrix< MT2, true > &rhs) |
Addition operator for the addition of a row-major dense matrix and a column-major sparse matrix ( ![]() | |
template<typename MT1 , typename MT2 > | |
decltype(auto) | blaze::operator+ (const SparseMatrix< MT1, true > &lhs, const DenseMatrix< MT2, false > &rhs) |
Addition operator for the addition of a column-major sparse matrix and a row-major dense matrix ( ![]() | |
template<typename MT1 , typename MT2 > | |
decltype(auto) | blaze::operator* (const DenseMatrix< MT1, false > &lhs, const SparseMatrix< MT2, true > &rhs) |
Multiplication operator for the multiplication of a row-major dense matrix and a column-major sparse matrix ( ![]() | |
template<typename MT1 , typename MT2 > | |
decltype(auto) | blaze::operator- (const DenseMatrix< MT1, false > &lhs, const SparseMatrix< MT2, true > &rhs) |
Subtraction operator for the subtraction of a row-major dense matrix and a column-major sparse matrix ( ![]() | |
template<typename VT1 , typename VT2 > | |
decltype(auto) | blaze::operator* (const DenseVector< VT1, false > &lhs, const DenseVector< VT2, true > &rhs) |
Multiplication operator for the outer product of two dense vectors ( ![]() | |
template<typename MT1 , typename MT2 > | |
decltype(auto) | blaze::operator* (const SparseMatrix< MT1, false > &lhs, const DenseMatrix< MT2, false > &rhs) |
Multiplication operator for the multiplication of a row-major sparse matrix and a row-major dense matrix ( ![]() | |
template<typename MT1 , typename MT2 , bool SO> | |
decltype(auto) | blaze::operator- (const SparseMatrix< MT1, SO > &lhs, const DenseMatrix< MT2, SO > &rhs) |
Subtraction operator for the subtraction of a sparse matrix and a dense matrix with identical storage order ( ![]() | |
template<typename MT1 , typename MT2 > | |
decltype(auto) | blaze::operator* (const SparseMatrix< MT1, false > &lhs, const DenseMatrix< MT2, true > &rhs) |
Multiplication operator for the multiplication of a row-major sparse matrix and a column-major dense matrix ( ![]() | |
template<typename MT1 , typename MT2 > | |
decltype(auto) | blaze::operator- (const SparseMatrix< MT1, false > &lhs, const DenseMatrix< MT2, true > &rhs) |
Subtraction operator for the subtraction of a row-major sparse matrix and a column-major dense matrix ( ![]() | |
template<typename MT1 , typename MT2 > | |
decltype(auto) | blaze::operator* (const DenseMatrix< MT1, true > &lhs, const DenseMatrix< MT2, false > &rhs) |
Multiplication operator for the multiplication of a column-major dense matrix and a row-major dense matrix ( ![]() | |
template<typename MT1 , typename MT2 > | |
decltype(auto) | blaze::operator+ (const DenseMatrix< MT1, true > &lhs, const SparseMatrix< MT2, false > &rhs) |
Addition operator for the addition of a column-major dense matrix and a row-major sparse matrix ( ![]() | |
template<typename MT1 , typename MT2 > | |
decltype(auto) | blaze::operator+ (const SparseMatrix< MT1, false > &lhs, const DenseMatrix< MT2, true > &rhs) |
Addition operator for the addition of a row-major sparse matrix and a column-major dense matrix ( ![]() | |
template<typename MT1 , typename MT2 > | |
decltype(auto) | blaze::operator* (const DenseMatrix< MT1, true > &lhs, const SparseMatrix< MT2, false > &rhs) |
Multiplication operator for the multiplication of a column-major dense matrix and a row-major sparse matrix ( ![]() | |
template<typename MT1 , typename MT2 > | |
decltype(auto) | blaze::operator- (const DenseMatrix< MT1, true > &lhs, const SparseMatrix< MT2, false > &rhs) |
Subtraction operator for the subtraction of a column-major dense matrix and a row-major sparse matrix ( ![]() | |
template<typename MT1 , typename MT2 > | |
decltype(auto) | blaze::operator* (const DenseMatrix< MT1, true > &lhs, const DenseMatrix< MT2, true > &rhs) |
Multiplication operator for the multiplication of two column-major dense matrices ( ![]() | |
template<typename MT1 , typename MT2 > | |
decltype(auto) | blaze::operator* (const DenseMatrix< MT1, true > &lhs, const SparseMatrix< MT2, true > &rhs) |
Multiplication operator for the multiplication of a column-major dense matrix and a column-major sparse matrix ( ![]() | |
template<typename VT , typename MT > | |
decltype(auto) | blaze::operator* (const DenseVector< VT, true > &vec, const DenseMatrix< MT, true > &mat) |
Multiplication operator for the multiplication of a transpose dense vector and a column-major dense matrix ( ![]() | |
template<typename MT1 , typename MT2 > | |
decltype(auto) | blaze::operator* (const SparseMatrix< MT1, true > &lhs, const DenseMatrix< MT2, false > &rhs) |
Multiplication operator for the multiplication of a column-major sparse matrix and a row-major dense matrix ( ![]() | |
template<typename MT1 , typename MT2 > | |
decltype(auto) | blaze::operator- (const SparseMatrix< MT1, true > &lhs, const DenseMatrix< MT2, false > &rhs) |
Subtraction operator for the subtraction of a column-major sparse matrix and a row-major dense matrix ( ![]() | |
template<typename MT1 , typename MT2 > | |
decltype(auto) | blaze::operator* (const SparseMatrix< MT1, true > &lhs, const DenseMatrix< MT2, true > &rhs) |
Multiplication operator for the multiplication of a column-major sparse matrix and a column-major dense matrix ( ![]() | |
template<typename VT , typename MT > | |
decltype(auto) | blaze::operator* (const SparseVector< VT, true > &vec, const DenseMatrix< MT, false > &mat) |
Multiplication operator for the multiplication of a transpose sparse vector and a row-major dense matrix ( ![]() | |
DenseMatrix operators | |
template<typename T1 , typename T2 > | |
auto | blaze::operator== (const DenseMatrix< T1, false > &mat, T2 scalar) -> EnableIf_t< IsNumeric_v< T2 >, bool > |
Equality operator for the comparison of a row-major dense matrix and a scalar value. More... | |
template<typename T1 , typename T2 > | |
auto | blaze::operator== (const DenseMatrix< T1, true > &mat, T2 scalar) -> EnableIf_t< IsNumeric_v< T2 >, bool > |
Equality operator for the comparison of a column-major dense matrix and a scalar value. More... | |
template<typename T1 , typename T2 , bool SO> | |
auto | blaze::operator== (T1 scalar, const DenseMatrix< T2, SO > &mat) -> EnableIf_t< IsNumeric_v< T1 >, bool > |
Equality operator for the comparison of a scalar value and a dense matrix. More... | |
template<typename T1 , typename T2 , bool SO> | |
auto | blaze::operator!= (const DenseMatrix< T1, SO > &mat, T2 scalar) -> EnableIf_t< IsNumeric_v< T2 >, bool > |
Inequality operator for the comparison of a dense matrix and a scalar value. More... | |
template<typename T1 , typename T2 , bool SO> | |
auto | blaze::operator!= (T1 scalar, const DenseMatrix< T2, SO > &mat) -> EnableIf_t< IsNumeric_v< T1 >, bool > |
Inequality operator for the comparison of a scalar value and a dense matrix. More... | |
template<typename MT , bool SO, typename ST > | |
auto | blaze::operator*= (DenseMatrix< MT, SO > &mat, ST scalar) -> EnableIf_t< IsNumeric_v< ST >, MT &> |
Multiplication assignment operator for the multiplication of a dense matrix and a scalar value ( ![]() | |
template<typename MT , bool SO, typename ST > | |
auto | blaze::operator*= (DenseMatrix< MT, SO > &&mat, ST scalar) -> EnableIf_t< IsNumeric_v< ST >, MT &> |
Multiplication assignment operator for the multiplication of a temporary dense matrix and a scalar value ( ![]() | |
template<typename MT , bool SO, typename ST > | |
auto | blaze::operator/= (DenseMatrix< MT, SO > &mat, ST scalar) -> EnableIf_t< IsNumeric_v< ST >, MT &> |
Division assignment operator for the division of a dense matrix by a scalar value ( ![]() | |
template<typename MT , bool SO, typename ST > | |
auto | blaze::operator/= (DenseMatrix< MT, SO > &&mat, ST scalar) -> EnableIf_t< IsNumeric_v< ST >, MT &> |
Division assignment operator for the division of a temporary dense matrix by a scalar value ( ![]() | |
DenseMatrix functions | |
template<typename MT , bool SO> | |
bool | blaze::isnan (const DenseMatrix< MT, SO > &dm) |
Checks the given dense matrix for not-a-number elements. More... | |
template<bool RF, typename MT , bool SO> | |
bool | blaze::isSymmetric (const DenseMatrix< MT, SO > &dm) |
Checks if the given dense matrix is symmetric. More... | |
template<bool RF, typename MT , bool SO> | |
bool | blaze::isHermitian (const DenseMatrix< MT, SO > &dm) |
Checks if the given dense matrix is Hermitian. More... | |
template<bool RF, typename MT , bool SO> | |
bool | blaze::isUniform (const DenseMatrix< MT, SO > &dm) |
Checks if the given dense matrix is a uniform matrix. More... | |
template<bool RF, typename MT , bool SO> | |
bool | blaze::isZero (const DenseMatrix< MT, SO > &dm) |
Checks if the given dense matrix is a zero matrix. More... | |
template<bool RF, typename MT , bool SO> | |
bool | blaze::isLower (const DenseMatrix< MT, SO > &dm) |
Checks if the given dense matrix is a lower triangular matrix. More... | |
template<bool RF, typename MT , bool SO> | |
bool | blaze::isUniLower (const DenseMatrix< MT, SO > &dm) |
Checks if the given dense matrix is a lower unitriangular matrix. More... | |
template<bool RF, typename MT , bool SO> | |
bool | blaze::isStrictlyLower (const DenseMatrix< MT, SO > &dm) |
Checks if the given dense matrix is a strictly lower triangular matrix. More... | |
template<bool RF, typename MT , bool SO> | |
bool | blaze::isUpper (const DenseMatrix< MT, SO > &dm) |
Checks if the given dense matrix is an upper triangular matrix. More... | |
template<bool RF, typename MT , bool SO> | |
bool | blaze::isUniUpper (const DenseMatrix< MT, SO > &dm) |
Checks if the given dense matrix is an upper unitriangular matrix. More... | |
template<bool RF, typename MT , bool SO> | |
bool | blaze::isStrictlyUpper (const DenseMatrix< MT, SO > &dm) |
Checks if the given dense matrix is a strictly upper triangular matrix. More... | |
template<bool RF, typename MT , bool SO> | |
bool | blaze::isDiagonal (const DenseMatrix< MT, SO > &dm) |
Checks if the give dense matrix is diagonal. More... | |
template<bool RF, typename MT , bool SO> | |
bool | blaze::isIdentity (const DenseMatrix< MT, SO > &dm) |
Checks if the give dense matrix is an identity matrix. More... | |
Eigenvalue functions | |
template<typename MT , bool SO, typename VT , bool TF> | |
void | blaze::eigen (const DenseMatrix< MT, SO > &A, DenseVector< VT, TF > &w) |
Eigenvalue computation of the given dense matrix. More... | |
template<typename MT1 , bool SO1, typename VT , bool TF, typename MT2 , bool SO2> | |
void | blaze::eigen (const DenseMatrix< MT1, SO1 > &A, DenseVector< VT, TF > &w, DenseMatrix< MT2, SO2 > &V) |
Eigenvalue computation of the given dense matrix. More... | |
Inversion functions | |
template<typename MT , bool SO> | |
void | blaze::invert (DenseMatrix< MT, SO > &dm) |
In-place inversion of the given dense matrix. More... | |
template<InversionFlag IF, typename MT , bool SO> | |
void | blaze::invert (DenseMatrix< MT, SO > &dm) |
In-place inversion of the given dense matrix. More... | |
LLH decomposition functions | |
template<typename MT1 , bool SO1, typename MT2 , bool SO2> | |
void | blaze::llh (const DenseMatrix< MT1, SO1 > &A, DenseMatrix< MT2, SO2 > &L) |
Cholesky (LLH) decomposition of the given dense matrix. More... | |
LQ decomposition functions | |
template<typename MT1 , bool SO1, typename MT2 , bool SO2, typename MT3 , bool SO3> | |
void | blaze::lq (const DenseMatrix< MT1, SO1 > &A, DenseMatrix< MT2, SO2 > &L, DenseMatrix< MT3, SO3 > &Q) |
LQ decomposition of the given dense matrix. More... | |
LU decomposition functions | |
template<typename MT1 , bool SO1, typename MT2 , typename MT3 , typename MT4 , bool SO2> | |
void | blaze::lu (const DenseMatrix< MT1, SO1 > &A, DenseMatrix< MT2, SO1 > &L, DenseMatrix< MT3, SO1 > &U, Matrix< MT4, SO2 > &P) |
LU decomposition of the given dense matrix. More... | |
QL decomposition functions | |
template<typename MT1 , bool SO1, typename MT2 , bool SO2, typename MT3 , bool SO3> | |
void | blaze::ql (const DenseMatrix< MT1, SO1 > &A, DenseMatrix< MT2, SO2 > &Q, DenseMatrix< MT3, SO3 > &L) |
QL decomposition of the given dense matrix. More... | |
QR decomposition functions | |
template<typename MT1 , bool SO1, typename MT2 , bool SO2, typename MT3 , bool SO3> | |
void | blaze::qr (const DenseMatrix< MT1, SO1 > &A, DenseMatrix< MT2, SO2 > &Q, DenseMatrix< MT3, SO3 > &R) |
QR decomposition of the given dense matrix. More... | |
RQ decomposition functions | |
template<typename MT1 , bool SO1, typename MT2 , bool SO2, typename MT3 , bool SO3> | |
void | blaze::rq (const DenseMatrix< MT1, SO1 > &A, DenseMatrix< MT2, SO2 > &R, DenseMatrix< MT3, SO3 > &Q) |
RQ decomposition of the given dense matrix. More... | |
Singular value decomposition functions | |
template<typename MT , bool SO, typename VT , bool TF> | |
void | blaze::svd (const DenseMatrix< MT, SO > &A, DenseVector< VT, TF > &s) |
Singular value decomposition (SVD) of the given dense general matrix. More... | |
template<typename MT1 , bool SO, typename VT , bool TF, typename MT2 , typename MT3 > | |
void | blaze::svd (const DenseMatrix< MT1, SO > &A, DenseMatrix< MT2, SO > &U, DenseVector< VT, TF > &s, DenseMatrix< MT3, SO > &V) |
Singular value decomposition (SVD) of the given dense general matrix. More... | |
template<typename MT , bool SO, typename VT , bool TF, typename ST > | |
size_t | blaze::svd (const DenseMatrix< MT, SO > &A, DenseVector< VT, TF > &s, ST low, ST upp) |
Singular value decomposition (SVD) of the given dense general matrix. More... | |
template<typename MT1 , bool SO, typename VT , bool TF, typename MT2 , typename MT3 , typename ST > | |
size_t | blaze::svd (const DenseMatrix< MT1, SO > &A, DenseMatrix< MT2, SO > &U, DenseVector< VT, TF > &s, DenseMatrix< MT3, SO > &V, ST low, ST upp) |
Singular value decomposition (SVD) of the given dense general matrix. More... | |
Determinant functions | |
template<typename MT , bool SO> | |
ElementType_t< MT > | blaze::det (const DenseMatrix< MT, SO > &dm) |
Computation of the determinant of the given dense square matrix. More... | |
|
inline |
Applies the abs() function to each single element of the dense matrix dm.
dm | The input matrix. |
This function applies the abs() function to each element of the input matrix dm. 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 matrix dm.
dm | The input matrix; all elements must be in the range ![]() |
The acos() function computes the inverse cosine for each element of the input matrix dm. 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 matrix dm.
dm | The input matrix; all elements must be in the range ![]() |
The acosh() function computes the inverse hyperbolic cosine for each element of the input matrix dm. The function returns an expression representing this operation.
The following example demonstrates the use of the acosh() function:
|
inline |
Computes the inverse sine for each single element of the dense matrix dm.
dm | The input matrix; all elements must be in the range ![]() |
The asin() function computes the inverse sine for each element of the input matrix dm. 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 matrix dm.
dm | The input matrix. |
The asinh() function computes the inverse hyperbolic sine for each element of the input matrix dm. 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 matrix dm.
dm | The input matrix. |
The atan() function computes the inverse tangent for each element of the input matrix dm. 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 matrices lhs and rhs.
lhs | The left-hand side dense matrix operand. |
rhs | The right-hand side dense matrix operand. |
This function computes the multi-valued inverse tangent of the two dense matrix lhs and rhs. The function returns an expression representing this operation.
The following example demonstrates the use of the max() function:
|
inline |
Computes the inverse hyperbolic tangent for each single element of the dense matrix dm.
dm | The input matrix; all elements must be in the range ![]() |
The atanh() function computes the inverse hyperbolic tangent for each element of the input matrix dm. 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 matrix dm.
dm | The input matrix; all elements must be in the range ![]() |
The cbrt() function computes the cubic root of each element of the input matrix dm. 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 matrix dm.
dm | The input matrix. |
This function applies the ceil() function to each element of the input matrix dm. 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 matrix dm to the range .
dm | The input matrix. |
min | The lower delimiter. |
max | The upper delimiter. |
The clamp() function restricts each element of the input matrix dm to the range . The function returns an expression representing this operation.
The following example demonstrates the use of the clamp() function:
|
inline |
Returns a matrix containing the complex conjugate of each single element of dm.
dm | The input matrix. |
The conj function calculates the complex conjugate of each element of the input matrix dm. 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 matrix dm.
dm | The input matrix. |
The cos() function computes the cosine for each element of the input matrix dm. 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 matrix dm.
dm | The input matrix. |
The cosh() function computes the hyperbolic cosine for each element of the input matrix dm. The function returns an expression representing this operation.
The following example demonstrates the use of the cosh() function:
|
inline |
Returns the conjugate transpose matrix of dm.
dm | The input matrix. |
The ctrans function returns an expression representing the conjugate transpose (also called adjoint matrix, Hermitian conjugate matrix or transjugate matrix) of the given input matrix dm.
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 matrix elements.
dm | The given dense matrix. |
This function provides a unified interface to access the given dense matrix's internal element storage. In contrast to the data()
member function, which is only available in case the matrix has some internal storage, this function can be used on all kinds of dense matrices. In case the given dense matrix does not provide low-level data access, the function returns nullptr
.
|
noexcept |
Low-level data access to the dense matrix elements.
dm | The given dense matrix. |
This function provides a unified interface to access the given dense matrix's internal element storage. In contrast to the data()
member function, which is only available in case the matrix has some internal storage, this function can be used on all kinds of dense matrices. In case the given dense matrix does not provide low-level data access, the function returns nullptr
.
|
inline |
Declares the given dense matrix expression dm as diagonal.
dm | The input matrix. |
std::invalid_argument | Invalid diagonal matrix specification. |
The decldiag function declares the given dense matrix expression dm as diagonal. In case the given matrix is not a square matrix, a std::invalid_argument exception is thrown.
The following example demonstrates the use of the decldiag function:
|
inline |
Declares the given dense matrix expression dm as Hermitian.
dm | The input matrix. |
std::invalid_argument | Invalid Hermitian matrix specification. |
The declherm function declares the given dense matrix expression dm as Hermitian. In case the given matrix is not a square matrix, a std::invalid_argument exception is thrown.
The following example demonstrates the use of the declherm function:
|
inline |
Declares the given dense matrix expression dm as lower.
dm | The input matrix. |
std::invalid_argument | Invalid lower matrix specification. |
The decllow function declares the given dense matrix expression dm as lower. In case the given matrix is not a square matrix, a std::invalid_argument exception is thrown.
The following example demonstrates the use of the decllow function:
|
inline |
Declares the given dense matrix expression dm as symmetric.
dm | The input matrix. |
std::invalid_argument | Invalid symmetric matrix specification. |
The declsym function declares the given dense matrix expression dm as symmetric. In case the given matrix is not a square matrix, a std::invalid_argument exception is thrown.
The following example demonstrates the use of the declsym function:
|
inline |
Declares the given dense matrix expression dm as upper.
dm | The input matrix. |
std::invalid_argument | Invalid upper matrix specification. |
The declupp function declares the given dense matrix expression dm as upper. In case the given matrix is not a square matrix, a std::invalid_argument exception is thrown.
The following example demonstrates the use of the declupp function:
|
inline |
Computation of the determinant of the given dense square matrix.
dm | The given dense matrix. |
std::invalid_argument | Invalid non-square matrix provided. |
This function computes the determinant of the given dense square matrix. The computation fails if the given matrix is not a square matrix. In this case either a compilation error is created (if possible) or a std::invalid_argument exception is thrown.
|
inline |
Eigenvalue computation of the given dense matrix.
A | The given general matrix. |
w | The resulting vector of eigenvalues. |
std::invalid_argument | Invalid non-square matrix provided. |
std::invalid_argument | Vector cannot be resized. |
std::runtime_error | Eigenvalue computation failed. |
This function computes the eigenvalues of the given n-by-n matrix. The eigenvalues are returned in the given vector w, which is resized to the correct size (if possible and necessary).
Please note that in case the given matrix is either a compile time symmetric matrix with floating point elements or an Hermitian matrix with complex elements, the resulting eigenvalues will be of floating point type and therefore the elements of the given eigenvalue vector are expected to be of floating point type. In all other cases they are expected to be of complex type. Also please note that for complex eigenvalues no order of eigenvalues can be assumed, except that complex conjugate pairs of eigenvalues appear consecutively with the eigenvalue having the positive imaginary part first.
The function fails if ...
In all failure cases an exception is thrown.
Examples:
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!
|
inline |
Eigenvalue computation of the given dense matrix.
A | The given general matrix. |
w | The resulting vector of eigenvalues. |
V | The resulting matrix of eigenvectors. |
std::invalid_argument | Invalid non-square matrix provided. |
std::invalid_argument | Vector cannot be resized. |
std::invalid_argument | Matrix cannot be resized. |
std::runtime_error | Eigenvalue computation failed. |
This function computes the eigenvalues and eigenvectors of the given n-by-n matrix. The eigenvalues are returned in the given vector w and the eigenvectors are returned in the given matrix V, which are both resized to the correct dimensions (if possible and necessary).
Please note that in case the given matrix is either a compile time symmetric matrix with floating point elements or an Hermitian matrix with complex elements, the resulting eigenvalues will be of floating point type and therefore the elements of the given eigenvalue vector are expected to be of floating point type. In all other cases they are expected to be of complex type. Also please note that for complex eigenvalues no order of eigenvalues can be assumed, except that complex conjugate pairs of eigenvalues appear consecutively with the eigenvalue having the positive imaginary part first.
In case A is a row-major matrix, the left eigenvectors are returned in the rows of V, in case A is a column-major matrix, the right eigenvectors are returned in the columns of V. In case the given matrix is a compile time symmetric matrix with floating point elements, the resulting eigenvectors will be of floating point type and therefore the elements of the given eigenvector matrix are expected to be of floating point type. In all other cases they are expected to be of complex type.
The function fails if ...
In all failure cases an exception is thrown.
Examples:
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!
|
inline |
Computes the error function for each single element of the dense matrix dm.
dm | The input matrix. |
The erf() function computes the error function for each element of the input matrix dm. 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 matrix dm.
dm | The input matrix. |
The erfc() function computes the complementary error function for each element of the input matrix dm. 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 matrix expression dm.
dm | The input matrix. |
The eval function forces the evaluation of the given dense matrix expression dm. The function returns an expression representing the operation.
The following example demonstrates the use of the eval function:
|
inline |
Computes for each single element of the dense matrix dm.
dm | The input matrix. |
The exp() function computes for each element of the input matrix dm. 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 matrix dm.
dm | The input matrix. |
The exp10() function computes for each element of the input matrix dm. 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 matrix dm.
dm | The input matrix. |
The exp2() function computes for each element of the input matrix dm. The function returns an expression representing this operation.
The following example demonstrates the use of the exp2() function:
|
inline |
Applies the floor() function to each single element of the dense matrix dm.
dm | The input matrix. |
This function applies the floor() function to each element of the input matrix dm. 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 matrix dm.
dm | The input matrix. |
op | The custom operation. |
The forEach() function evaluates the given custom operation on each element of the input matrix dm. The function returns an expression representing this operation.
The following example demonstrates the use of the forEach() function:
|
inline |
Computes the componentwise hypotenous for the dense matrices lhs and rhs.
lhs | The left-hand side dense matrix operand. |
rhs | The right-hand side dense matrix operand. |
The hypot() function computes the componentwise hypotenous for the two dense matrices lhs and rhs. The function returns an expression representing this operation.
The following example demonstrates the use of the hypot() function:
|
inline |
Returns a matrix containing the imaginary part of each single element of dm.
dm | The input matrix. |
The imag function calculates the imaginary part of each element of the input matrix dm. The function returns an expression representing this operation.
The following example demonstrates the use of the imag function:
|
inline |
Calculation of the inverse of the given dense matrix.
dm | The dense matrix to be inverted. |
This function returns an expression representing the inverse of the given dense matrix:
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!inv()
function. Also, it is not possible to access individual elements via the function call operator on the expression object:
|
inline |
Computes the inverse cubic root of each single element of the dense matrix dm.
dm | The input matrix; all elements must be in the range ![]() |
The invcbrt() function computes the inverse cubic root of each element of the input matrix dm. The function returns an expression representing this operation.
The following example demonstrates the use of the invcbrt() function:
|
inline |
In-place inversion of the given dense matrix.
dm | The dense matrix to be inverted. |
std::invalid_argument | Invalid non-square matrix provided. |
std::runtime_error | Inversion of singular matrix failed. |
This function inverts the given dense square matrix. The matrix inversion 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 of any other element type results in a compile time error!
|
inline |
In-place inversion of the given dense matrix.
dm | The dense matrix to be inverted. |
std::invalid_argument | Invalid non-square matrix provided. |
std::runtime_error | Inversion of singular matrix failed. |
This function inverts the given dense matrix by means of the specified matrix type or matrix inversion algorithm IF
(see the InversionFlag documentation):
The matrix inversion fails if ...
In all failure cases either a compilation error is created if the failure can be predicted at compile time or an exception is thrown.
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!
|
inline |
Computes the inverse square root of each single element of the dense matrix dm.
dm | The input matrix; all elements must be in the range ![]() |
The invsqrt() function computes the inverse square root of each element of the input matrix dm. The function returns an expression representing this operation.
The following example demonstrates the use of the invsqrt() function:
bool blaze::isDiagonal | ( | const DenseMatrix< MT, SO > & | dm | ) |
Checks if the give dense matrix is diagonal.
dm | The dense matrix to be checked. |
This function tests whether the matrix is diagonal, i.e. if the non-diagonal elements are default elements. In case of integral or floating point data types, a diagonal matrix has the form
or
matrices are considered as trivially diagonal. The following 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 matrix expression results is a diagonal matrix:
However, note that this might require the complete evaluation of the expression, including the generation of a temporary matrix.
bool blaze::isHermitian | ( | const DenseMatrix< MT, SO > & | dm | ) |
Checks if the given dense matrix is Hermitian.
dm | The dense matrix to be checked. |
This function checks if the given dense matrix is an Hermitian matrix. The matrix is considered to be an Hermitian matrix if it is a square matrix whose conjugate transpose is equal to itself ( ), i.e. each matrix element
is equal to the complex conjugate of the element
. 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 matrix expression results in an Hermitian matrix:
However, note that this might require the complete evaluation of the expression, including the generation of a temporary matrix.
bool blaze::isIdentity | ( | const DenseMatrix< MT, SO > & | dm | ) |
Checks if the give dense matrix is an identity matrix.
dm | The dense matrix to be checked. |
This function tests whether the matrix is an identity matrix, i.e. if the diagonal elements are 1 and the non-diagonal elements are 0. In case of integral or floating point data types, an identity matrix has the form
The following 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 matrix expression results in an identity matrix:
However, note that this might require the complete evaluation of the expression, including the generation of a temporary matrix.
bool blaze::isLower | ( | const DenseMatrix< MT, SO > & | dm | ) |
Checks if the given dense matrix is a lower triangular matrix.
dm | The dense matrix to be checked. |
This function checks if the given dense matrix is a lower triangular matrix. The matrix is considered to be lower triangular if it is a square matrix of the form
or
matrices are considered as trivially lower triangular. 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 matrix expression results is a lower triangular matrix:
However, note that this might require the complete evaluation of the expression, including the generation of a temporary matrix.
bool blaze::isnan | ( | const DenseMatrix< MT, SO > & | dm | ) |
Checks the given dense matrix for not-a-number elements.
dm | The matrix to be checked for not-a-number elements. |
This function checks the dense matrix for not-a-number (NaN) elements. If at least one element of the matrix is not-a-number, the function returns true, otherwise it returns false.
Note that this function only works for matrices with floating point elements. The attempt to use it for a matrix with a non-floating point element type results in a compile time error.
bool blaze::isStrictlyLower | ( | const DenseMatrix< MT, SO > & | dm | ) |
Checks if the given dense matrix is a strictly lower triangular matrix.
dm | The dense matrix to be checked. |
This function checks if the given dense matrix is a strictly lower triangular matrix. The matrix is considered to be strictly lower triangular if it is a square matrix of the form
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 matrix expression results is a strictly lower triangular matrix:
However, note that this might require the complete evaluation of the expression, including the generation of a temporary matrix.
bool blaze::isStrictlyUpper | ( | const DenseMatrix< MT, SO > & | dm | ) |
Checks if the given dense matrix is a strictly upper triangular matrix.
dm | The dense matrix to be checked. |
This function checks if the given dense matrix is a strictly upper triangular matrix. The matrix is considered to be strictly upper triangular if it is a square matrix of the form
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 matrix expression results is a strictly upper triangular matrix:
However, note that this might require the complete evaluation of the expression, including the generation of a temporary matrix.
bool blaze::isSymmetric | ( | const DenseMatrix< MT, SO > & | dm | ) |
Checks if the given dense matrix is symmetric.
dm | The dense matrix to be checked. |
This function checks if the given dense matrix is symmetric. The matrix is considered to be symmetric if it is a square matrix whose transpose is equal to itself ( ). 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 matrix expression results is a symmetric matrix:
However, note that this might require the complete evaluation of the expression, including the generation of a temporary matrix.
bool blaze::isUniform | ( | const DenseMatrix< MT, SO > & | dm | ) |
Checks if the given dense matrix is a uniform matrix.
dm | The dense matrix to be checked. |
This function checks if the given dense matrix is a uniform matrix. The matrix 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 matrix expression results is a uniform matrix:
However, note that this might require the complete evaluation of the expression, including the generation of a temporary matrix.
bool blaze::isUniLower | ( | const DenseMatrix< MT, SO > & | dm | ) |
Checks if the given dense matrix is a lower unitriangular matrix.
dm | The dense matrix to be checked. |
This function checks if the given dense matrix is a lower unitriangular matrix. The matrix is considered to be lower unitriangular if it is a square matrix of the form
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 matrix expression results is a lower unitriangular matrix:
However, note that this might require the complete evaluation of the expression, including the generation of a temporary matrix.
bool blaze::isUniUpper | ( | const DenseMatrix< MT, SO > & | dm | ) |
Checks if the given dense matrix is an upper unitriangular matrix.
dm | The dense matrix to be checked. |
This function checks if the given dense matrix is an upper unitriangular matrix. The matrix is considered to be upper unitriangular if it is a square matrix of the form
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 matrix expression results in an upper unitriangular matrix:
However, note that this might require the complete evaluation of the expression, including the generation of a temporary matrix.
bool blaze::isUpper | ( | const DenseMatrix< MT, SO > & | dm | ) |
Checks if the given dense matrix is an upper triangular matrix.
dm | The dense matrix to be checked. |
This function checks if the given dense matrix is an upper triangular matrix. The matrix is considered to be upper triangular if it is a square matrix of the form
or
matrices are considered as trivially upper triangular. 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 matrix expression results in an upper triangular matrix:
However, note that this might require the complete evaluation of the expression, including the generation of a temporary matrix.
bool blaze::isZero | ( | const DenseMatrix< MT, SO > & | dm | ) |
Checks if the given dense matrix is a zero matrix.
dm | The dense matrix to be checked. |
This function checks if the given dense matrix is a zero matrix. The matrix 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 matrix expression results is a zero matrix:
However, note that this might require the complete evaluation of the expression, including the generation of a temporary matrix.
decltype(auto) blaze::l1Norm | ( | const DenseMatrix< MT, SO > & | dm | ) |
Computes the L1 norm for the given dense matrix.
dm | The given dense matrix for the norm computation. |
This function computes the L1 norm of the given dense matrix:
decltype(auto) blaze::l2Norm | ( | const DenseMatrix< MT, SO > & | dm | ) |
Computes the L2 norm for the given dense matrix.
dm | The given dense matrix for the norm computation. |
This function computes the L2 norm of the given dense matrix:
decltype(auto) blaze::l3Norm | ( | const DenseMatrix< MT, SO > & | dm | ) |
Computes the L3 norm for the given dense matrix.
dm | The given dense matrix for the norm computation. |
This function computes the L3 norm of the given dense matrix:
decltype(auto) blaze::l4Norm | ( | const DenseMatrix< MT, SO > & | dm | ) |
Computes the L4 norm for the given dense matrix.
dm | The given dense matrix for the norm computation. |
This function computes the L4 norm of the given dense matrix:
void blaze::llh | ( | const DenseMatrix< MT1, SO1 > & | A, |
DenseMatrix< MT2, SO2 > & | L | ||
) |
Cholesky (LLH) decomposition of the given dense matrix.
A | The matrix to be decomposed. |
L | The resulting lower triangular matrix. |
std::invalid_argument | Invalid non-square matrix provided. |
std::invalid_argument | Dimensions of fixed size matrix do not match. |
std::invalid_argument | Decomposition of singular matrix failed. |
This function performs the dense matrix Cholesky (LLH) decomposition of a positive definite n-by-n matrix. The resulting decomposition has the form
where L
is a lower triangular n-by-n matrix. The decomposition is written to the matrix L
, which is resized to the correct dimensions (if possible and necessary).
The function fails if ...
In all failure cases a std::invalid_argument exception is thrown.
Example:
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!
|
inline |
Computes the natural logarithm for each single element of the dense matrix dm.
dm | The input matrix; all elements must be in the range ![]() |
The log() function computes natural logarithm for each element of the input matrix dm. 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 matrix dm.
dm | The input matrix; all elements must be in the range ![]() |
The log10() function computes common logarithm for each element of the input matrix dm. The function returns an expression representing this operation.
The following example demonstrates the use of the log10() function:
|
inline |
Computes the binary logarithm for each single element of the dense matrix dm.
dm | The input matrix; all elements must be in the range ![]() |
The log2() function computes binary logarithm for each element of the input matrix dm. The function returns an expression representing this operation.
The following example demonstrates the use of the log2() function:
decltype(auto) blaze::lpNorm | ( | const DenseMatrix< MT, SO > & | dm, |
ST | p | ||
) |
Computes the Lp norm for the given dense matrix.
dm | The given dense matrix for the norm computation. |
p | The norm parameter (p > 0). |
This function computes the Lp norm of the given dense matrix, where the norm is specified by the runtime argument p:
|
inline |
Computes the Lp norm for the given dense matrix.
dm | The given dense matrix for the norm computation. |
This function computes the Lp norm of the given dense matrix, where the norm is specified by the runtime argument P:
void blaze::lq | ( | const DenseMatrix< MT1, SO1 > & | A, |
DenseMatrix< MT2, SO2 > & | L, | ||
DenseMatrix< MT3, SO3 > & | Q | ||
) |
LQ decomposition of the given dense matrix.
A | The matrix to be decomposed. |
L | The resulting L matrix. |
Q | The resulting Q matrix. |
std::invalid_argument | Dimensions of fixed size matrix do not match. |
std::invalid_argument | Square matrix cannot be resized to m-by-n. |
This function performs the dense matrix LQ decomposition of a general m-by-n matrix. The resulting decomposition has the form
where L
is a lower trapezoidal m-by-min(m,n) matrix and Q
is a general min(m,n)-by-n matrix. The decomposition is written to the two distinct matrices L
and Q
, which are resized to the correct dimensions (if possible and necessary).
The function fails if ...
In all failure cases a std::invalid_argument exception is thrown.
Example:
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!void blaze::lu | ( | const DenseMatrix< MT1, SO1 > & | A, |
DenseMatrix< MT2, SO1 > & | L, | ||
DenseMatrix< MT3, SO1 > & | U, | ||
Matrix< MT4, SO2 > & | P | ||
) |
LU decomposition of the given dense matrix.
A | The matrix to be decomposed. |
L | The resulting lower triangular matrix. |
U | The resulting upper triangular matrix. |
P | The resulting permutation matrix. |
std::invalid_argument | Dimensions of fixed size matrix do not match. |
std::invalid_argument | Square matrix cannot be resized to m-by-n. |
This function performs the dense matrix (P)LU decomposition of a general m-by-n matrix. The resulting decomposition is written to the three distinct matrices L
, U
, and P
, which are resized to the correct dimensions (if possible and necessary).
In case of a column-major matrix the algorithm performs the decomposition using partial pivoting with row interchanges. The resulting decomposition has the form
where P
is an m-by-m permutation matrix, which represents the pivoting indices for the applied row interchanges, L
is a lower triangular matrix (lower trapezoidal if m > n), and U
is an upper triangular matrix (upper trapezoidal if m < n).
In case of a row-major matrix the algorithm performs the decomposition using partial pivoting with column interchanges. The resulting decomposition has the form
where L
is a lower triangular matrix (lower trapezoidal if m > n), U
is an upper triangular matrix (upper trapezoidal if m < n), and P
is an n-by-n permutation matrix, which represents the pivoting indices for the applied column interchanges.
The function fails if ...
In all failure cases a std::invalid_argument exception is thrown.
Examples:
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!
|
inline |
Evaluates the given binary operation on each single element of the row-major dense matrix lhs and the column-major dense matrix rhs.
lhs | The left-hand side dense matrix operand. |
rhs | The right-hand side dense matrix operand. |
op | The custom, binary operation. |
std::invalid_argument | Matrix sizes do not match. |
The map() function evaluates the given binary operation on each element of the input matrices lhs and rhs. The function returns an expression representing this operation.
The following example demonstrates the use of the map() function:
|
inline |
Evaluates the given custom operation on each single element of the dense matrix dm.
dm | The input matrix. |
op | The custom operation. |
The map() function evaluates the given custom operation on each element of the input matrix dm. The function returns an expression representing this operation.
The following example demonstrates the use of the map() function:
|
inline |
Evaluates the given binary operation on each single element of the dense matrices lhs and rhs.
lhs | The left-hand side dense matrix operand. |
rhs | The right-hand side dense matrix operand. |
op | The custom, binary operation. |
std::invalid_argument | Matrix sizes do not match. |
The map() function evaluates the given binary operation on each element of the input matrices lhs and rhs. The function returns an expression representing this operation.
The following example demonstrates the use of the map() function:
|
inline |
Evaluates the given binary operation on each single element of the column-major dense matrix lhs and the row-major dense matrix rhs.
lhs | The left-hand side dense matrix operand. |
rhs | The right-hand side dense matrix operand. |
op | The custom, binary operation. |
std::invalid_argument | Matrix sizes do not match. |
The map() function evaluates the given binary operation on each element of the input matrices lhs and rhs. The function returns an expression representing this operation.
The following example demonstrates the use of the map() function:
|
inline |
Computes the componentwise maximum of the dense matrices lhs and rhs.
lhs | The left-hand side dense matrix operand. |
rhs | The right-hand side dense matrix operand. |
This function computes the componentwise maximum of the two dense matrices lhs and rhs. The function returns an expression representing this operation.
The following example demonstrates the use of the max() function:
|
inline |
Returns the largest element of the dense matrix.
dm | The given dense matrix. |
This function returns the largest element of the given dense matrix. This function can only be used for element types that support the smaller-than relationship. In case the given martix currently has either 0 rows or 0 columns, the returned value is the default value (e.g. 0 in case of fundamental data types).
|
inline |
Returns the largest element of each row/columns of the dense matrix.
dm | The given dense matrix. |
This function returns the largest element of each row/column of the given dense matrix dm. In case the reduction flag RF is set to blaze::columnwise, a row vector containing the largest element of each column is returned. In case RF is set to blaze::rowwise, a column vector containing the largest element of each row is returned.
decltype(auto) blaze::maxNorm | ( | const DenseMatrix< MT, SO > & | dm | ) |
Computes the maximum norm for the given dense matrix.
dm | The given dense matrix for the norm computation. |
This function computes the maximum norm of the given dense matrix:
|
inline |
Computes the componentwise minimum of the dense matrices lhs and rhs.
lhs | The left-hand side dense matrix operand. |
rhs | The right-hand side dense matrix operand. |
This function computes the componentwise minimum of the two dense matrices lhs and rhs. The function returns an expression representing this operation.
The following example demonstrates the use of the min() function:
|
inline |
Returns the smallest element of the dense matrix.
dm | The given dense matrix. |
This function returns the smallest element of the given dense matrix. This function can only be used for element types that support the smaller-than relationship. In case the given matrix currently has either 0 rows or 0 columns, the returned value is the default value (e.g. 0 in case of fundamental data types).
|
inline |
Returns the smallest element of each row/columns of the dense matrix.
dm | The given dense matrix. |
This function returns the smallest element of each row/column of the given dense matrix dm. In case the reduction flag RF is set to blaze::columnwise, a row vector containing the smallest element of each column is returned. In case RF is set to blaze::rowwise, a column vector containing the smallest element of each row is returned.
decltype(auto) blaze::norm | ( | const DenseMatrix< MT, SO > & | dm | ) |
Computes the L2 norm for the given dense matrix.
dm | The given dense matrix for the norm computation. |
This function computes the L2 norm of the given dense matrix:
|
inline |
Inequality operator for the comparison of a dense matrix and a scalar value.
mat | The left-hand side dense matrix for the comparison. |
scalar | The right-hand side scalar value for the comparison. |
If one value of the matrix is inequal to the scalar value, the inequality test returns true, otherwise false. Note that this function can only be used with built-in, numerical data types!
|
inline |
Inequality operator for the comparison of a scalar value and a dense matrix.
scalar | The left-hand side scalar value for the comparison. |
mat | The right-hand side dense matrix for the comparison. |
If one value of the matrix is inequal to the scalar value, the inequality test returns true, otherwise false. Note that this function can only be used with built-in, numerical data types!
|
inline |
Inequality operator for the comparison of a dense matrix and a sparse matrix.
lhs | The left-hand side dense matrix for the comparison. |
rhs | The right-hand side sparse matrix for the comparison. |
|
inline |
Inequality operator for the comparison of a sparse matrix and a dense matrix.
lhs | The left-hand side sparse matrix for the comparison. |
rhs | The right-hand side dense matrix for the comparison. |
|
inline |
Inequality operator for the comparison of two dense matrices.
lhs | The left-hand side dense matrix for the comparison. |
rhs | The right-hand side dense matrix for the comparison. |
|
inline |
Operator for the Schur product of a row-major and a column-major dense matrix ( ).
lhs | The left-hand side dense matrix for the Schur product. |
rhs | The right-hand side dense matrix for the Schur product. |
std::invalid_argument | Matrix sizes do not match. |
This operator represents the Schur product of a row-major and a column-major dense matrix:
The operator returns an expression representing a dense matrix of the higher-order element type of the two involved matrix element types MT1::ElementType and MT2::ElementType. Both matrix types MT1 and MT2 as well as the two element types MT1::ElementType and MT2::ElementType have to be supported by the MultTrait class template.
In case the current number of rows and columns of the two given matrices don't match, a std::invalid_argument is thrown.
|
inline |
Operator for the Schur product of two dense matrices with identical storage order ( ).
lhs | The left-hand side dense matrix for the Schur product. |
rhs | The right-hand side dense matrix for the Schur product. |
std::invalid_argument | Matrix sizes do not match. |
This operator represents the Schur product of two dense matrices with identical storage order:
The operator returns an expression representing a dense matrix of the higher-order element type of the two involved matrix element types MT1::ElementType and MT2::ElementType. Both matrix types MT1 and MT2 as well as the two element types MT1::ElementType and MT2::ElementType have to be supported by the MultTrait class template.
In case the current number of rows and columns of the two given matrices don't match, a std::invalid_argument is thrown.
|
inline |
Operator for the Schur product of a column-major and a row-major dense matrix ( ).
lhs | The left-hand side dense matrix for the Schur product. |
rhs | The right-hand side dense matrix for the Schur product. |
std::invalid_argument | Matrix sizes do not match |
This operator represents the Schur product of a column-major and a row-major dense matrix:
The operator returns an expression representing a dense matrix of the higher-order element type of the two involved matrix element types MT1::ElementType and MT2::ElementType. Both matrix types MT1 and MT2 as well as the two element types MT1::ElementType and MT2::ElementType have to be supported by the MultTrait class template.
In case the current number of rows and columns of the two given matrices don't match, a std::invalid_argument is thrown.
decltype(auto) blaze::operator* | ( | const DenseVector< VT, true > & | vec, |
const DenseMatrix< MT, true > & | mat | ||
) |
Multiplication operator for the multiplication of a transpose dense vector and a column-major dense matrix ( ).
vec | The left-hand side transpose dense 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 dense vector and a column-major dense matrix:
The operator returns an expression representing a transpose dense vector of the higher-order element type of the two involved element types VT::ElementType and MT::ElementType. Both the dense matrix type VT and the dense vector type MT as well as the two element types VT::ElementType and MT::ElementType have to be supported by the MultTrait class template.
In case the current size of the vector vec doesn't match the current number of rows of the matrix mat, a std::invalid_argument is thrown.
decltype(auto) blaze::operator* | ( | const SparseVector< VT, true > & | vec, |
const DenseMatrix< MT, false > & | mat | ||
) |
Multiplication operator for the multiplication of a transpose sparse vector and a row-major dense matrix ( ).
vec | The left-hand side transpose sparse 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 sparse vector and a row-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.
decltype(auto) blaze::operator* | ( | const DenseMatrix< MT1, true > & | lhs, |
const DenseMatrix< MT2, false > & | rhs | ||
) |
Multiplication operator for the multiplication of a column-major dense matrix and a row-major dense matrix ( ).
lhs | The left-hand side matrix for the multiplication. |
rhs | The right-hand side matrix for the multiplication. |
std::invalid_argument | Matrix sizes do not match. |
This operator represents the multiplication of a column-major dense matrix and a row-major dense matrix:
The operator returns an expression representing a dense matrix of the higher-order element type of the two involved matrix element types MT1::ElementType and MT2::ElementType. Both matrix types MT1 and MT2 as well as the two element types MT1::ElementType and MT2::ElementType have to be supported by the MultTrait class template.
In case the current number of columns of lhs and the current number of rows of rhs don't match, a std::invalid_argument is thrown.
decltype(auto) blaze::operator* | ( | const DenseMatrix< MT1, true > & | lhs, |
const DenseMatrix< MT2, true > & | rhs | ||
) |
Multiplication operator for the multiplication of two column-major dense matrices ( ).
lhs | The left-hand side matrix for the multiplication. |
rhs | The right-hand side matrix for the multiplication. |
std::invalid_argument | Matrix sizes do not match. |
This operator represents the multiplication of two column-major dense matrices:
The operator returns an expression representing a dense matrix of the higher-order element type of the two involved matrix element types MT1::ElementType and MT2::ElementType. Both matrix types MT1 and MT2 as well as the two element types MT1::ElementType and MT2::ElementType have to be supported by the MultTrait class template.
In case the current number of columns of lhs and the current number of rows of rhs don't match, a std::invalid_argument is thrown.
decltype(auto) blaze::operator* | ( | const DenseMatrix< MT1, true > & | lhs, |
const SparseMatrix< MT2, false > & | rhs | ||
) |
Multiplication operator for the multiplication of a column-major dense matrix and a row-major sparse matrix ( ).
lhs | The left-hand side dense matrix for the multiplication. |
rhs | The right-hand side sparse matrix for the multiplication. |
std::invalid_argument | Matrix sizes do not match. |
This operator represents the multiplication of a column-major dense matrix and a row-major sparse matrix:
The operator returns an expression representing a dense matrix of the higher-order element type of the two involved matrix element types MT1::ElementType and MT2::ElementType. Both matrix types MT1 and MT2 as well as the two element types MT1::ElementType and MT2::ElementType have to be supported by the MultTrait class template.
In case the current sizes of the two given matrices don't match, a std::invalid_argument is thrown.
decltype(auto) blaze::operator* | ( | const DenseMatrix< MT1, true > & | lhs, |
const SparseMatrix< MT2, true > & | rhs | ||
) |
Multiplication operator for the multiplication of a column-major dense matrix and a column-major sparse matrix ( ).
lhs | The left-hand side dense matrix for the multiplication. |
rhs | The right-hand side sparse matrix for the multiplication. |
std::invalid_argument | Matrix sizes do not match. |
This operator represents the multiplication of a column-major dense matrix and a column-major sparse matrix:
The operator returns an expression representing a dense matrix of the higher-order element type of the two involved matrix element types MT1::ElementType and MT2::ElementType. Both matrix types MT1 and MT2 as well as the two element types MT1::ElementType and MT2::ElementType have to be supported by the MultTrait class template.
In case the current sizes of the two given matrices don't match, a std::invalid_argument is thrown.
decltype(auto) blaze::operator* | ( | const SparseMatrix< MT1, false > & | lhs, |
const DenseMatrix< MT2, false > & | rhs | ||
) |
Multiplication operator for the multiplication of a row-major sparse matrix and a row-major dense matrix ( ).
lhs | The left-hand side sparse matrix for the multiplication. |
rhs | The right-hand side dense matrix for the multiplication. |
std::invalid_argument | Matrix sizes do not match. |
This operator represents the multiplication of a row-major sparse matrix and a row-major dense matrix:
The operator returns an expression representing a dense matrix of the higher-order element type of the two involved matrix element types MT1::ElementType and MT2::ElementType. Both matrix types MT1 and MT2 as well as the two element types MT1::ElementType and MT2::ElementType have to be supported by the MultTrait class template.
In case the current sizes of the two given matrices don't match, a std::invalid_argument is thrown.
decltype(auto) blaze::operator* | ( | const SparseMatrix< MT1, false > & | lhs, |
const DenseMatrix< MT2, true > & | rhs | ||
) |
Multiplication operator for the multiplication of a row-major sparse matrix and a column-major dense matrix ( ).
lhs | The left-hand side sparse matrix for the multiplication. |
rhs | The right-hand side dense matrix for the multiplication. |
std::invalid_argument | Matrix sizes do not match. |
This operator represents the multiplication of a row-major sparse matrix and a column-major dense matrix:
The operator returns an expression representing a dense matrix of the higher-order element type of the two involved matrix element types MT1::ElementType and MT2::ElementType. Both matrix types MT1 and MT2 as well as the two element types MT1::ElementType and MT2::ElementType have to be supported by the MultTrait class template.
In case the current sizes of the two given matrices don't match, a std::invalid_argument is thrown.
decltype(auto) blaze::operator* | ( | const SparseMatrix< MT1, true > & | lhs, |
const DenseMatrix< MT2, false > & | rhs | ||
) |
Multiplication operator for the multiplication of a column-major sparse matrix and a row-major dense matrix ( ).
lhs | The left-hand side sparse matrix for the multiplication. |
rhs | The right-hand side dense matrix for the multiplication. |
std::invalid_argument | Matrix sizes do not match. |
This operator represents the multiplication of a column-major sparse matrix and a row-major dense matrix:
The operator returns an expression representing a dense matrix of the higher-order element type of the two involved matrix element types MT1::ElementType and MT2::ElementType. Both matrix types MT1 and MT2 as well as the two element types MT1::ElementType and MT2::ElementType have to be supported by the MultTrait class template.
In case the current sizes of the two given matrices don't match, a std::invalid_argument is thrown.
decltype(auto) blaze::operator* | ( | const SparseMatrix< MT1, true > & | lhs, |
const DenseMatrix< MT2, true > & | rhs | ||
) |
Multiplication operator for the multiplication of a column-major sparse matrix and a column-major dense matrix ( ).
lhs | The left-hand side sparse matrix for the multiplication. |
rhs | The right-hand side dense matrix for the multiplication. |
std::invalid_argument | Matrix sizes do not match. |
This operator represents the multiplication of a column-major sparse matrix and a column-major dense matrix:
The operator returns an expression representing a dense matrix of the higher-order element type of the two involved matrix element types MT1::ElementType and MT2::ElementType. Both matrix types MT1 and MT2 as well as the two element types MT1::ElementType and MT2::ElementType have to be supported by the MultTrait class template.
In case the current sizes of the two given matrices don't match, a std::invalid_argument is thrown.
|
inline |
Multiplication operator for the multiplication of a dense matrix and a scalar value ( ).
mat | The left-hand side dense matrix for the multiplication. |
scalar | The right-hand side scalar value for the multiplication. |
This operator represents the multiplication between a dense matrix and a scalar value:
The operator returns an expression representing a dense matrix of the higher-order element type of the involved data types MT::ElementType and ST. Note that this operator only works for scalar values of built-in data type.
|
inline |
Multiplication operator for the multiplication of a scalar value and a dense matrix ( ).
scalar | The left-hand side scalar value for the multiplication. |
mat | The right-hand side dense matrix for the multiplication. |
This operator represents the multiplication between a a scalar value and dense matrix:
The operator returns an expression representing a dense matrix of the higher-order element type of the involved data types ST and MT::ElementType. Note that this operator only works for scalar values of built-in data type.
|
inline |
Multiplication operator for the multiplication of a row-major dense matrix and a row-major sparse matrix ( ).
lhs | The left-hand side dense matrix for the multiplication. |
rhs | The right-hand side sparse matrix for the multiplication. |
std::invalid_argument | Matrix sizes do not match. |
This operator represents the multiplication of a row-major dense matrix and a row-major sparse matrix:
The operator returns an expression representing a dense matrix of the higher-order element type of the two involved matrix element types MT1::ElementType and MT2::ElementType. Both matrix types MT1 and MT2 as well as the two element types MT1::ElementType and MT2::ElementType have to be supported by the MultTrait class template.
In case the current sizes of the two given matrices don't match, a std::invalid_argument is thrown.
|
inline |
Multiplication operator for the outer product of two dense vectors ( ).
lhs | The left-hand side dense vector for the outer product. |
rhs | The right-hand side transpose dense vector for the outer product. |
This operator represents the outer product between a dense vector and a transpose dense vector:
The operator returns an expression representing a dense matrix of the higher-order element type of the two involved element types VT1::ElementType and VT2::ElementType. Both dense 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 |
Multiplication operator for the multiplication of a row-major dense matrix and a column-major sparse matrix ( ).
lhs | The left-hand side dense matrix for the multiplication. |
rhs | The right-hand side sparse matrix for the multiplication. |
std::invalid_argument | Matrix sizes do not match. |
This operator represents the multiplication of a row-major dense matrix and a column-major sparse matrix:
The operator returns an expression representing a dense matrix of the higher-order element type of the two involved matrix element types MT1::ElementType and MT2::ElementType. Both matrix types MT1 and MT2 as well as the two element types MT1::ElementType and MT2::ElementType have to be supported by the MultTrait class template.
In case the current sizes of the two given matrices don't match, a std::invalid_argument is thrown.
|
inline |
Multiplication operator for the multiplication of a row-major dense matrix and a column-major dense matrix ( ).
lhs | The left-hand side matrix for the multiplication. |
rhs | The right-hand side matrix for the multiplication. |
std::invalid_argument | Matrix sizes do not match. |
This operator represents the multiplication of a row-major dense matrix and a column-major dense matrix:
The operator returns an expression representing a dense matrix of the higher-order element type of the two involved matrix element types MT1::ElementType and MT2::ElementType. Both matrix types MT1 and MT2 as well as the two element types MT1::ElementType and MT2::ElementType have to be supported by the MultTrait class template.
In case the current number of columns of lhs and the current number of rows of rhs don't match, a std::invalid_argument is thrown.
|
inline |
Multiplication operator for the multiplication of two row-major dense matrices ( ).
lhs | The left-hand side matrix for the multiplication. |
rhs | The right-hand side matrix for the multiplication. |
std::invalid_argument | Matrix sizes do not match. |
This operator represents the multiplication of two row-major dense matrices:
The operator returns an expression representing a dense matrix of the higher-order element type of the two involved matrix element types MT1::ElementType and MT2::ElementType. Both matrix types MT1 and MT2 as well as the two element types MT1::ElementType and MT2::ElementType have to be supported by the MultTrait class template.
In case the current number of columns of lhs and the current number of rows of rhs don't match, a std::invalid_argument is thrown.
|
inline |
Multiplication assignment operator for the multiplication of a dense matrix and a scalar value ( ).
mat | The left-hand side dense matrix for the multiplication. |
scalar | The right-hand side scalar value for the multiplication. |
std::invalid_argument | Invalid scaling of restricted matrix. |
In case the matrix MT is restricted and the assignment would violate an invariant of the matrix, a std::invalid_argument exception is thrown.
|
inline |
Multiplication assignment operator for the multiplication of a temporary dense matrix and a scalar value ( ).
mat | The left-hand side temporary dense matrix for the multiplication. |
scalar | The right-hand side scalar value for the multiplication. |
std::invalid_argument | Invalid scaling of restricted matrix. |
In case the matrix MT is restricted and the assignment would violate an invariant of the matrix, a std::invalid_argument exception is thrown.
decltype(auto) blaze::operator+ | ( | const DenseMatrix< MT1, true > & | lhs, |
const SparseMatrix< MT2, false > & | rhs | ||
) |
Addition operator for the addition of a column-major dense matrix and a row-major sparse matrix ( ).
lhs | The left-hand side dense matrix for the matrix addition. |
rhs | The right-hand side sparse matrix to be added to the left-hand side matrix. |
std::invalid_argument | Matrix sizes do not match. |
This operator represents the addition of a column-major dense matrix and a row-major sparse matrix:
The operator returns an expression representing a dense matrix of the higher-order element type of the two involved matrix element types MT1::ElementType and MT2::ElementType. Both matrix types MT1 and MT2 as well as the two element types MT1::ElementType and MT2::ElementType have to be supported by the AddTrait class template.
In case the current sizes of the two given matrices don't match, a std::invalid_argument is thrown.
decltype(auto) blaze::operator+ | ( | const SparseMatrix< MT1, false > & | lhs, |
const DenseMatrix< MT2, true > & | rhs | ||
) |
Addition operator for the addition of a row-major sparse matrix and a column-major dense matrix ( ).
lhs | The left-hand side sparse matrix for the matrix addition. |
rhs | The right-hand side dense matrix to be added to the left-hand side matrix. |
std::invalid_argument | Matrix sizes do not match. |
This operator represents the addition of a row-major sparse matrix and a column-major dense matrix:
The operator returns an expression representing a dense matrix of the higher-order element type of the two involved matrix element types MT1::ElementType and MT2::ElementType. Both matrix types MT1 and MT2 as well as the two element types MT1::ElementType and MT2::ElementType have to be supported by the AddTrait class template.
In case the current sizes of the two given matrices don't match, a std::invalid_argument is thrown.
|
inline |
Addition operator for the addition of a dense matrix and a sparse matrix with identical storage order ( ).
lhs | The left-hand side dense matrix for the matrix addition. |
rhs | The right-hand side sparse matrix to be added to the left-hand side matrix. |
std::invalid_argument | Matrix sizes do not match. |
This operator represents the addition of a dense matrix and a sparse matrix:
The operator returns an expression representing a dense matrix of the higher-order element type of the two involved matrix element types MT1::ElementType and MT2::ElementType. Both matrix types MT1 and MT2 as well as the two element types MT1::ElementType and MT2::ElementType have to be supported by the AddTrait class template.
In case the current sizes of the two given matrices don't match, a std::invalid_argument is thrown.
|
inline |
Addition operator for the addition of a row-major dense matrix and a column-major sparse matrix ( ).
lhs | The left-hand side dense matrix for the matrix addition. |
rhs | The right-hand side sparse matrix to be added to the left-hand side matrix. |
std::invalid_argument | Matrix sizes do not match. |
This operator represents the addition of a row-major dense matrix and a column-major sparse matrix:
The operator returns an expression representing a dense matrix of the higher-order element type of the two involved matrix element types MT1::ElementType and MT2::ElementType. Both matrix types MT1 and MT2 as well as the two element types MT1::ElementType and MT2::ElementType have to be supported by the AddTrait class template.
In case the current sizes of the two given matrices don't match, a std::invalid_argument is thrown.
|
inline |
Addition operator for the addition of a sparse matrix and a dense matrix ( ).
lhs | The left-hand side sparse matrix for the matrix addition. |
rhs | The right-hand side dense matrix to be added to the left-hand side matrix. |
std::invalid_argument | Matrix sizes do not match. |
This operator represents the addition of a sparse matrix and a dense matrix:
The operator returns an expression representing a dense matrix of the higher-order element type of the two involved matrix element types MT1::ElementType and MT2::ElementType. Both matrix types MT1 and MT2 as well as the two element types MT1::ElementType and MT2::ElementType have to be supported by the AddTrait class template.
In case the current sizes of the two given matrices don't match, a std::invalid_argument is thrown.
|
inline |
Addition operator for the addition of a column-major sparse matrix and a row-major dense matrix ( ).
lhs | The left-hand side sparse matrix for the matrix addition. |
rhs | The right-hand side dense matrix to be added to the left-hand side matrix. |
std::invalid_argument | Matrix sizes do not match. |
This operator represents the addition of a column-major sparse matrix and a row-major dense matrix:
The operator returns an expression representing a dense matrix of the higher-order element type of the two involved matrix element types MT1::ElementType and MT2::ElementType. Both matrix types MT1 and MT2 as well as the two element types MT1::ElementType and MT2::ElementType have to be supported by the AddTrait class template.
In case the current sizes of the two given matrices don't match, a std::invalid_argument is thrown.
|
inline |
Addition operator for the addition of a row-major and a colum-major dense matrix ( ).
lhs | The left-hand side dense matrix for the matrix addition. |
rhs | The right-hand side dense matrix to be added to the left-hand side matrix. |
std::invalid_argument | Matrix sizes do not match. |
This operator represents the addition of a row-major and a column-major dense matrix:
The operator returns an expression representing a dense matrix of the higher-order element type of the two involved matrix element types MT1::ElementType and MT2::ElementType. Both matrix types MT1 and MT2 as well as the two element types MT1::ElementType and MT2::ElementType have to be supported by the AddTrait class template.
In case the current number of rows and columns of the two given matrices don't match, a std::invalid_argument is thrown.
|
inline |
Addition operator for the addition of two dense matrices with identical storage order ( ).
lhs | The left-hand side dense matrix for the matrix addition. |
rhs | The right-hand side dense matrix to be added to the left-hand side matrix. |
std::invalid_argument | Matrix sizes do not match. |
This operator represents the addition of two dense matrices with identical storage order:
The operator returns an expression representing a dense matrix of the higher-order element type of the two involved matrix element types MT1::ElementType and MT2::ElementType. Both matrix types MT1 and MT2 as well as the two element types MT1::ElementType and MT2::ElementType have to be supported by the AddTrait class template.
In case the current number of rows and columns of the two given matrices don't match, a std::invalid_argument is thrown.
|
inline |
Addition operator for the addition of a column-major and a row-major dense matrix ( ).
lhs | The left-hand side dense matrix for the matrix addition. |
rhs | The right-hand side dense matrix to be added to the left-hand side matrix. |
std::invalid_argument | Matrix sizes do not match |
This operator represents the addition of a column-major and a row-major dense matrix:
The operator returns an expression representing a dense matrix of the higher-order element type of the two involved matrix element types MT1::ElementType and MT2::ElementType. Both matrix types MT1 and MT2 as well as the two element types MT1::ElementType and MT2::ElementType have to be supported by the AddTrait class template.
In case the current number of rows and columns of the two given matrices don't match, a std::invalid_argument is thrown.
decltype(auto) blaze::operator- | ( | const DenseMatrix< MT1, true > & | lhs, |
const SparseMatrix< MT2, false > & | rhs | ||
) |
Subtraction operator for the subtraction of a column-major dense matrix and a row-major sparse matrix ( ).
lhs | The left-hand side dense matrix for the matrix subtraction. |
rhs | The right-hand side sparse matrix to be subtracted from the dense matrix. |
std::invalid_argument | Matrix sizes do not match. |
This operator represents the subtraction of a column-major dense matrix and a row-major sparse matrix:
The operator returns an expression representing a dense matrix of the higher-order element type of the two involved matrix element types MT1::ElementType and MT2::ElementType. Both matrix types MT1 and MT2 as well as the two element types MT1::ElementType and MT2::ElementType have to be supported by the SubTrait class template.
In case the current sizes of the two given matrices don't match, a std::invalid_argument is thrown.
decltype(auto) blaze::operator- | ( | const SparseMatrix< MT1, SO > & | lhs, |
const DenseMatrix< MT2, SO > & | rhs | ||
) |
Subtraction operator for the subtraction of a sparse matrix and a dense matrix with identical storage order ( ).
lhs | The left-hand side sparse matrix for the matrix subtraction. |
rhs | The right-hand side dense matrix to be subtracted from the sparse matrix. |
std::invalid_argument | Matrix sizes do not match. |
This operator represents the subtraction of a sparse matrix and a dense matrix with identical storage order:
The operator returns an expression representing a dense matrix of the higher-order element type of the two involved matrix element types MT1::ElementType and MT2::ElementType. Both matrix types MT1 and MT2 as well as the two element types MT1::ElementType and MT2::ElementType have to be supported by the SubTrait class template.
In case the current sizes of the two given matrices don't match, a std::invalid_argument is thrown.
decltype(auto) blaze::operator- | ( | const SparseMatrix< MT1, false > & | lhs, |
const DenseMatrix< MT2, true > & | rhs | ||
) |
Subtraction operator for the subtraction of a row-major sparse matrix and a column-major dense matrix ( ).
lhs | The left-hand side sparse matrix for the matrix subtraction. |
rhs | The right-hand side dense matrix to be subtracted from the sparse matrix. |
std::invalid_argument | Matrix sizes do not match. |
This operator represents the subtraction of a row-major sparse matrix and a column-major dense matrix:
The operator returns an expression representing a dense matrix of the higher-order element type of the two involved matrix element types MT1::ElementType and MT2::ElementType. Both matrix types MT1 and MT2 as well as the two element types MT1::ElementType and MT2::ElementType have to be supported by the SubTrait class template.
In case the current sizes of the two given matrices don't match, a std::invalid_argument is thrown.
decltype(auto) blaze::operator- | ( | const SparseMatrix< MT1, true > & | lhs, |
const DenseMatrix< MT2, false > & | rhs | ||
) |
Subtraction operator for the subtraction of a column-major sparse matrix and a row-major dense matrix ( ).
lhs | The left-hand side sparse matrix for the matrix subtraction. |
rhs | The right-hand side dense matrix to be subtracted from the sparse matrix. |
std::invalid_argument | Matrix sizes do not match. |
This operator represents the subtraction of a column-major sparse matrix and a row-major dense matrix:
The operator returns an expression representing a dense matrix of the higher-order element type of the two involved matrix element types MT1::ElementType and MT2::ElementType. Both matrix types MT1 and MT2 as well as the two element types MT1::ElementType and MT2::ElementType have to be supported by the SubTrait class template.
In case the current sizes of the two given matrices don't match, a std::invalid_argument is thrown.
|
inline |
Subtraction operator for the subtraction of a dense matrix and a sparse matrix with identical storage order ( ).
lhs | The left-hand side dense matrix for the matrix subtraction. |
rhs | The right-hand side sparse matrix to be subtracted from the dense matrix. |
std::invalid_argument | Matrix sizes do not match. |
This operator represents the subtraction of a dense matrix and a sparse matrix with identical storage order:
The operator returns an expression representing a dense matrix of the higher-order element type of the two involved matrix element types MT1::ElementType and MT2::ElementType. Both matrix types MT1 and MT2 as well as the two element types MT1::ElementType and MT2::ElementType have to be supported by the SubTrait class template.
In case the current sizes of the two given matrices don't match, a std::invalid_argument is thrown.
|
inline |
Subtraction operator for the subtraction of a row-major dense matrix and a column-major sparse matrix ( ).
lhs | The left-hand side dense matrix for the matrix subtraction. |
rhs | The right-hand side sparse matrix to be subtracted from the dense matrix. |
std::invalid_argument | Matrix sizes do not match. |
This operator represents the subtraction of a row-major dense matrix and a column-major sparse matrix:
The operator returns an expression representing a dense matrix of the higher-order element type of the two involved matrix element types MT1::ElementType and MT2::ElementType. Both matrix types MT1 and MT2 as well as the two element types MT1::ElementType and MT2::ElementType have to be supported by the SubTrait class template.
In case the current sizes of the two given matrices don't match, a std::invalid_argument is thrown.
|
inline |
Subtraction operator for the subtraction of a row-major and a column-major dense matrix ( ).
lhs | The left-hand side dense matrix for the matrix subtraction. |
rhs | The right-hand side dense matrix to be subtracted from the left-hand side matrix. |
std::invalid_argument | Matrix sizes do not match. |
This operator represents the subtraction of a row-major and a column-major dense matrix:
The operator returns an expression representing a dense matrix of the higher-order element type of the two involved matrix element types MT1::ElementType and MT2::ElementType. Both matrix types MT1 and MT2 as well as the two element types MT1::ElementType and MT2::ElementType have to be supported by the SubTrait class template.
In case the current number of rows and columns of the two given matrices don't match, a std::invalid_argument is thrown.
|
inline |
Unary minus operator for the negation of a dense matrix ( ).
dm | The dense matrix to be negated. |
This operator represents the negation of a dense matrix:
The operator returns an expression representing the negation of the given dense matrix.
|
inline |
Subtraction operator for the subtraction of two dense matrices with identical storage order ( ).
lhs | The left-hand side dense matrix for the matrix subtraction. |
rhs | The right-hand side dense matrix to be subtracted from the left-hand side matrix. |
std::invalid_argument | Matrix sizes do not match. |
This operator represents the subtraction of two dense matrices with identical storage order:
The operator returns an expression representing a dense matrix of the higher-order element type of the two involved matrix element types MT1::ElementType and MT2::ElementType. Both matrix types MT1 and MT2 as well as the two element types MT1::ElementType and MT2::ElementType have to be supported by the SubTrait class template.
In case the current number of rows and columns of the two given matrices don't match, a std::invalid_argument is thrown.
|
inline |
Subtraction operator for the subtraction of a column-major and a row-major dense matrix ( ).
lhs | The left-hand side dense matrix for the matrix subtraction. |
rhs | The right-hand side dense matrix to be subtracted from the left-hand side matrix. |
std::invalid_argument | Matrix sizes do not match |
This operator represents the subtraction of a column-major and a row-major dense matrix:
The operator returns an expression representing a dense matrix of the higher-order element type of the two involved matrix element types MT1::ElementType and MT2::ElementType. Both matrix types MT1 and MT2 as well as the two element types MT1::ElementType and MT2::ElementType have to be supported by the SubTrait class template.
In case the current number of rows and columns of the two given matrices don't match, a std::invalid_argument is thrown.
|
inline |
Division operator for the division of a dense matrix by a scalar value ( ).
mat | The left-hand side dense matrix for the division. |
scalar | The right-hand side scalar value for the division. |
This operator represents the division of a dense matrix by a scalar value:
The operator returns an expression representing a dense matrix of the higher-order element type of the involved data types MT::ElementType and ST. Note that this operator only works for scalar values of built-in data type.
|
inline |
Division assignment operator for the division of a dense matrix by a scalar value ( ).
mat | The left-hand side dense matrix for the division. |
scalar | The right-hand side scalar value for the division. |
std::invalid_argument | Invalid scaling of restricted matrix. |
In case the matrix MT is restricted and the assignment would violate an invariant of the matrix, a std::invalid_argument exception is thrown.
|
inline |
Division assignment operator for the division of a temporary dense matrix by a scalar value ( ).
mat | The left-hand side temporary dense matrix for the division. |
scalar | The right-hand side scalar value for the division. |
std::invalid_argument | Invalid scaling of restricted matrix. |
In case the matrix MT is restricted and the assignment would violate an invariant of the matrix, a std::invalid_argument exception is thrown.
|
inline |
Equality operator for the comparison of a row-major dense matrix and a scalar value.
mat | The left-hand side row-major dense matrix for the comparison. |
scalar | The right-hand side scalar value for the comparison. |
If all values of the matrix are equal to the scalar value, the equality test returns true, otherwise false. Note that this function can only be used with built-in, numerical data types!
|
inline |
Equality operator for the comparison of a column-major dense matrix and a scalar value.
mat | The left-hand side column-major dense matrix for the comparison. |
scalar | The right-hand side scalar value for the comparison. |
If all values of the matrix are equal to the scalar value, the equality test returns true, otherwise false. Note that this function can only be used with built-in, numerical data types!
|
inline |
Equality operator for the comparison of a scalar value and a dense matrix.
scalar | The left-hand side scalar value for the comparison. |
mat | The right-hand side dense matrix for the comparison. |
If all values of the matrix are equal to the scalar value, the equality test returns true, otherwise false. Note that this function can only be used with built-in, numerical data types!
|
inline |
Equality operator for the comparison of a dense matrix and a sparse matrix.
lhs | The left-hand side dense matrix for the comparison. |
rhs | The right-hand side sparse matrix for the comparison. |
|
inline |
Equality operator for the comparison of a sparse matrix and a dense matrix.
lhs | The left-hand side sparse matrix for the comparison. |
rhs | The right-hand side dense matrix for the comparison. |
|
inline |
Equality operator for the comparison of two dense matrices.
lhs | The left-hand side matrix for the comparison. |
rhs | The right-hand side matrix for the comparison. |
|
inline |
Computes the componentwise exponential value for the dense matrices lhs and rhs.
lhs | The left-hand side dense matrix operand. |
rhs | The right-hand side dense matrix operand. |
The pow() function computes the componentwise exponential value for the two dense matrices lhs and rhs. The function returns an expression representing this operation.
The following example demonstrates the use of the pow() function:
|
inline |
Computes the exponential value for each single element of the dense matrix dm.
dm | The input matrix. |
exp | The scalar exponent. |
The pow() function computes the exponential value for each element of the input matrix dm. The function returns an expression representing this operation.
The following example demonstrates the use of the pow() function:
|
inline |
Reduces the given dense matrix by means of multiplication.
dm | The given dense matrix for the reduction operation. |
This function reduces the given dense matrix dm by means of multiplication:
Please note that the evaluation order of the reduction operation is unspecified.
|
inline |
Reduces the given dense matrix by means of multiplication.
dm | The given dense matrix for the reduction operation. |
This function reduces the rows or columns of the given dense matrix dm by means of multiplication. In case the reduction flag RF is set to blaze::columnwise, the elements of the matrix are reduced column-wise and the result is a row vector. In case RF is set to blaze::rowwise, the elements of the matrix are reduced row-wise and the result is a column vector:
Please note that the evaluation order of the reduction operation is unspecified.
void blaze::ql | ( | const DenseMatrix< MT1, SO1 > & | A, |
DenseMatrix< MT2, SO2 > & | Q, | ||
DenseMatrix< MT3, SO3 > & | L | ||
) |
QL decomposition of the given dense matrix.
A | The matrix to be decomposed. |
Q | The resulting Q matrix. |
L | The resulting L matrix. |
std::invalid_argument | Dimensions of fixed size matrix do not match. |
std::invalid_argument | Square matrix cannot be resized to m-by-n. |
This function performs the dense matrix QL decomposition of a general m-by-n matrix. The resulting decomposition has the form
where Q
is a general m-by-min(m,n) matrix and L
is a lower trapezoidal min(m,n)-by-n matrix. The decomposition is written to the two distinct matrices Q
and L
, which are resized to the correct dimensions (if possible and necessary).
The function fails if ...
In all failure cases a std::invalid_argument exception is thrown.
Example:
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!void blaze::qr | ( | const DenseMatrix< MT1, SO1 > & | A, |
DenseMatrix< MT2, SO2 > & | Q, | ||
DenseMatrix< MT3, SO3 > & | R | ||
) |
QR decomposition of the given dense matrix.
A | The matrix to be decomposed. |
Q | The resulting Q matrix. |
R | The resulting R matrix. |
std::invalid_argument | Dimensions of fixed size matrix do not match. |
std::invalid_argument | Square matrix cannot be resized to m-by-n. |
This function performs the dense matrix QR decomposition of a general m-by-n matrix. The resulting decomposition has the form
where Q
is a general m-by-min(m,n) matrix and R
is an upper trapezoidal min(m,n)-by-n matrix. The decomposition is written to the two distinct matrices Q
and R
, which are resized to the correct dimensions (if possible and necessary).
The function fails if ...
In all failure cases a std::invalid_argument exception is thrown.
Example:
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!
|
inline |
Returns a matrix containing the real part of each single element of dm.
dm | The input matrix. |
The real function calculates the real part of each element of the input matrix dm. 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 matrix.
dm | The given dense matrix for the reduction computation. |
op | The reduction operation. |
This function reduces the given dense matrix dm 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 |
Performs a custom reduction operation on the given dense matrix.
dm | The given dense matrix for the reduction computation. |
op | The reduction operation. |
This function reduces the rows or columns of the given dense matrix dm by means of the given reduction operation op. In case the reduction flag RF is set to blaze::columnwise, the elements of the matrix are reduced column-wise and the result is a row vector. In case RF is set to blaze::rowwise, the elements of the matrix are reduced row-wise and the result is a column vector:
As demonstrated in the examples 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 |
Applies the round() function to each single element of the dense matrix dm.
dm | The input matrix. |
This function applies the round() function to each element of the input matrix dm. The function returns an expression representing this operation.
The following example demonstrates the use of the round() function:
void blaze::rq | ( | const DenseMatrix< MT1, SO1 > & | A, |
DenseMatrix< MT2, SO2 > & | R, | ||
DenseMatrix< MT3, SO3 > & | Q | ||
) |
RQ decomposition of the given dense matrix.
A | The matrix to be decomposed. |
R | The resulting R matrix. |
Q | The resulting Q matrix. |
std::invalid_argument | Dimensions of fixed size matrix do not match. |
std::invalid_argument | Square matrix cannot be resized to m-by-n. |
This function performs the dense matrix RQ decomposition of a general m-by-n matrix. The resulting decomposition has the form
where R
is an upper trapezoidal m-by-min(m,n) matrix and Q
is a general min(m,n)-by-n matrix. The decomposition is written to the two distinct matrices R
and Q
, which are resized to the correct dimensions (if possible and necessary).
The function fails if ...
In all failure cases a std::invalid_argument exception is thrown.
Example:
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!
|
inline |
Forces the serial evaluation of the given dense matrix expression dm.
dm | The input matrix. |
The serial function forces the serial evaluation of the given dense matrix expression dm. The function returns an expression representing the operation.
The following example demonstrates the use of the serial function:
|
inline |
Applies the sign() function to each single element of the dense matrix dm.
dm | The input matrix. |
This function applies the sign() function to each element of the input matrix dm. 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 matrix dm.
dm | The input matrix. |
The sin() function computes the sine for each element of the input matrix dm. 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 matrix dm.
dm | The input matrix. |
The sinh() function computes the hyperbolic sine for each element of the input matrix dm. The function returns an expression representing this operation.
The following example demonstrates the use of the sinh() function:
auto blaze::softmax | ( | const DenseMatrix< MT, SO > & | dm | ) |
Computes the softmax function for the given dense matrix.
dm | The given dense matrix for the softmax computation. |
This function computes the softmax function (i.e. the normalized exponential function) for the given dense matrix dm (see also https://en.wikipedia.org/wiki/Softmax_function). The resulting dense matrix consists of real values in the range (0..1], which add up to 1.
auto blaze::softmax | ( | const DenseMatrix< MT, SO > & | dm | ) |
Computes the row-/columnwise softmax function for the given dense matrix.
dm | The given dense matrix for the softmax computation. |
This function computes the row-/columnwise softmax function (i.e. the normalized exponential function) for the given dense matrix dm (see also https://en.wikipedia.org/wiki/Softmax_function). The resulting dense matrix consists of real values in the range (0..1], which add up to the numbers of rows or columns, respectively.
|
noexcept |
Returns the spacing between the beginning of two rows/columns.
dm | The given matrix. |
decltype(auto) blaze::sqrNorm | ( | const DenseMatrix< MT, SO > & | dm | ) |
Computes the squared L2 norm for the given dense matrix.
dm | The given dense matrix for the norm computation. |
This function computes the squared L2 norm of the given dense matrix:
|
inline |
Computes the square root of each single element of the dense matrix dm.
dm | The input matrix; all elements must be in the range ![]() |
The sqrt() function computes the square root of each element of the input matrix dm. The function returns an expression representing this operation.
The following example demonstrates the use of the sqrt() function:
|
inline |
Reduces the given dense matrix by means of addition.
dm | The given dense matrix for the reduction operation. |
This function reduces the given dense matrix dm by means of addition:
Please note that the evaluation order of the reduction operation is unspecified.
|
inline |
Reduces the given dense matrix by means of addition.
dm | The given dense matrix for the reduction operation. |
This function reduces the rows or columns of the given dense matrix dm by means of addition. In case the reduction flag RF is set to blaze::columnwise, the elements of the matrix are reduced column-wise and the result is a row vector. In case RF is set to blaze::rowwise, the elements of the matrix are reduced row-wise and the result is a column vector:
Please note that the evaluation order of the reduction operation is unspecified.
|
inline |
Singular value decomposition (SVD) of the given dense general matrix.
A | The given general matrix. |
s | The resulting vector of singular values. |
std::invalid_argument | Size of fixed size vector does not match. |
std::runtime_error | Singular value decomposition failed. |
This function performs the singular value decomposition of a general m-by-n matrix. The resulting min(m,n) singular values are stored in the given vector s, which is resized to the correct size (if possible and necessary).
The function fails if ...
In all failure cases an exception is thrown.
Examples:
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!
|
inline |
Singular value decomposition (SVD) of the given dense general matrix.
A | The given general matrix. |
U | The resulting matrix of left singular vectors. |
s | The resulting vector of singular values. |
V | The resulting matrix of right singular vectors. |
std::invalid_argument | Dimensions of fixed size matrix U do not match. |
std::invalid_argument | Size of fixed size vector does not match. |
std::invalid_argument | Dimensions of fixed size matrix V do not match. |
std::runtime_error | Singular value decomposition failed. |
This function performs the singular value decomposition of a general m-by-n matrix. The resulting min(m,n) singular values are stored in the given vector s, the resulting left singular vectors are stored in the given matrix U, and the resulting right singular vectors are stored in the given matrix V. s, U and V are resized to the correct dimensions (if possible and necessary).
The function fails if ...
In all failure cases an exception is thrown.
Examples:
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!
|
inline |
Singular value decomposition (SVD) of the given dense general matrix.
A | The given general matrix. |
s | The resulting vector of singular values. |
low | The lower bound of the interval to be searched for singular values. |
upp | The upper bound of the interval to be searched for singular values. |
std::invalid_argument | Size of fixed size vector does not match. |
std::invalid_argument | Invalid value range provided. |
std::invalid_argument | Invalid index range provided. |
std::runtime_error | Singular value decomposition failed. |
This function computes a specified number of singular values of the given general m-by-n matrix. The number of singular values to be computed is specified by the lower bound low and the upper bound upp, which either form an integral or a floating point range.
In case low and upp are of integral type, the function computes all singular values in the index range . The num resulting real and non-negative singular values are stored in descending order in the given vector s, which is either resized (if possible) or expected to be a num-dimensional vector.
In case low and upp are of floating point type, the function computes all singular values in the half-open interval . The resulting real and non-negative singular values are stored in descending order in the given vector s, which is either resized (if possible) or expected to be a min(m,n)-dimensional vector.
The function fails if ...
In all failure cases an exception is thrown.
Examples:
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!
|
inline |
Singular value decomposition (SVD) of the given dense general matrix.
A | The given general matrix. |
U | The resulting matrix of left singular vectors. |
s | The resulting vector of singular values. |
V | The resulting matrix of right singular vectors. |
low | The lower bound of the interval to be searched for singular values. |
upp | The upper bound of the interval to be searched for singular values. |
std::invalid_argument | Dimensions of fixed size matrix U do not match. |
std::invalid_argument | Size of fixed size vector does not match. |
std::invalid_argument | Dimensions of fixed size matrix V do not match. |
std::invalid_argument | Invalid value range provided. |
std::invalid_argument | Invalid index range provided. |
std::runtime_error | Singular value decomposition failed. |
This function computes a specified number of singular values and singular vectors of the given general m-by-n matrix. The number of singular values and vectors to be computed is specified by the lower bound low and the upper bound upp, which either form an integral or a floating point range.
In case low and upp form are of integral type, the function computes all singular values in the index range . The num resulting real and non-negative singular values are stored in descending order in the given vector s, which is either resized (if possible) or expected to be a num-dimensional vector. The resulting left singular vectors are stored in the given matrix U, which is either resized (if possible) or expected to be a m-by-num matrix. The resulting right singular vectors are stored in the given matrix V, which is either resized (if possible) or expected to be a num-by-n matrix.
In case low and upp are of floating point type, the function computes all singular values in the half-open interval . The resulting real and non-negative singular values are stored in descending order in the given vector s, which is either resized (if possible) or expected to be a min(m,n)-dimensional vector. The resulting left singular vectors are stored in the given matrix U, which is either resized (if possible) or expected to be a m-by-min(m,n) matrix. The resulting right singular vectors are stored in the given matrix V, which is either resized (if possible) or expected to be a min(m,n)-by-n matrix.
The function fails if ...
In all failure cases an exception is thrown.
Examples:
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!
|
inline |
Computes the tangent for each single element of the dense matrix dm.
dm | The input matrix. |
The tan() function computes the tangent for each element of the input matrix dm. 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 matrix dm.
dm | The input matrix; all elements must be in the range ![]() |
The tanh() function computes the hyperbolic tangent for each element of the input matrix dm. 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 matrix.
dm | The dense matrix to be transposed. |
This function returns an expression representing the transpose of the given dense matrix:
|
inline |
Applies the trunc() function to each single element of the dense matrix dm.
dm | The input matrix. |
This function applies the trunc() function to each element of the input matrix dm. The function returns an expression representing this operation.
The following example demonstrates the use of the trunc() function: