![]() |
Blaze 3.9
|
Modules | |
Adaptors | |
BLAS | |
Compile time constraints | |
Matrices | |
Vectors | |
Functors | |
LAPACK | |
Serialization | |
Shims | |
SIMD | |
Shared memory parallelization module | |
Expression traits | |
Type traits | |
Views | |
Classes | |
class | blaze::NegativeAccuracy< A > |
Negative computation accuracy for floating point data types. More... | |
class | blaze::Accuracy |
Computation accuracy for floating point data types. More... | |
class | blaze::DenseIterator< Type, AF > |
Implementation of a generic iterator for dense vectors and matrices. More... | |
class | blaze::InitializerIterator< Type > |
Implementation of an iterator for (extended) initializer lists. More... | |
class | blaze::UniformIterator< Type, AF > |
Implementation of a generic iterator for uniform vectors and matrices. More... | |
class | blaze::NegativeEpsilon< E > |
Negative epsilon value for floating point data types. More... | |
class | blaze::Epsilon |
Numerical epsilon value for floating point data types. More... | |
struct | blaze::AddExpr< T > |
Base class for all addition expression templates. More... | |
struct | blaze::BinaryMapExpr< T > |
Base class for all for-each expression templates. More... | |
struct | blaze::Computation |
Base class for all compute expression templates. More... | |
struct | blaze::CrossExpr< VT > |
Base class for all cross product expression templates. More... | |
struct | blaze::Declaration< T > |
Base class for all declaration expression templates. More... | |
struct | blaze::DeclDiagExpr< MT > |
Base class for all decldiag expression templates. More... | |
struct | blaze::DeclExpr< T > |
Base class for all matrix for-each expression templates. More... | |
struct | blaze::DeclHermExpr< MT > |
Base class for all declherm expression templates. More... | |
struct | blaze::DeclLowExpr< MT > |
Base class for all decllow expression templates. More... | |
struct | blaze::DeclStrLowExpr< MT > |
Base class for all declstrlow expression templates. More... | |
struct | blaze::DeclStrUppExpr< MT > |
Base class for all declstrupp expression templates. More... | |
struct | blaze::DeclSymExpr< MT > |
Base class for all declsym expression templates. More... | |
struct | blaze::DeclUniLowExpr< MT > |
Base class for all declunilow expression templates. More... | |
struct | blaze::DeclUniUppExpr< MT > |
Base class for all decluniupp expression templates. More... | |
struct | blaze::DeclUppExpr< MT > |
Base class for all declupp expression templates. More... | |
struct | blaze::DivExpr< T > |
Base class for all division expression templates. More... | |
struct | blaze::EigenExpr< MT > |
Base class for all eigenvalue expression templates. More... | |
struct | blaze::EvalExpr< T > |
Base class for all evaluation expression templates. More... | |
struct | blaze::ExpandExpr< T > |
Base class for all expansion expression templates. More... | |
class | blaze::ExpandExprData< CEAs > |
Auxiliary class template for the data members of expansion expression classes. More... | |
struct | blaze::Expression< T > |
Base class for all expression templates. More... | |
struct | blaze::GenExpr< T > |
Base class for all for-each expression templates. More... | |
struct | blaze::KronExpr< MT > |
Base class for all Kron product expression templates. More... | |
struct | blaze::MatEvalExpr< MT > |
Base class for all matrix evaluation expression templates. More... | |
struct | blaze::MatExpExpr< MT > |
Base class for all matrix exponential expression templates. More... | |
struct | blaze::MatGenExpr< MT > |
Base class for all matrix generator expression templates. More... | |
struct | blaze::MatInvExpr< MT > |
Base class for all matrix inversion expression templates. More... | |
struct | blaze::MatMapExpr< MT > |
Base class for all unary matrix map expression templates. More... | |
struct | blaze::MatMatAddExpr< MT > |
Base class for all matrix/matrix addition expression templates. More... | |
struct | blaze::MatMatKronExpr< MT > |
Base class for all matrix/matrix Kronecker expression templates. More... | |
struct | blaze::MatMatMapExpr< MT > |
Base class for all binary matrix map expression templates. More... | |
struct | blaze::MatMatMultExpr< MT > |
Base class for all matrix/matrix multiplication expression templates. More... | |
struct | blaze::MatMatSolveExpr< MT > |
Base class for all multi LSE solver expression templates. More... | |
struct | blaze::MatMatSubExpr< MT > |
Base class for all matrix/matrix subtraction expression templates. More... | |
struct | blaze::MatNoAliasExpr< MT > |
Base class for all matrix no-alias expression templates. More... | |
struct | blaze::MatNoSIMDExpr< MT > |
Base class for all matrix no-SIMD expression templates. More... | |
struct | blaze::MatReduceExpr< VT, RF > |
Base class for all matrix reduction expression templates. More... | |
struct | blaze::MatRepeatExpr< MT, CEAs > |
Base class for all matrix repeat expression templates. More... | |
struct | blaze::MatScalarDivExpr< MT > |
Base class for all matrix/scalar division expression templates. More... | |
struct | blaze::MatScalarMultExpr< MT > |
Base class for all matrix/scalar multiplication expression templates. More... | |
struct | blaze::MatSerialExpr< MT > |
Base class for all matrix serial evaluation expression templates. More... | |
struct | blaze::MatTransExpr< MT > |
Base class for all matrix transposition expression templates. More... | |
struct | blaze::MatVecMultExpr< VT > |
Base class for all matrix/vector multiplication expression templates. More... | |
struct | blaze::MatVecSolveExpr< VT > |
Base class for all single LSE solver expression templates. More... | |
struct | blaze::Modification< T > |
Base class for all modification expression templates. More... | |
struct | blaze::MultExpr< T > |
Base class for all multiplication expression templates. More... | |
struct | blaze::NoAliasExpr< T > |
Base class for all no-alias expression templates. More... | |
struct | blaze::NoSIMDExpr< T > |
Base class for all no-SIMD expression templates. More... | |
struct | blaze::Operation |
Base class for all operational expression templates. More... | |
struct | blaze::ReduceExpr< T > |
Base class for all reduction expression templates. More... | |
struct | blaze::RepeatExpr< T > |
Base class for all for-each expression templates. More... | |
class | blaze::RepeatExprData< Dim, CRAs > |
Auxiliary class template for the data members of repeater expression classes. More... | |
struct | blaze::SchurExpr< MT > |
Base class for all Schur product expression templates. More... | |
struct | blaze::SerialExpr< T > |
Base class for all serial evaluation expression templates. More... | |
struct | blaze::SolveExpr< T > |
Base class for all LSE solver expression templates. More... | |
struct | blaze::SubExpr< T > |
Base class for all subtraction expression templates. More... | |
struct | blaze::SVDExpr< MT > |
Base class for all singular value expression templates. More... | |
struct | blaze::TransExpr< T > |
Base class for all transposition expression templates. More... | |
struct | blaze::Transformation |
Base class for all transform expression templates. More... | |
struct | blaze::TVecMatMultExpr< VT > |
Base class for all vector/matrix multiplication expression templates. More... | |
struct | blaze::UnaryMapExpr< T > |
Base class for all for-each expression templates. More... | |
struct | blaze::VecEvalExpr< VT > |
Base class for all vector evaluation expression templates. More... | |
struct | blaze::VecExpandExpr< MT, CEAs > |
Base class for all vector expansion expression templates. More... | |
struct | blaze::VecGenExpr< VT > |
Base class for all vector generator expression templates. More... | |
struct | blaze::VecMapExpr< VT > |
Base class for all unary vector map expression templates. More... | |
struct | blaze::VecNoAliasExpr< VT > |
Base class for all vector no-alias expression templates. More... | |
struct | blaze::VecNoSIMDExpr< VT > |
Base class for all vector no-SIMD expression templates. More... | |
struct | blaze::VecRepeatExpr< VT, CRAs > |
Base class for all vector repeater expression templates. More... | |
struct | blaze::VecScalarDivExpr< VT > |
Base class for all vector/scalar division expression templates. More... | |
struct | blaze::VecScalarMultExpr< VT > |
Base class for all vector/scalar multiplication expression templates. More... | |
struct | blaze::VecSerialExpr< VT > |
Base class for all vector serial evaluation expression templates. More... | |
struct | blaze::VecTransExpr< VT > |
Base class for all vector transposition expression templates. More... | |
struct | blaze::VecTVecMapExpr< MT > |
Base class for all outer map expression templates. More... | |
struct | blaze::VecTVecMultExpr< MT > |
Base class for all outer product expression templates. More... | |
struct | blaze::VecVecAddExpr< VT > |
Base class for all vector/vector addition expression templates. More... | |
struct | blaze::VecVecDivExpr< VT > |
Base class for all vector/vector division expression templates. More... | |
struct | blaze::VecVecKronExpr< VT > |
Base class for all vector/vector Kronecker expression templates. More... | |
struct | blaze::VecVecMapExpr< VT > |
Base class for all binary vector map expression templates. More... | |
struct | blaze::VecVecMultExpr< VT > |
Base class for all vector/vector multiplication expression templates. More... | |
struct | blaze::VecVecSubExpr< VT > |
Base class for all vector/vector subtraction expression templates. More... | |
struct | blaze::View< T > |
Base class for all views. More... | |
struct | blaze::GroupTag< ID > |
Group tag for vectors and matrices. More... | |
class | blaze::NegativeInfinity< I > |
Negative infinity for built-in data types. More... | |
class | blaze::Infinity |
Positive infinity for built-in data types. More... | |
class | blaze::ComplexProxy< PT, CT > |
Proxy backend for complex types. More... | |
class | blaze::DefaultProxy< PT, RT > |
Default proxy backend for built-in and alternate user-specific class types. More... | |
class | blaze::DenseMatrixProxy< PT, MT > |
Proxy backend for dense matrix types. More... | |
class | blaze::DenseVectorProxy< PT, VT > |
Proxy backend for dense vector types. More... | |
class | blaze::Proxy< PT, RT > |
Proxy base class. More... | |
class | blaze::SparseMatrixProxy< PT, MT > |
Proxy backend for sparse matrix types. More... | |
class | blaze::SparseVectorProxy< PT, VT > |
Proxy backend for sparse vector types. More... | |
struct | blaze::SparseElement |
Base class for all sparse element types. More... | |
class | blaze::ValueIndexPair< Type > |
Index-value-pair for sparse vectors and matrices. More... | |
Macros | |
#define | BLAZE_THROW_DIVISION_BY_ZERO(MESSAGE) BLAZE_THROW_RUNTIME_ERROR( MESSAGE ) |
Macro for the emission of an exception on detection of a division by zero. More... | |
#define | BLAZE_THROW_LAPACK_ERROR(MESSAGE) BLAZE_THROW_RUNTIME_ERROR( MESSAGE ) |
Macro for the emission of an exception on detection of a LAPACK error. More... | |
Typedefs | |
using | blaze::blas_int_t = int32_t |
Signed integer type used in the BLAS/LAPACK wrapper functions. | |
using | blaze::Group0 = GroupTag< 0UL > |
Tag for group 0. This is the default tag for vectors and matrices. | |
using | blaze::Group1 = GroupTag< 1UL > |
Tag for group 1. | |
using | blaze::Group2 = GroupTag< 2UL > |
Tag for group 2. | |
using | blaze::Group3 = GroupTag< 3UL > |
Tag for group 3. | |
using | blaze::Group4 = GroupTag< 4UL > |
Tag for group 4. | |
using | blaze::Group5 = GroupTag< 5UL > |
Tag for group 5. | |
using | blaze::Group6 = GroupTag< 6UL > |
Tag for group 6. | |
using | blaze::Group7 = GroupTag< 7UL > |
Tag for group 7. | |
using | blaze::Group8 = GroupTag< 8UL > |
Tag for group 8. | |
using | blaze::Group9 = GroupTag< 9UL > |
Tag for group 9. | |
Enumerations | |
enum | blaze::AlignmentFlag : bool { blaze::unaligned = false , blaze::aligned = true } |
Alignment flag for (un-)aligned vectors and matrices. More... | |
enum | blaze::InversionFlag { blaze::byLU = 0 , blaze::byLDLT = 1 , blaze::byLDLH = 2 , blaze::byLLH = 3 , blaze::asGeneral = 4 , blaze::asSymmetric = 5 , blaze::asHermitian = 6 , blaze::asLower = 7 , blaze::asUniLower = 8 , blaze::asUpper = 9 , blaze::asUniUpper = 10 , blaze::asDiagonal = 11 } |
Inversion flag. More... | |
enum | blaze::PaddingFlag : bool { blaze::unpadded = false , blaze::padded = true } |
Padding flag for (un-)padded vectors and matrices. More... | |
enum | blaze::RelaxationFlag : bool { blaze::strict = false , blaze::relaxed = true } |
Relaxation flag for strict or relaxed semantics. More... | |
Functions | |
constexpr AlignmentFlag | blaze::operator! (AlignmentFlag flag) noexcept |
Negating the given alignment flag. More... | |
template<typename Type > | |
size_t | blaze::nonZeros (initializer_list< Type > list) noexcept |
Determines the number of non-zero elements contained in the given initializer list. More... | |
template<typename Type > | |
size_t | blaze::nonZeros (initializer_list< initializer_list< Type > > list) noexcept |
Determines the number of non-zero elements contained in the given initializer list. More... | |
template<typename Type > | |
constexpr size_t | blaze::determineColumns (initializer_list< initializer_list< Type > > list) noexcept |
Determines the maximum number of columns specified by the given initializer list. More... | |
constexpr PaddingFlag | blaze::operator! (PaddingFlag flag) noexcept |
Negating the given padding flag. More... | |
constexpr RelaxationFlag | blaze::operator! (RelaxationFlag flag) noexcept |
Negating the given relaxation flag. More... | |
template<typename T1 , typename T2 > | |
BLAZE_ALWAYS_INLINE constexpr auto | blaze::nextMultiple (T1 value, T2 factor) noexcept |
Rounds up an integral value to the next multiple of a given factor. More... | |
template<typename T1 , typename T2 > | |
BLAZE_ALWAYS_INLINE constexpr auto | blaze::prevMultiple (T1 value, T2 factor) noexcept |
Rounds down an integral value to the previous multiple of a given factor. More... | |
Accuracy operators | |
constexpr Accuracy | blaze::accuracy |
Global Accuracy instance. More... | |
template<typename T > | |
constexpr bool | blaze::operator== (const Accuracy &, const T &rhs) |
Equality comparison between an Accuracy object and a floating point value. More... | |
template<typename T > | |
constexpr bool | blaze::operator== (const T &lhs, const Accuracy &) |
Equality comparison between a floating point value and an Accuracy object. More... | |
template<typename T > | |
constexpr bool | blaze::operator!= (const Accuracy &, const T &rhs) |
Inequality comparison between an Accuracy object and a floating point value. More... | |
template<typename T > | |
constexpr bool | blaze::operator!= (const T &lhs, const Accuracy &) |
Inequality comparison between a floating point value and an Accuracy object. More... | |
template<typename T > | |
constexpr bool | blaze::operator< (const Accuracy &, const T &rhs) |
Less-than comparison between an Accuracy object and a floating point value. More... | |
template<typename T > | |
constexpr bool | blaze::operator< (const T &lhs, const Accuracy &) |
Less-than comparison between a floating point value and an Accuracy object. More... | |
template<typename T > | |
constexpr bool | blaze::operator> (const Accuracy &, const T &rhs) |
Greater-than comparison between an Accuracy object and a floating point value. More... | |
template<typename T > | |
constexpr bool | blaze::operator> (const T &lhs, const Accuracy &) |
Greater-than comparison between a floating point value and an Accuracy object. More... | |
template<typename T > | |
constexpr bool | blaze::operator<= (const Accuracy &, const T &rhs) |
Less-or-equal-than comparison between an Accuracy object and a floating point value. More... | |
template<typename T > | |
constexpr bool | blaze::operator<= (const T &lhs, const Accuracy &) |
Less-or-equal-than comparison between a floating point value and an Accuracy object. More... | |
template<typename T > | |
constexpr bool | blaze::operator>= (const Accuracy &, const T &rhs) |
Greater-or-equal-than comparison between an Accuracy object and a floating point value. More... | |
template<typename T > | |
constexpr bool | blaze::operator>= (const T &lhs, const Accuracy &) |
Less-or-equal-than comparison between a floating point value and an Accuracy object. More... | |
Epsilon operators | |
constexpr Epsilon | blaze::epsilon |
Global Epsilon instance. More... | |
template<typename T > | |
constexpr bool | blaze::operator== (const Epsilon &, const T &rhs) |
Equality comparison between an Epsilon object and a floating point value. More... | |
template<typename T > | |
constexpr bool | blaze::operator== (const T &lhs, const Epsilon &) |
Equality comparison between a floating point value and an Epsilon object. More... | |
template<typename T > | |
constexpr bool | blaze::operator!= (const Epsilon &, const T &rhs) |
Inequality comparison between an Epsilon object and a floating point value. More... | |
template<typename T > | |
constexpr bool | blaze::operator!= (const T &lhs, const Epsilon &) |
Inequality comparison between a floating point value and an Epsilon object. More... | |
template<typename T > | |
constexpr bool | blaze::operator< (const Epsilon &, const T &rhs) |
Less-than comparison between an Epsilon object and a floating point value. More... | |
template<typename T > | |
constexpr bool | blaze::operator< (const T &lhs, const Epsilon &) |
Less-than comparison between a floating point value and an Epsilon object. More... | |
template<typename T > | |
constexpr bool | blaze::operator> (const Epsilon &, const T &rhs) |
Greater-than comparison between an Epsilon object and a floating point value. More... | |
template<typename T > | |
constexpr bool | blaze::operator> (const T &lhs, const Epsilon &) |
Greater-than comparison between a floating point value and an Epsilon object. More... | |
template<typename T > | |
constexpr bool | blaze::operator<= (const Epsilon &, const T &rhs) |
Less-or-equal-than comparison between an Epsilon object and a floating point value. More... | |
template<typename T > | |
constexpr bool | blaze::operator<= (const T &lhs, const Epsilon &) |
Less-or-equal-than comparison between a floating point value and an Epsilon object. More... | |
template<typename T > | |
constexpr bool | blaze::operator>= (const Epsilon &, const T &rhs) |
Greater-or-equal-than comparison between an Epsilon object and a floating point value. More... | |
template<typename T > | |
constexpr bool | blaze::operator>= (const T &lhs, const Epsilon &) |
Less-or-equal-than comparison between a floating point value and an Epsilon object. More... | |
Infinity operators | |
constexpr Infinity | blaze::inf |
Global Infinity instance. More... | |
constexpr bool | blaze::operator== (const Infinity &, const Infinity &) |
Equality comparison between two Infinity objects. More... | |
template<typename I > | |
constexpr bool | blaze::operator== (const Infinity &, const NegativeInfinity< I > &) |
Equality comparison between an Infinity object and a NegativeInfinity object. More... | |
template<typename I > | |
constexpr bool | blaze::operator== (const NegativeInfinity< I > &, const Infinity &) |
Equality comparison between a NegativeInfinity object and an Infinity object. More... | |
template<typename T > | |
constexpr bool | blaze::operator== (const Infinity &lhs, const T &rhs) |
Equality comparison between an Infinity object and a built-in data type. More... | |
template<typename T > | |
constexpr bool | blaze::operator== (const T &lhs, const Infinity &rhs) |
Equality comparison between a built-in data type and an Infinity object. More... | |
constexpr bool | blaze::operator!= (const Infinity &, const Infinity &) |
Inequality comparison between two Infinity objects. More... | |
template<typename I > | |
constexpr bool | blaze::operator!= (const Infinity &, const NegativeInfinity< I > &) |
Inequality comparison between an Infinity object and a NegativeInfinity object. More... | |
template<typename I > | |
constexpr bool | blaze::operator!= (const NegativeInfinity< I > &, const Infinity &) |
Inequality comparison between a NegativeInfinity object and an Infinity object. More... | |
template<typename T > | |
constexpr bool | blaze::operator!= (const Infinity &lhs, const T &rhs) |
Inequality comparison between an Infinity object and a built-in data type. More... | |
template<typename T > | |
constexpr bool | blaze::operator!= (const T &lhs, const Infinity &rhs) |
Inequality comparison between a built-in data type and an Infinity object. More... | |
NegativeAccuracy operators | |
template<typename A , typename T > | |
constexpr bool | blaze::operator== (const NegativeAccuracy< A > &, const T &rhs) |
Equality comparison between a NegativeAccuracy object and a floating point value. More... | |
template<typename A , typename T > | |
constexpr bool | blaze::operator== (const T &lhs, const NegativeAccuracy< A > &) |
Equality comparison between a floating point value and a NegativeAccuracy object. More... | |
template<typename A , typename T > | |
constexpr bool | blaze::operator!= (const NegativeAccuracy< A > &, const T &rhs) |
Inequality comparison between a NegativeAccuracy object and a floating point value. More... | |
template<typename A , typename T > | |
constexpr bool | blaze::operator!= (const T &lhs, const NegativeAccuracy< A > &) |
Inequality comparison between a floating point value and a NegativeAccuracy object. More... | |
template<typename A , typename T > | |
constexpr bool | blaze::operator< (const NegativeAccuracy< A > &, const T &rhs) |
Less-than comparison between a NegativeAccuracy object and a floating point value. More... | |
template<typename A , typename T > | |
constexpr bool | blaze::operator< (const T &lhs, const NegativeAccuracy< A > &) |
Less-than comparison between a floating point value and a NegativeAccuracy object. More... | |
template<typename A , typename T > | |
constexpr bool | blaze::operator> (const NegativeAccuracy< A > &, const T &rhs) |
Greater-than comparison between a NegativeAccuracy object and a floating point value. More... | |
template<typename A , typename T > | |
constexpr bool | blaze::operator> (const T &lhs, const NegativeAccuracy< A > &) |
Greater-than comparison between a floating point value and a NegativeAccuracy object. More... | |
template<typename A , typename T > | |
constexpr bool | blaze::operator<= (const NegativeAccuracy< A > &, const T &rhs) |
Less-or-equal-than comparison between a NegativeAccuracy object and a floating point value. More... | |
template<typename A , typename T > | |
constexpr bool | blaze::operator<= (const T &lhs, const NegativeAccuracy< A > &) |
Less-or-equal-than comparison between a floating point value and a NegativeAccuracy object. More... | |
template<typename A , typename T > | |
constexpr bool | blaze::operator>= (const NegativeAccuracy< A > &, const T &rhs) |
Greater-or-equal-than comparison between a NegativeAccuracy object and a floating point value. More... | |
template<typename A , typename T > | |
constexpr bool | blaze::operator>= (const T &lhs, const NegativeAccuracy< A > &) |
Less-or-equal-than comparison between a floating point value and a NegativeAccuracy object. More... | |
NegativeEpsilon operators | |
template<typename E , typename T > | |
constexpr bool | blaze::operator== (const NegativeEpsilon< E > &, const T &rhs) |
Equality comparison between a NegativeEpsilon object and a floating point value. More... | |
template<typename E , typename T > | |
constexpr bool | blaze::operator== (const T &lhs, const NegativeEpsilon< E > &) |
Equality comparison between a floating point value and a NegativeEpsilon object. More... | |
template<typename E , typename T > | |
constexpr bool | blaze::operator!= (const NegativeEpsilon< E > &, const T &rhs) |
Inequality comparison between a NegativeEpsilon object and a floating point value. More... | |
template<typename E , typename T > | |
constexpr bool | blaze::operator!= (const T &lhs, const NegativeEpsilon< E > &) |
Inequality comparison between a floating point value and a NegativeEpsilon object. More... | |
template<typename E , typename T > | |
constexpr bool | blaze::operator< (const NegativeEpsilon< E > &, const T &rhs) |
Less-than comparison between a NegativeEpsilon object and a floating point value. More... | |
template<typename E , typename T > | |
constexpr bool | blaze::operator< (const T &lhs, const NegativeEpsilon< E > &) |
Less-than comparison between a floating point value and a NegativeEpsilon object. More... | |
template<typename E , typename T > | |
constexpr bool | blaze::operator> (const NegativeEpsilon< E > &, const T &rhs) |
Greater-than comparison between a NegativeEpsilon object and a floating point value. More... | |
template<typename E , typename T > | |
constexpr bool | blaze::operator> (const T &lhs, const NegativeEpsilon< E > &) |
Greater-than comparison between a floating point value and a NegativeEpsilon object. More... | |
template<typename E , typename T > | |
constexpr bool | blaze::operator<= (const NegativeEpsilon< E > &, const T &rhs) |
Less-or-equal-than comparison between a NegativeEpsilon object and a floating point value. More... | |
template<typename E , typename T > | |
constexpr bool | blaze::operator<= (const T &lhs, const NegativeEpsilon< E > &) |
Less-or-equal-than comparison between a floating point value and a NegativeEpsilon object. More... | |
template<typename E , typename T > | |
constexpr bool | blaze::operator>= (const NegativeEpsilon< E > &, const T &rhs) |
Greater-or-equal-than comparison between a NegativeEpsilon object and a floating point value. More... | |
template<typename E , typename T > | |
constexpr bool | blaze::operator>= (const T &lhs, const NegativeEpsilon< E > &) |
Less-or-equal-than comparison between a floating point value and a NegativeEpsilon object. More... | |
NegativeInfinity operators | |
template<typename I1 , typename I2 > | |
constexpr bool | blaze::operator== (const NegativeInfinity< I1 > &, const NegativeInfinity< I2 > &) |
Equality comparison between two NegativeInfinity objects. More... | |
template<typename I , typename T > | |
constexpr bool | blaze::operator== (const NegativeInfinity< I > &lhs, const T &rhs) |
Equality comparison between an NegativeInfinity object and a built-in data type. More... | |
template<typename I , typename T > | |
constexpr bool | blaze::operator== (const T &lhs, const NegativeInfinity< I > &rhs) |
Equality comparison between a built-in data type and an NegativeInfinity object. More... | |
template<typename I1 , typename I2 > | |
constexpr bool | blaze::operator!= (const NegativeInfinity< I1 > &, const NegativeInfinity< I2 > &) |
Inequality comparison between two NegativeInfinity objects. More... | |
template<typename I , typename T > | |
constexpr bool | blaze::operator!= (const NegativeInfinity< I > &lhs, const T &rhs) |
Inequality comparison between an NegativeInfinity object and a built-in data type. More... | |
template<typename I , typename T > | |
constexpr bool | blaze::operator!= (const T &lhs, const NegativeInfinity< I > &rhs) |
Inequality comparison between a built-in data type and an NegativeInfinity object. More... | |
DenseMatrixProxy global functions | |
template<typename PT , typename MT > | |
BLAZE_ALWAYS_INLINE DenseMatrixProxy< PT, MT >::Iterator | blaze::begin (const DenseMatrixProxy< PT, MT > &proxy, size_t i) |
Returns an iterator to the first element of row/column i of the represented matrix. More... | |
template<typename PT , typename MT > | |
BLAZE_ALWAYS_INLINE DenseMatrixProxy< PT, MT >::ConstIterator | blaze::cbegin (const DenseMatrixProxy< PT, MT > &proxy, size_t i) |
Returns an iterator to the first element of row/column i of the represented matrix. More... | |
template<typename PT , typename MT > | |
BLAZE_ALWAYS_INLINE DenseMatrixProxy< PT, MT >::Iterator | blaze::end (const DenseMatrixProxy< PT, MT > &proxy, size_t i) |
Returns an iterator just past the last element of row/column i of the represented matrix. More... | |
template<typename PT , typename MT > | |
BLAZE_ALWAYS_INLINE DenseMatrixProxy< PT, MT >::ConstIterator | blaze::cend (const DenseMatrixProxy< PT, MT > &proxy, size_t i) |
Returns an iterator just past the last element of row/column i of the represented matrix. More... | |
template<typename PT , typename MT > | |
BLAZE_ALWAYS_INLINE size_t | blaze::rows (const DenseMatrixProxy< PT, MT > &proxy) |
Returns the current number of rows of the represented matrix. More... | |
template<typename PT , typename MT > | |
BLAZE_ALWAYS_INLINE size_t | blaze::columns (const DenseMatrixProxy< PT, MT > &proxy) |
Returns the current number of columns of the represented matrix. More... | |
template<typename PT , typename MT > | |
BLAZE_ALWAYS_INLINE size_t | blaze::capacity (const DenseMatrixProxy< PT, MT > &proxy) |
Returns the maximum capacity of the represented matrix. More... | |
template<typename PT , typename MT > | |
BLAZE_ALWAYS_INLINE size_t | blaze::capacity (const DenseMatrixProxy< PT, MT > &proxy, size_t i) |
Returns the current capacity of the specified row/column of the represented matrix. More... | |
template<typename PT , typename MT > | |
BLAZE_ALWAYS_INLINE size_t | blaze::nonZeros (const DenseMatrixProxy< PT, MT > &proxy) |
Returns the number of non-zero elements in the represented matrix. More... | |
template<typename PT , typename MT > | |
BLAZE_ALWAYS_INLINE size_t | blaze::nonZeros (const DenseMatrixProxy< PT, MT > &proxy, size_t i) |
Returns the number of non-zero elements in the specified row/column of the represented matrix. More... | |
template<typename PT , typename MT > | |
BLAZE_ALWAYS_INLINE void | blaze::resize (const DenseMatrixProxy< PT, MT > &proxy, size_t m, size_t n, bool preserve) |
Changing the size of the represented matrix. More... | |
DenseVectorProxy global functions | |
template<typename PT , typename VT > | |
BLAZE_ALWAYS_INLINE DenseVectorProxy< PT, VT >::Iterator | blaze::begin (const DenseVectorProxy< PT, VT > &proxy) |
Returns an iterator to the first element of the represented vector. More... | |
template<typename PT , typename VT > | |
BLAZE_ALWAYS_INLINE DenseVectorProxy< PT, VT >::ConstIterator | blaze::cbegin (const DenseVectorProxy< PT, VT > &proxy) |
Returns an iterator to the first element of the represented vector. More... | |
template<typename PT , typename VT > | |
BLAZE_ALWAYS_INLINE DenseVectorProxy< PT, VT >::Iterator | blaze::end (const DenseVectorProxy< PT, VT > &proxy) |
Returns an iterator just past the last element of the represented vector. More... | |
template<typename PT , typename VT > | |
BLAZE_ALWAYS_INLINE DenseVectorProxy< PT, VT >::ConstIterator | blaze::cend (const DenseVectorProxy< PT, VT > &proxy) |
Returns an iterator just past the last element of the represented vector. More... | |
template<typename PT , typename VT > | |
BLAZE_ALWAYS_INLINE size_t | blaze::size (const DenseVectorProxy< PT, VT > &proxy) |
Returns the current size/dimension of the represented vector. More... | |
template<typename PT , typename VT > | |
BLAZE_ALWAYS_INLINE size_t | blaze::capacity (const DenseVectorProxy< PT, VT > &proxy) |
Returns the maximum capacity of the represented vector. More... | |
template<typename PT , typename VT > | |
BLAZE_ALWAYS_INLINE size_t | blaze::nonZeros (const DenseVectorProxy< PT, VT > &proxy) |
Returns the number of non-zero elements in the represented vector. More... | |
template<typename PT , typename VT > | |
BLAZE_ALWAYS_INLINE void | blaze::resize (const DenseVectorProxy< PT, VT > &proxy, size_t n, bool preserve) |
Changing the size of the represented vector. More... | |
Proxy operators | |
template<typename T , typename PT , typename RT > | |
decltype(auto) | blaze::operator+= (T &lhs, const Proxy< PT, RT > &rhs) |
Addition assignment of an object of different type with a Proxy object. More... | |
template<typename T , typename PT , typename RT > | |
decltype(auto) | blaze::operator-= (T &lhs, const Proxy< PT, RT > &rhs) |
Subtraction assignment of an object of different type with a Proxy object. More... | |
template<typename T , typename PT , typename RT > | |
decltype(auto) | blaze::operator*= (T &lhs, const Proxy< PT, RT > &rhs) |
Multiplication assignment of an object of different type with a Proxy object. More... | |
template<typename T , typename PT , typename RT > | |
decltype(auto) | blaze::operator/= (T &lhs, const Proxy< PT, RT > &rhs) |
Division assignment of an object of different type with a Proxy object. More... | |
template<typename PT1 , typename RT1 , typename PT2 , typename RT2 > | |
decltype(auto) | blaze::operator+ (const Proxy< PT1, RT1 > &lhs, const Proxy< PT2, RT2 > &rhs) |
Addition between two Proxy objects. More... | |
template<typename PT , typename RT , typename T , typename = DisableIf_t< IsProxy_v<T> >> | |
decltype(auto) | blaze::operator+ (const Proxy< PT, RT > &lhs, const T &rhs) |
Addition between a Proxy object and an object of different type. More... | |
template<typename T , typename PT , typename RT , typename = DisableIf_t< IsProxy_v<T> >> | |
decltype(auto) | blaze::operator+ (const T &lhs, const Proxy< PT, RT > &rhs) |
Addition between an object of different type and a Proxy object. More... | |
template<typename PT1 , typename RT1 , typename PT2 , typename RT2 > | |
decltype(auto) | blaze::operator- (const Proxy< PT1, RT1 > &lhs, const Proxy< PT2, RT2 > &rhs) |
Subtraction between two Proxy objects. More... | |
template<typename PT , typename RT , typename T , typename = DisableIf_t< IsProxy_v<T> >> | |
decltype(auto) | blaze::operator- (const Proxy< PT, RT > &lhs, const T &rhs) |
Subtraction between a Proxy object and an object of different type. More... | |
template<typename T , typename PT , typename RT , typename = DisableIf_t< IsProxy_v<T> >> | |
decltype(auto) | blaze::operator- (const T &lhs, const Proxy< PT, RT > &rhs) |
Subtraction between an object of different type and a Proxy object. More... | |
template<typename PT1 , typename RT1 , typename PT2 , typename RT2 > | |
decltype(auto) | blaze::operator* (const Proxy< PT1, RT1 > &lhs, const Proxy< PT2, RT2 > &rhs) |
Multiplication between two Proxy objects. More... | |
template<typename PT , typename RT , typename T , typename = DisableIf_t< IsProxy_v<T> >> | |
decltype(auto) | blaze::operator* (const Proxy< PT, RT > &lhs, const T &rhs) |
Multiplication between a Proxy object and an object of different type. More... | |
template<typename T , typename PT , typename RT , typename = DisableIf_t< IsProxy_v<T> >> | |
decltype(auto) | blaze::operator* (const T &lhs, const Proxy< PT, RT > &rhs) |
Multiplication between an object of different type and a Proxy object. More... | |
template<typename PT1 , typename RT1 , typename PT2 , typename RT2 > | |
decltype(auto) | blaze::operator/ (const Proxy< PT1, RT1 > &lhs, const Proxy< PT2, RT2 > &rhs) |
Division between two Proxy objects. More... | |
template<typename PT , typename RT , typename T , typename = DisableIf_t< IsProxy_v<T> >> | |
decltype(auto) | blaze::operator/ (const Proxy< PT, RT > &lhs, const T &rhs) |
Division between a Proxy object and an object of different type. More... | |
template<typename T , typename PT , typename RT , typename = DisableIf_t< IsProxy_v<T> >> | |
decltype(auto) | blaze::operator/ (const T &lhs, const Proxy< PT, RT > &rhs) |
Division between an object of different type and a Proxy object. More... | |
template<typename PT1 , typename RT1 , typename PT2 , typename RT2 > | |
bool | blaze::operator== (const Proxy< PT1, RT1 > &lhs, const Proxy< PT2, RT2 > &rhs) |
Equality comparison between two Proxy objects. More... | |
template<typename PT , typename RT , typename T , typename = DisableIf_t< IsProxy_v<T> >> | |
bool | blaze::operator== (const Proxy< PT, RT > &lhs, const T &rhs) |
Equality comparison between a Proxy object and an object of different type. More... | |
template<typename T , typename PT , typename RT , typename = DisableIf_t< IsProxy_v<T> >> | |
bool | blaze::operator== (const T &lhs, const Proxy< PT, RT > &rhs) |
Equality comparison between an object of different type and a Proxy object. More... | |
template<typename PT1 , typename RT1 , typename PT2 , typename RT2 > | |
bool | blaze::operator!= (const Proxy< PT1, RT1 > &lhs, const Proxy< PT2, RT2 > &rhs) |
Inequality comparison between two Proxy objects. More... | |
template<typename PT , typename RT , typename T , typename = DisableIf_t< IsProxy_v<T> >> | |
bool | blaze::operator!= (const Proxy< PT, RT > &lhs, const T &rhs) |
Inequality comparison between a Proxy object and an object of different type. More... | |
template<typename T , typename PT , typename RT , typename = DisableIf_t< IsProxy_v<T> >> | |
bool | blaze::operator!= (const T &lhs, const Proxy< PT, RT > &rhs) |
Inquality comparison between an object of different type and a Proxy object. More... | |
template<typename PT1 , typename RT1 , typename PT2 , typename RT2 > | |
bool | blaze::operator< (const Proxy< PT1, RT1 > &lhs, const Proxy< PT2, RT2 > &rhs) |
Less-than comparison between two Proxy objects. More... | |
template<typename PT , typename RT , typename T , typename = DisableIf_t< IsProxy_v<T> >> | |
bool | blaze::operator< (const Proxy< PT, RT > &lhs, const T &rhs) |
Less-than comparison between a Proxy object and an object of different type. More... | |
template<typename T , typename PT , typename RT , typename = DisableIf_t< IsProxy_v<T> >> | |
bool | blaze::operator< (const T &lhs, const Proxy< PT, RT > &rhs) |
Less-than comparison between an object of different type and a Proxy object. More... | |
template<typename PT1 , typename RT1 , typename PT2 , typename RT2 > | |
bool | blaze::operator> (const Proxy< PT1, RT1 > &lhs, const Proxy< PT2, RT2 > &rhs) |
Greater-than comparison between two Proxy objects. More... | |
template<typename PT , typename RT , typename T , typename = DisableIf_t< IsProxy_v<T> >> | |
bool | blaze::operator> (const Proxy< PT, RT > &lhs, const T &rhs) |
Greater-than comparison between a Proxy object and an object of different type. More... | |
template<typename T , typename PT , typename RT , typename = DisableIf_t< IsProxy_v<T> >> | |
bool | blaze::operator> (const T &lhs, const Proxy< PT, RT > &rhs) |
Greater-than comparison between an object of different type and a Proxy object. More... | |
template<typename PT1 , typename RT1 , typename PT2 , typename RT2 > | |
bool | blaze::operator<= (const Proxy< PT1, RT1 > &lhs, const Proxy< PT2, RT2 > &rhs) |
Less-or-equal-than comparison between two Proxy objects. More... | |
template<typename PT , typename RT , typename T , typename = DisableIf_t< IsProxy_v<T> >> | |
bool | blaze::operator<= (const Proxy< PT, RT > &lhs, const T &rhs) |
Less-or-equal-than comparison between a Proxy object and an object of different type. More... | |
template<typename T , typename PT , typename RT , typename = DisableIf_t< IsProxy_v<T> >> | |
bool | blaze::operator<= (const T &lhs, const Proxy< PT, RT > &rhs) |
Less-or-equal-than comparison between an object of different type and a Proxy object. More... | |
template<typename PT1 , typename RT1 , typename PT2 , typename RT2 > | |
bool | blaze::operator>= (const Proxy< PT1, RT1 > &lhs, const Proxy< PT2, RT2 > &rhs) |
Greater-or-equal-than comparison between two Proxy objects. More... | |
template<typename PT , typename RT , typename T , typename = DisableIf_t< IsProxy_v<T> >> | |
bool | blaze::operator>= (const Proxy< PT, RT > &lhs, const T &rhs) |
Greater-or-equal-than comparison between a Proxy object and an object of different type. More... | |
template<typename T , typename PT , typename RT , typename = DisableIf_t< IsProxy_v<T> >> | |
bool | blaze::operator>= (const T &lhs, const Proxy< PT, RT > &rhs) |
Greater-or-equal-than comparison between an object of different type and a Proxy object. More... | |
template<typename PT , typename RT > | |
std::ostream & | blaze::operator<< (std::ostream &os, const Proxy< PT, RT > &proxy) |
Global output operator for the Proxy class template. More... | |
Proxy global functions | |
template<typename PT , typename RT > | |
decltype(auto) | blaze::abs (const Proxy< PT, RT > &proxy) |
Computing the absolute value of the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | blaze::sign (const Proxy< PT, RT > &proxy) |
Evaluating the sign of the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | blaze::floor (const Proxy< PT, RT > &proxy) |
Computes the largest integral value that is not greater than the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | blaze::ceil (const Proxy< PT, RT > &proxy) |
Computes the smallest integral value that is not less than the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | blaze::trunc (const Proxy< PT, RT > &proxy) |
Computes the nearest integral value that is not greater than the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | blaze::round (const Proxy< PT, RT > &proxy) |
Computes the nearest integral value to the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | blaze::conj (const Proxy< PT, RT > &proxy) |
Computing the complex conjugate of the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | blaze::trans (const Proxy< PT, RT > &proxy) |
Computing the transpose of the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | blaze::ctrans (const Proxy< PT, RT > &proxy) |
Computing the conjugate transpose of the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | blaze::real (const Proxy< PT, RT > &proxy) |
Computing the real part of the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | blaze::imag (const Proxy< PT, RT > &proxy) |
Computing the imaginary part of the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | blaze::sqrt (const Proxy< PT, RT > &proxy) |
Computing the square root of the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | blaze::invsqrt (const Proxy< PT, RT > &proxy) |
Computing the inverse square root of the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | blaze::cbrt (const Proxy< PT, RT > &proxy) |
Computing the cubic root of the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | blaze::invcbrt (const Proxy< PT, RT > &proxy) |
Computing the inverse cubic root of the represented element. More... | |
template<typename PT1 , typename RT1 , typename PT2 , typename RT2 > | |
decltype(auto) | blaze::hypot (const Proxy< PT1, RT1 > &lhs, const Proxy< PT2, RT2 > &rhs) |
Computes the hypotenous of the two Proxy objects. More... | |
template<typename PT , typename RT , typename T , typename = DisableIf_t< IsProxy_v<T> >> | |
decltype(auto) | blaze::hypot (const Proxy< PT, RT > &lhs, const T &rhs) |
Computes the hypotenous of a Proxy object and an object of different type. More... | |
template<typename T , typename PT , typename RT , typename = DisableIf_t< IsProxy_v<T> >> | |
decltype(auto) | blaze::hypot (const T &lhs, const Proxy< PT, RT > &rhs) |
Computes the hypotenous of an object of different type and a Proxy object. More... | |
template<typename PT , typename RT , typename ET > | |
decltype(auto) | blaze::pow (const Proxy< PT, RT > &proxy, const ET &exp) |
Computing the exponential value of the represented element. More... | |
template<typename PT , typename RT , typename ET > | |
decltype(auto) | blaze::pow2 (const Proxy< PT, RT > &proxy) |
Computing the square value of the represented element. More... | |
template<typename PT , typename RT , typename ET > | |
decltype(auto) | blaze::pow3 (const Proxy< PT, RT > &proxy) |
Computing the cube value of the represented element. More... | |
template<typename PT , typename RT , typename ET > | |
decltype(auto) | blaze::pow4 (const Proxy< PT, RT > &proxy) |
Computing the quadruple value of the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | blaze::exp (const Proxy< PT, RT > &proxy) |
Computing the base-e exponential of the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | blaze::exp2 (const Proxy< PT, RT > &proxy) |
Computing the base-2 exponential of the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | blaze::exp10 (const Proxy< PT, RT > &proxy) |
Computing the base-10 exponential of the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | blaze::log (const Proxy< PT, RT > &proxy) |
Computing the natural logarithm of the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | blaze::log2 (const Proxy< PT, RT > &proxy) |
Computing the binary logarithm of the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | blaze::log10 (const Proxy< PT, RT > &proxy) |
Computing the common logarithm of the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | blaze::log1p (const Proxy< PT, RT > &proxy) |
Computing the natural logarithm of x+1 of the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | blaze::lgamma (const Proxy< PT, RT > &proxy) |
Computing the natural logarithm of the absolute value of the gamma function of the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | blaze::sin (const Proxy< PT, RT > &proxy) |
Computing the sine of the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | blaze::asin (const Proxy< PT, RT > &proxy) |
Computing the inverse sine of the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | blaze::sinh (const Proxy< PT, RT > &proxy) |
Computing the hyperbolic sine of the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | blaze::asinh (const Proxy< PT, RT > &proxy) |
Computing the inverse hyperbolic sine of the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | blaze::cos (const Proxy< PT, RT > &proxy) |
Computing the cosine of the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | blaze::acos (const Proxy< PT, RT > &proxy) |
Computing the inverse cosine of the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | blaze::cosh (const Proxy< PT, RT > &proxy) |
Computing the hyperbolic cosine of the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | blaze::acosh (const Proxy< PT, RT > &proxy) |
Computing the inverse hyperbolic cosine of the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | blaze::tan (const Proxy< PT, RT > &proxy) |
Computing the tangent of the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | blaze::atan (const Proxy< PT, RT > &proxy) |
Computing the inverse tangent of the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | blaze::tanh (const Proxy< PT, RT > &proxy) |
Computing the hyperbolic tangent of the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | blaze::atanh (const Proxy< PT, RT > &proxy) |
Computing the inverse hyperbolic tangent of the represented element. More... | |
template<typename PT1 , typename RT1 , typename PT2 , typename RT2 > | |
decltype(auto) | blaze::atan2 (const Proxy< PT1, RT1 > &lhs, const Proxy< PT2, RT2 > &rhs) |
Computes the multi-valued inverse tangent of two Proxy objects. More... | |
template<typename PT , typename RT , typename T , typename = DisableIf_t< IsProxy_v<T> >> | |
decltype(auto) | blaze::atan2 (const Proxy< PT, RT > &lhs, const T &rhs) |
Computes the multi-valued inverse tangent of a Proxy object and an object of different type. More... | |
template<typename T , typename PT , typename RT , typename = DisableIf_t< IsProxy_v<T> >> | |
decltype(auto) | blaze::atan2 (const T &lhs, const Proxy< PT, RT > &rhs) |
Computes the multi-valued inverse tangent of an object of different type and a Proxy object. More... | |
template<typename PT , typename RT > | |
decltype(auto) | blaze::erf (const Proxy< PT, RT > &proxy) |
Computing the error function of the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | blaze::erfc (const Proxy< PT, RT > &proxy) |
Computing the complementary error function of the represented element. More... | |
template<typename PT , typename RT > | |
void | blaze::reset (const Proxy< PT, RT > &proxy) |
Resetting the represented element to the default initial values. More... | |
template<typename PT , typename RT > | |
void | blaze::reset (const Proxy< PT, RT > &proxy, size_t i) |
Reset the specified row/column of the represented matrix. More... | |
template<typename PT , typename RT > | |
void | blaze::clear (const Proxy< PT, RT > &proxy) |
Clearing the represented element. More... | |
template<typename PT , typename RT > | |
void | blaze::transpose (const Proxy< PT, RT > &proxy) |
In-place transpose of the represented matrix element. More... | |
template<typename PT , typename RT > | |
void | blaze::ctranspose (const Proxy< PT, RT > &proxy) |
In-place conjugate transpose of the represented matrix element. More... | |
template<typename PT , typename RT > | |
void | blaze::invert (const Proxy< PT, RT > &proxy) |
In-place inversion of the represented element. More... | |
template<InversionFlag IF, typename PT , typename RT > | |
void | blaze::invert (const Proxy< PT, RT > &proxy) |
In-place inversion of the represented element. More... | |
template<RelaxationFlag RF, typename PT , typename RT > | |
bool | blaze::isDefault (const Proxy< PT, RT > &proxy) |
Returns whether the represented element is in default state. More... | |
template<RelaxationFlag RF, typename PT , typename RT > | |
bool | blaze::isReal (const Proxy< PT, RT > &proxy) |
Returns whether the element represents a real number. More... | |
template<RelaxationFlag RF, typename PT , typename RT > | |
bool | blaze::isZero (const Proxy< PT, RT > &proxy) |
Returns whether the represented element is 0. More... | |
template<RelaxationFlag RF, typename PT , typename RT > | |
bool | blaze::isOne (const Proxy< PT, RT > &proxy) |
Returns whether the represented element is 1. More... | |
template<typename PT , typename RT > | |
bool | blaze::isnan (const Proxy< PT, RT > &proxy) |
Returns whether the represented element is not-a-number. More... | |
template<typename PT , typename RT > | |
bool | blaze::isinf (const Proxy< PT, RT > &proxy) |
Returns whether the represented element is infinite. More... | |
template<typename PT , typename RT > | |
bool | blaze::isfinite (const Proxy< PT, RT > &proxy) |
Returns whether the represented element is finite. More... | |
template<RelaxationFlag RF, typename PT1 , typename RT1 , typename PT2 , typename RT2 > | |
bool | blaze::equal (const Proxy< PT1, RT1 > &lhs, const Proxy< PT2, RT2 > &rhs) |
Equality comparison between two Proxy objects. More... | |
template<RelaxationFlag RF, typename PT , typename RT , typename T , typename = DisableIf_t< IsProxy_v<T> >> | |
bool | blaze::equal (const Proxy< PT, RT > &lhs, const T &rhs) |
Equality comparison between a Proxy object and an object of different type. More... | |
template<RelaxationFlag RF, typename T , typename PT , typename RT , typename = DisableIf_t< IsProxy_v<T> >> | |
bool | blaze::equal (const T &lhs, const Proxy< PT, RT > &rhs) |
Equality comparison between an object of different type and a Proxy object. More... | |
template<typename PT , typename RT > | |
decltype(auto) | blaze::evaluate (const Proxy< PT, RT > &proxy) |
Returns whether the represented element is finite. More... | |
template<typename PT , typename RT > | |
decltype(auto) | blaze::pow2 (const Proxy< PT, RT > &proxy) |
template<typename PT , typename RT > | |
decltype(auto) | blaze::pow3 (const Proxy< PT, RT > &proxy) |
template<typename PT , typename RT > | |
decltype(auto) | blaze::pow4 (const Proxy< PT, RT > &proxy) |
SparseMatrixProxy global functions | |
template<typename PT , typename MT > | |
BLAZE_ALWAYS_INLINE SparseMatrixProxy< PT, MT >::Iterator | blaze::begin (const SparseMatrixProxy< PT, MT > &proxy, size_t i) |
Returns an iterator to the first element of row/column i of the represented matrix. More... | |
template<typename PT , typename MT > | |
BLAZE_ALWAYS_INLINE SparseMatrixProxy< PT, MT >::ConstIterator | blaze::cbegin (const SparseMatrixProxy< PT, MT > &proxy, size_t i) |
Returns an iterator to the first element of row/column i of the represented matrix. More... | |
template<typename PT , typename MT > | |
BLAZE_ALWAYS_INLINE SparseMatrixProxy< PT, MT >::Iterator | blaze::end (const SparseMatrixProxy< PT, MT > &proxy, size_t i) |
Returns an iterator just past the last element of row/column i of the represented matrix. More... | |
template<typename PT , typename MT > | |
BLAZE_ALWAYS_INLINE SparseMatrixProxy< PT, MT >::ConstIterator | blaze::cend (const SparseMatrixProxy< PT, MT > &proxy, size_t i) |
Returns an iterator just past the last element of row/column i of the represented matrix. More... | |
template<typename PT , typename MT > | |
BLAZE_ALWAYS_INLINE size_t | blaze::rows (const SparseMatrixProxy< PT, MT > &proxy) |
Returns the current number of rows of the represented matrix. More... | |
template<typename PT , typename MT > | |
BLAZE_ALWAYS_INLINE size_t | blaze::columns (const SparseMatrixProxy< PT, MT > &proxy) |
Returns the current number of columns of the represented matrix. More... | |
template<typename PT , typename MT > | |
BLAZE_ALWAYS_INLINE size_t | blaze::capacity (const SparseMatrixProxy< PT, MT > &proxy) |
Returns the maximum capacity of the represented matrix. More... | |
template<typename PT , typename MT > | |
BLAZE_ALWAYS_INLINE size_t | blaze::capacity (const SparseMatrixProxy< PT, MT > &proxy, size_t i) |
Returns the current capacity of the specified row/column of the represented matrix. More... | |
template<typename PT , typename MT > | |
BLAZE_ALWAYS_INLINE size_t | blaze::nonZeros (const SparseMatrixProxy< PT, MT > &proxy) |
Returns the number of non-zero elements in the represented matrix. More... | |
template<typename PT , typename MT > | |
BLAZE_ALWAYS_INLINE size_t | blaze::nonZeros (const SparseMatrixProxy< PT, MT > &proxy, size_t i) |
Returns the number of non-zero elements in the specified row/column of the represented matrix. More... | |
template<typename PT , typename MT > | |
BLAZE_ALWAYS_INLINE void | blaze::resize (const SparseMatrixProxy< PT, MT > &proxy, size_t m, size_t n, bool preserve) |
Changing the size of the represented matrix. More... | |
template<typename PT , typename MT > | |
BLAZE_ALWAYS_INLINE SparseMatrixProxy< PT, MT >::Iterator | blaze::find (const SparseMatrixProxy< PT, MT > &proxy, size_t i, size_t j) |
Searches for a specific matrix element. More... | |
template<typename PT , typename MT > | |
BLAZE_ALWAYS_INLINE SparseMatrixProxy< PT, MT >::Iterator | blaze::lowerBound (const SparseMatrixProxy< PT, MT > &proxy, size_t i, size_t j) |
Returns an iterator to the first index not less than the given index. More... | |
template<typename PT , typename MT > | |
BLAZE_ALWAYS_INLINE SparseMatrixProxy< PT, MT >::Iterator | blaze::upperBound (const SparseMatrixProxy< PT, MT > &proxy, size_t i, size_t j) |
Returns an iterator to the first index greater than the given index. More... | |
SparseVectorProxy global functions | |
template<typename PT , typename VT > | |
BLAZE_ALWAYS_INLINE SparseVectorProxy< PT, VT >::Iterator | blaze::begin (const SparseVectorProxy< PT, VT > &proxy) |
Returns an iterator to the first element of the represented vector. More... | |
template<typename PT , typename VT > | |
BLAZE_ALWAYS_INLINE SparseVectorProxy< PT, VT >::ConstIterator | blaze::cbegin (const SparseVectorProxy< PT, VT > &proxy) |
Returns an iterator to the first element of the represented vector. More... | |
template<typename PT , typename VT > | |
BLAZE_ALWAYS_INLINE SparseVectorProxy< PT, VT >::Iterator | blaze::end (const SparseVectorProxy< PT, VT > &proxy) |
Returns an iterator just past the last element of the represented vector. More... | |
template<typename PT , typename VT > | |
BLAZE_ALWAYS_INLINE SparseVectorProxy< PT, VT >::ConstIterator | blaze::cend (const SparseVectorProxy< PT, VT > &proxy) |
Returns an iterator just past the last element of the represented vector. More... | |
template<typename PT , typename VT > | |
BLAZE_ALWAYS_INLINE size_t | blaze::size (const SparseVectorProxy< PT, VT > &proxy) |
Returns the current size/dimension of the represented vector. More... | |
template<typename PT , typename VT > | |
BLAZE_ALWAYS_INLINE size_t | blaze::capacity (const SparseVectorProxy< PT, VT > &proxy) |
Returns the maximum capacity of the represented vector. More... | |
template<typename PT , typename VT > | |
BLAZE_ALWAYS_INLINE size_t | blaze::nonZeros (const SparseVectorProxy< PT, VT > &proxy) |
Returns the number of non-zero elements in the represented vector. More... | |
template<typename PT , typename VT > | |
BLAZE_ALWAYS_INLINE void | blaze::resize (const SparseVectorProxy< PT, VT > &proxy, size_t n, bool preserve) |
Changing the size of the represented vector. More... | |
template<typename PT , typename VT > | |
BLAZE_ALWAYS_INLINE SparseVectorProxy< PT, VT >::Iterator | blaze::find (const SparseVectorProxy< PT, VT > &proxy, size_t index) |
Searches for a specific sparse vector element. More... | |
template<typename PT , typename VT > | |
BLAZE_ALWAYS_INLINE SparseVectorProxy< PT, VT >::Iterator | blaze::lowerBound (const SparseVectorProxy< PT, VT > &proxy, size_t index) |
Returns an iterator to the first index not less then the given index. More... | |
template<typename PT , typename VT > | |
BLAZE_ALWAYS_INLINE SparseVectorProxy< PT, VT >::Iterator | blaze::upperBound (const SparseVectorProxy< PT, VT > &proxy, size_t index) |
Returns an iterator to the first index greater then the given index. More... | |
#define BLAZE_THROW_DIVISION_BY_ZERO | ( | MESSAGE | ) | BLAZE_THROW_RUNTIME_ERROR( MESSAGE ) |
Macro for the emission of an exception on detection of a division by zero.
This macro encapsulates the default way of Blaze to throw an exception on detection of a division by zero. Also, since it may be desirable to replace the type of exception by a custom exception type this macro provides an opportunity to customize the behavior.
The macro excepts a single argument, which specifies the message of the exception:
In order to customize the type of exception all that needs to be done is to define the macro prior to including any Blaze header file. This will override the Blaze default behavior. The following example demonstrates this by replacing std::runtime_error by a custom exception type:
#define BLAZE_THROW_LAPACK_ERROR | ( | MESSAGE | ) | BLAZE_THROW_RUNTIME_ERROR( MESSAGE ) |
Macro for the emission of an exception on detection of a LAPACK error.
This macro encapsulates the default way of Blaze to throw an exception when encountering a LAPACK error (for instance when trying to invert a singular matrix). Also, since it may be desirable to replace the type of exception by a custom exception type this macro provides an opportunity to customize the behavior.
The macro excepts a single argument, which specifies the message of the exception:
In order to customize the type of exception all that needs to be done is to define the macro prior to including any Blaze header file. This will override the Blaze default behavior. The following example demonstrates this by replacing std::runtime_error by a custom exception type:
enum blaze::AlignmentFlag : bool |
Alignment flag for (un-)aligned vectors and matrices.
Via these flags it is possible to specify subvectors, submatrices, custom vectors and matrices as unaligned or aligned. The following example demonstrates the setup of an unaligned subvector:
Enumerator | |
---|---|
unaligned | Flag for unaligned vectors and matrices. |
aligned | Flag for aligned vectors and matrices. |
enum blaze::InversionFlag |
Inversion flag.
The InversionFlag type enumeration represents the different types of matrix inversion algorithms that are available within the Blaze library. The following flags are available:
byLU:
The default inversion algorithm for general square matrices. It uses the LU algorithm to decompose a matrix into a lower unitriangular matrix L
, an upper triangular matrix U
, and a permutation matrix P
( P
is the identity matrix.byLDLT:
The Bunch-Kaufman inversion algorithm for symmetric indefinite matrices. It decomposes the given matrix into either U
(or L
) is a product of permutation and unit upper (lower) triangular matrices, and D
is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks.byLDLH:
The Bunch-Kaufman inversion algorithm for Hermitian indefinite matrices. It decomposes the given matrix into either U
(or L
) is a product of permutation and unit upper (lower) triangular matrices, and D
is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks.byLLH:
The Cholesky inversion algorithm for Hermitian positive definite matrices. It decomposes a given matrix into either L
is a lower triangular matrix, or U
is an upper triangular matrix.Alternatively, the type of the matrix can be specified, leaving it to the Blaze library to select the appropriate matrix inversion algorithm. The following flags are available:
asGeneral:
This flag selects the best suited inversion algorithm for general square matrices. In case no further compile time information is available, this will imply the use of the LU decomposition algorithm (see the byLU
flag).asSymmetric:
This flag selects the most suited inversion algorithm for symmetric matrices. In case no further compile time information is available, the Bunch-Kaufman matrix decomposition algorithm will be used (see the byLDLT
flag).asHermitian:
This flag selects the most suited inversion algorithm for Hermitian matrices. In case no further compile time information is available, the Bunch-Kaufman matrix decomposition algorithm will be used (see the byLDLH
flag).asLower:
This flag selects the most suited inversion algorithm for lower triangular matrices. In case no further compile time information is available, the inversion will be performed by a forward substitution. No matrix decomposition will be performed.asUniLower:
This flag selects the most suited inversion algorithm for lower unitriangular matrices. In case no further compile time information is available, the inversion will be performed by a forward substitution. No matrix decomposition will be performed.asUpper:
This flag selects the most suited inversion algorithm for upper triangular matrices. In case no further compile time information is available, the inversion will be performed by a back substitution. No matrix decomposition will be performed.asUniUpper:
This flag selects the most suited inversion algorithm for upper unitriangular matrices. In case no further compile time information is available, the inversion will be performed by a back substitution. No matrix decomposition will be performed.asDiagonal:
This flag selects the most suited inversion algorithm for diagonal matrices. In case no further compile time information is available, the inversion will be performed by directly computing the reciprocal of each diagonal element. No matrix decomposition will be performed. enum blaze::PaddingFlag : bool |
Padding flag for (un-)padded vectors and matrices.
Via these flags it is possible to specify custom vectors and matrices as unpadded or padded. The following examples demonstrate the setup of an unaligned, unpadded and aligned, padded custom column vector of size 7, respectively:
Enumerator | |
---|---|
unpadded | Flag for unpadded vectors and matrices. |
padded | Flag for padded vectors and matrices. |
enum blaze::RelaxationFlag : bool |
Relaxation flag for strict or relaxed semantics.
Via these flags it is possible to specify that according operations should use strict semantics instead of relaxed semantics or vice versa. The following example demonstrates this by means of the isDefault() function template:
Enumerator | |
---|---|
strict | Flag for strict semantics. |
relaxed | Flag for relaxed semantics. |
|
inline |
Computing the absolute value of the represented element.
proxy | The given proxy instance. |
This function computes the absolute value of the element represented by the proxy. In case the proxy represents a vector- or matrix-like data structure the function returns an expression representing the absolute values of the elements of the vector/matrix.
|
inline |
Computing the inverse cosine of the represented element.
proxy | The given proxy instance. |
This function computes the inverse cosine of the element represented by the proxy. In case the proxy represents a vector- or matrix-like data structure the function returns an expression representing the inverse cosines of the elements of the vector/matrix.
|
inline |
Computing the inverse hyperbolic cosine of the represented element.
proxy | The given proxy instance. |
This function computes the inverse hyperbolic cosine of the element represented by the proxy. In case the proxy represents a vector- or matrix-like data structure the function returns an expression representing the inverse hyperbolic cosines of the elements of the vector/matrix.
|
inline |
Computing the inverse sine of the represented element.
proxy | The given proxy instance. |
This function computes the inverse sine of the element represented by the proxy. In case the proxy represents a vector- or matrix-like data structure the function returns an expression representing the inverse sines of the elements of the vector/matrix.
|
inline |
Computing the inverse hyperbolic sine of the represented element.
proxy | The given proxy instance. |
This function computes the inverse hyperbolic sine of the element represented by the proxy. In case the proxy represents a vector- or matrix-like data structure the function returns an expression representing the inverse hyperbolic sines of the elements of the vector/matrix.
|
inline |
Computing the inverse tangent of the represented element.
proxy | The given proxy instance. |
This function computes the inverse tangent of the element represented by the proxy. In case the proxy represents a vector- or matrix-like data structure the function returns an expression representing the inverse tangents of the elements of the vector/matrix.
|
inline |
Computes the multi-valued inverse tangent of a Proxy object and an object of different type.
lhs | The left-hand side Proxy object. |
rhs | The right-hand side object of other type. |
This function computes the multi-valued inverse tangent of the element represented by the proxy lhs and the object rhs. In case the objects represent vector- or matrix-like data structures the function returns an expression representing the multi-valued inverse tangent of the elements of the vectors/matrices.
|
inline |
Computes the multi-valued inverse tangent of two Proxy objects.
This function computes the multi-valued inverse tangent of the elements represented by the two proxies lhs and rhs. In case the objects represent vector- or matrix-like data structures the function returns an expression representing the multi-valued inverse tangent of the elements of the vectors/matrices.
|
inline |
Computes the multi-valued inverse tangent of an object of different type and a Proxy object.
lhs | The left-hand side object of other type. |
rhs | The right-hand side Proxy object. |
This function computes the multi-valued inverse tangent of the element represented by the object lhs and the proxy rhs. In case the objects represent vector- or matrix-like data structures the function returns an expression representing the multi-valued inverse tangent of the elements of the vectors/matrices.
|
inline |
Computing the inverse hyperbolic tangent of the represented element.
proxy | The given proxy instance. |
This function computes the inverse hyperbolic tangent of the element represented by the proxy. In case the proxy represents a vector- or matrix-like data structure the function returns an expression representing the inverse hyperbolic tangents of the elements of the vector/matrix.
BLAZE_ALWAYS_INLINE DenseMatrixProxy< PT, MT >::Iterator blaze::begin | ( | const DenseMatrixProxy< PT, MT > & | proxy, |
size_t | i | ||
) |
Returns an iterator to the first element of row/column i of the represented matrix.
proxy | The given access proxy. |
i | The row/column index. |
This function returns a row/column iterator to the first element of row/column i. In case the given matrix is a row-major matrix the function returns an iterator to the first element of row i, in case it is a column-major matrix the function returns an iterator to the first element of column i.
BLAZE_ALWAYS_INLINE DenseVectorProxy< PT, VT >::Iterator blaze::begin | ( | const DenseVectorProxy< PT, VT > & | proxy | ) |
Returns an iterator to the first element of the represented vector.
proxy | The given access proxy. |
BLAZE_ALWAYS_INLINE SparseMatrixProxy< PT, MT >::Iterator blaze::begin | ( | const SparseMatrixProxy< PT, MT > & | proxy, |
size_t | i | ||
) |
Returns an iterator to the first element of row/column i of the represented matrix.
proxy | The given access proxy. |
i | The row/column index. |
This function returns a row/column iterator to the first element of row/column i. In case the given matrix is a row-major matrix the function returns an iterator to the first element of row i, in case it is a column-major matrix the function returns an iterator to the first element of column i.
BLAZE_ALWAYS_INLINE SparseVectorProxy< PT, VT >::Iterator blaze::begin | ( | const SparseVectorProxy< PT, VT > & | proxy | ) |
Returns an iterator to the first element of the represented vector.
proxy | The given access proxy. |
BLAZE_ALWAYS_INLINE size_t blaze::capacity | ( | const DenseMatrixProxy< PT, MT > & | proxy | ) |
Returns the maximum capacity of the represented matrix.
proxy | The given access proxy. |
BLAZE_ALWAYS_INLINE size_t blaze::capacity | ( | const DenseMatrixProxy< PT, MT > & | proxy, |
size_t | i | ||
) |
Returns the current capacity of the specified row/column of the represented matrix.
proxy | The given access proxy. |
i | The index of the row/column. |
This function returns the current capacity of the specified row/column. In case the storage order is set to rowMajor the function returns the capacity of row i, in case the storage flag is set to columnMajor the function returns the capacity of column i.
BLAZE_ALWAYS_INLINE size_t blaze::capacity | ( | const DenseVectorProxy< PT, VT > & | proxy | ) |
Returns the maximum capacity of the represented vector.
proxy | The given access proxy. |
BLAZE_ALWAYS_INLINE size_t blaze::capacity | ( | const SparseMatrixProxy< PT, MT > & | proxy | ) |
Returns the maximum capacity of the represented matrix.
proxy | The given access proxy. |
BLAZE_ALWAYS_INLINE size_t blaze::capacity | ( | const SparseMatrixProxy< PT, MT > & | proxy, |
size_t | i | ||
) |
Returns the current capacity of the specified row/column of the represented matrix.
proxy | The given access proxy. |
i | The index of the row/column. |
This function returns the current capacity of the specified row/column. In case the storage order is set to rowMajor the function returns the capacity of row i, in case the storage flag is set to columnMajor the function returns the capacity of column i.
BLAZE_ALWAYS_INLINE size_t blaze::capacity | ( | const SparseVectorProxy< PT, VT > & | proxy | ) |
Returns the maximum capacity of the represented vector.
proxy | The given access proxy. |
BLAZE_ALWAYS_INLINE DenseMatrixProxy< PT, MT >::ConstIterator blaze::cbegin | ( | const DenseMatrixProxy< PT, MT > & | proxy, |
size_t | i | ||
) |
Returns an iterator to the first element of row/column i of the represented matrix.
proxy | The given access proxy. |
i | The row/column index. |
This function returns a row/column iterator to the first element of row/column i. In case the given matrix is a row-major matrix the function returns an iterator to the first element of row i, in case it is a column-major matrix the function returns an iterator to the first element of column i.
BLAZE_ALWAYS_INLINE DenseVectorProxy< PT, VT >::ConstIterator blaze::cbegin | ( | const DenseVectorProxy< PT, VT > & | proxy | ) |
Returns an iterator to the first element of the represented vector.
proxy | The given access proxy. |
BLAZE_ALWAYS_INLINE SparseMatrixProxy< PT, MT >::ConstIterator blaze::cbegin | ( | const SparseMatrixProxy< PT, MT > & | proxy, |
size_t | i | ||
) |
Returns an iterator to the first element of row/column i of the represented matrix.
proxy | The given access proxy. |
i | The row/column index. |
This function returns a row/column iterator to the first element of row/column i. In case the given matrix is a row-major matrix the function returns an iterator to the first element of row i, in case it is a column-major matrix the function returns an iterator to the first element of column i.
BLAZE_ALWAYS_INLINE SparseVectorProxy< PT, VT >::ConstIterator blaze::cbegin | ( | const SparseVectorProxy< PT, VT > & | proxy | ) |
Returns an iterator to the first element of the represented vector.
proxy | The given access proxy. |
|
inline |
Computing the cubic root of the represented element.
proxy | The given proxy instance. |
This function computes the cubic root of the element represented by the proxy. In case the proxy represents a vector- or matrix-like data structure the function returns an expression representing the cubic roots of the elements of the vector/matrix.
|
inline |
Computes the smallest integral value that is not less than the represented element.
proxy | The given proxy instance. |
This function computes the smallest integral value that is not less than the element represented by the proxy. In case the proxy represents a vector- or matrix-like data structure the function returns an expression representing the operation.
BLAZE_ALWAYS_INLINE DenseMatrixProxy< PT, MT >::ConstIterator blaze::cend | ( | const DenseMatrixProxy< PT, MT > & | proxy, |
size_t | i | ||
) |
Returns an iterator just past the last element of row/column i of the represented matrix.
proxy | The given access proxy. |
i | The row/column index. |
In case the access proxy represents a matrix-like data structure that provides a cend() function, this function returns an iterator just past the last element of row/column i of the matrix. In case the given matrix is a row-major matrix the function returns an iterator just past the last element of row i, in case it is a column-major matrix the function returns an iterator just past the last element of column i.
BLAZE_ALWAYS_INLINE DenseVectorProxy< PT, VT >::ConstIterator blaze::cend | ( | const DenseVectorProxy< PT, VT > & | proxy | ) |
Returns an iterator just past the last element of the represented vector.
proxy | The given access proxy. |
BLAZE_ALWAYS_INLINE SparseMatrixProxy< PT, MT >::ConstIterator blaze::cend | ( | const SparseMatrixProxy< PT, MT > & | proxy, |
size_t | i | ||
) |
Returns an iterator just past the last element of row/column i of the represented matrix.
proxy | The given access proxy. |
i | The row/column index. |
In case the access proxy represents a matrix-like data structure that provides a cend() function, this function returns an iterator just past the last element of row/column i of the matrix. In case the given matrix is a row-major matrix the function returns an iterator just past the last element of row i, in case it is a column-major matrix the function returns an iterator just past the last element of column i.
BLAZE_ALWAYS_INLINE SparseVectorProxy< PT, VT >::ConstIterator blaze::cend | ( | const SparseVectorProxy< PT, VT > & | proxy | ) |
Returns an iterator just past the last element of the represented vector.
proxy | The given access proxy. |
|
inline |
Clearing the represented element.
proxy | The given proxy instance. |
BLAZE_ALWAYS_INLINE size_t blaze::columns | ( | const DenseMatrixProxy< PT, MT > & | proxy | ) |
Returns the current number of columns of the represented matrix.
proxy | The given access proxy. |
BLAZE_ALWAYS_INLINE size_t blaze::columns | ( | const SparseMatrixProxy< PT, MT > & | proxy | ) |
Returns the current number of columns of the represented matrix.
proxy | The given access proxy. |
|
inline |
Computing the complex conjugate of the represented element.
proxy | The given proxy instance. |
This function computes the complex conjugate of the element represented by the proxy. In case the proxy represents a vector- or matrix-like data structure the function returns an expression representing the complex conjugate of the vector/matrix.
|
inline |
Computing the cosine of the represented element.
proxy | The given proxy instance. |
This function computes the cosine of the element represented by the proxy. In case the proxy represents a vector- or matrix-like data structure the function returns an expression representing the cosines of the elements of the vector/matrix.
|
inline |
Computing the hyperbolic cosine of the represented element.
proxy | The given proxy instance. |
This function computes the hyperbolic cosine of the element represented by the proxy. In case the proxy represents a vector- or matrix-like data structure the function returns an expression representing the hyperbolic cosines of the elements of the vector/matrix.
|
inline |
Computing the conjugate transpose of the represented element.
proxy | The given proxy instance. |
This function returns an expression representing the conjugate transpose of the element represented by the proxy.
|
inline |
In-place conjugate transpose of the represented matrix element.
proxy | The given proxy instance. |
std::invalid_argument | Invalid access to restricted element. |
std::logic_error | Matrix cannot be transposed. |
This function transposes the represented matrix in-place. The transpose operation fails if ...
In all failure cases a std::logic_error exception is thrown. Additionally, in case the represented matrix cannot be modified, a std::invalid_argument exception is thrown.
|
constexprnoexcept |
Determines the maximum number of columns specified by the given initializer list.
list | The given initializer list |
BLAZE_ALWAYS_INLINE DenseMatrixProxy< PT, MT >::Iterator blaze::end | ( | const DenseMatrixProxy< PT, MT > & | proxy, |
size_t | i | ||
) |
Returns an iterator just past the last element of row/column i of the represented matrix.
proxy | The given access proxy. |
i | The row/column index. |
In case the access proxy represents a matrix-like data structure that provides an end() function, this function returns an iterator just past the last element of row/column i of the matrix. In case the given matrix is a row-major matrix the function returns an iterator just past the last element of row i, in case it is a column-major matrix the function returns an iterator just past the last element of column i.
BLAZE_ALWAYS_INLINE DenseVectorProxy< PT, VT >::Iterator blaze::end | ( | const DenseVectorProxy< PT, VT > & | proxy | ) |
Returns an iterator just past the last element of the represented vector.
proxy | The given access proxy. |
BLAZE_ALWAYS_INLINE SparseMatrixProxy< PT, MT >::Iterator blaze::end | ( | const SparseMatrixProxy< PT, MT > & | proxy, |
size_t | i | ||
) |
Returns an iterator just past the last element of row/column i of the represented matrix.
proxy | The given access proxy. |
i | The row/column index. |
In case the access proxy represents a matrix-like data structure that provides an end() function, this function returns an iterator just past the last element of row/column i of the matrix. In case the given matrix is a row-major matrix the function returns an iterator just past the last element of row i, in case it is a column-major matrix the function returns an iterator just past the last element of column i.
BLAZE_ALWAYS_INLINE SparseVectorProxy< PT, VT >::Iterator blaze::end | ( | const SparseVectorProxy< PT, VT > & | proxy | ) |
Returns an iterator just past the last element of the represented vector.
proxy | The given access proxy. |
|
inline |
|
inline |
|
inline |
|
inline |
Computing the error function of the represented element.
proxy | The given proxy instance. |
This function computes the error function of the element represented by the proxy. In case the proxy represents a vector- or matrix-like data structure the function returns an expression representing the error functions of the elements of the vector/matrix.
|
inline |
Computing the complementary error function of the represented element.
proxy | The given proxy instance. |
This function computes the complementary error function of the element represented by the proxy. In case the proxy represents a vector- or matrix-like data structure the function returns an expression representing the complementary error functions of the elements of the vector/matrix.
|
inline |
Returns whether the represented element is finite.
proxy | The given proxy instance. |
This function checks whether the element represented by the proxy is finite (i.e. normal, subnormal or zero elements, but not infinite or NaN). In case it is finite, the function returns true, otherwise it returns false.
|
inline |
Computing the base-e exponential of the represented element.
proxy | The given proxy instance. |
This function computes the base-e exponential of the element represented by the proxy. In case the proxy represents a vector- or matrix-like data structure the function returns an expression representing the base-e exponentials of the elements of the vector/matrix.
|
inline |
Computing the base-10 exponential of the represented element.
proxy | The given proxy instance. |
This function computes the base-10 exponential of the element represented by the proxy. In case the proxy represents a vector- or matrix-like data structure the function returns an expression representing the base-10 exponentials of the elements of the vector/matrix.
|
inline |
Computing the base-2 exponential of the represented element.
proxy | The given proxy instance. |
This function computes the base-2 exponential of the element represented by the proxy. In case the proxy represents a vector- or matrix-like data structure the function returns an expression representing the base-2 exponentials of the elements of the vector/matrix.
BLAZE_ALWAYS_INLINE SparseMatrixProxy< PT, MT >::Iterator blaze::find | ( | const SparseMatrixProxy< PT, MT > & | proxy, |
size_t | i, | ||
size_t | j | ||
) |
Searches for a specific matrix element.
proxy | The given access proxy. |
i | The row index of the search element. The index has to be in the range ![]() |
j | The column index of the search element. The index has to be in the range ![]() |
BLAZE_ALWAYS_INLINE SparseVectorProxy< PT, VT >::Iterator blaze::find | ( | const SparseVectorProxy< PT, VT > & | proxy, |
size_t | index | ||
) |
Searches for a specific sparse vector element.
proxy | The given access proxy. |
index | The index of the search element. The index has to be in the range ![]() |
|
inline |
Computes the largest integral value that is not greater than the represented element.
proxy | The given proxy instance. |
This function computes the largest integral value that is not greater than the element represented by the proxy. In case the proxy represents a vector- or matrix-like data structure the function returns an expression representing the operation.
|
inline |
Computes the hypotenous of a Proxy object and an object of different type.
lhs | The left-hand side Proxy object. |
rhs | The right-hand side object of other type. |
This function computes the hypotenous of the element represented by the proxy lhs and the object rhs. In case the objects represent vector- or matrix-like data structures the function returns an expression representing the hypotenous of the elements of the vectors/matrices.
|
inline |
Computes the hypotenous of the two Proxy objects.
This function computes the hypotenous of the elements represented by the two proxies lhs and rhs. In case the objects represent vector- or matrix-like data structures the function returns an expression representing the hypotenous of the elements of the vectors/matrices.
|
inline |
Computes the hypotenous of an object of different type and a Proxy object.
lhs | The left-hand side object of other type. |
rhs | The right-hand side Proxy object. |
This function computes the hypotenous of the element represented by the object lhs and the proxy rhs. In case the objects represent vector- or matrix-like data structures the function returns an expression representing the hypotenous of the elements of the vectors/matrices.
|
inline |
Computing the imaginary part of the represented element.
proxy | The given proxy instance. |
This function returns the imaginary part of the element represented by the proxy. In case the proxy represents a vector- or matrix-like data structure the function returns an expression representing the real part of each each element of the vector/matrix.
|
inline |
Computing the inverse cubic root of the represented element.
proxy | The given proxy instance. |
This function computes the inverse cubic root of the element represented by the proxy. In case the proxy represents a vector- or matrix-like data structure the function returns an expression representing the inverse cubic roots of the elements of the vector/matrix.
|
inline |
In-place inversion of the represented element.
proxy | The given proxy instance. |
std::invalid_argument | Invalid access to restricted element. |
std::invalid_argument | Inversion of singular matrix failed. |
std::invalid_argument | Invalid non-square matrix provided. |
This function inverts the represented scalar or dense matrix element. The inversion fails if the represented element is a dense matrix, which ...
In all failure cases either a compilation error is created if the failure can be predicted at compile time or a std::invalid_argument exception is thrown. Additionally, in case the represented scalar or matrix cannot be modified, a std::invalid_argument exception is thrown.
|
inline |
In-place inversion of the represented element.
proxy | The given proxy instance. |
std::invalid_argument | Invalid access to restricted element. |
std::invalid_argument | Inversion of singular matrix failed. |
std::invalid_argument | Invalid non-square matrix provided. |
This function inverts the represented dense matrix element by means of the specified matrix inversion algorithm IF:
The inversion fails if the represented dense matrix element ...
In all failure cases either a compilation error is created if the failure can be predicted at compile time or a std::invalid_argument exception is thrown. Additionally, in case the represented scalar or matrix cannot be modified, a std::invalid_argument exception is thrown.
|
inline |
Computing the inverse square root of the represented element.
proxy | The given proxy instance. |
This function computes the inverse square root of the element represented by the proxy. In case the proxy represents a vector- or matrix-like data structure the function returns an expression representing the inverse square roots of the elements of the vector/matrix.
|
inline |
Returns whether the represented element is in default state.
proxy | The given proxy instance. |
This function checks whether the element represented by the proxy is in default state. In case the element is of built-in type, the function returns true. In case the element is in default state, the function returns true. Otherwise it returns false.
|
inline |
Returns whether the represented element is finite.
proxy | The given proxy instance. |
This function checks whether the element represented by the proxy is finite (i.e. normal, subnormal or zero elements, but not infinite or NaN). In case it is finite, the function returns true, otherwise it returns false.
|
inline |
Returns whether the represented element is infinite.
proxy | The given proxy instance. |
This function checks whether the element represented by the proxy is infinite (inf). In case it is infinite, the function returns true, otherwise it returns false.
|
inline |
Returns whether the represented element is not-a-number.
proxy | The given proxy instance. |
This function checks whether the element represented by the proxy is not-a-number (NaN). In case it is not-a-number, the function returns true, otherwise it returns false.
|
inline |
Returns whether the represented element is 1.
proxy | The given proxy instance. |
This function checks whether the element represented by the proxy represents the numeric value 1. In case it is 1, the function returns true, otherwise it returns false.
|
inline |
Returns whether the element represents a real number.
proxy | The given proxy instance. |
This function checks whether the element represented by the proxy represents the a real number. In case the element is of built-in type, the function returns true. In case the element is of complex type, the function returns true if the imaginary part is equal to 0. Otherwise it returns false.
|
inline |
Returns whether the represented element is 0.
proxy | The given proxy instance. |
This function checks whether the element represented by the proxy represents the numeric value 0. In case it is 0, the function returns true, otherwise it returns false.
|
inline |
Computing the natural logarithm of the absolute value of the gamma function of the represented element.
proxy | The given proxy instance. |
This function computes the natural logarithm of the absolute value of the gamma function of the element represented by the proxy. In case the proxy represents a vector- or matrix-like data structure the function returns an expression representing the natural logarithm of the elements of the vector/matrix.
|
inline |
Computing the natural logarithm of the represented element.
proxy | The given proxy instance. |
This function computes the natural logarithm of the element represented by the proxy. In case the proxy represents a vector- or matrix-like data structure the function returns an expression representing the natural logarithm of the elements of the vector/matrix.
|
inline |
Computing the common logarithm of the represented element.
proxy | The given proxy instance. |
This function computes the common logarithm of the element represented by the proxy. In case the proxy represents a vector- or matrix-like data structure the function returns an expression representing the common logarithm of the elements of the vector/matrix.
|
inline |
Computing the natural logarithm of x+1 of the represented element.
proxy | The given proxy instance. |
This function computes the natural logarithm of x+1 of the element represented by the proxy. In case the proxy represents a vector- or matrix-like data structure the function returns an expression representing the natural logarithm of x+1 of the elements of the vector/matrix.
|
inline |
Computing the binary logarithm of the represented element.
proxy | The given proxy instance. |
This function computes the binary logarithm of the element represented by the proxy. In case the proxy represents a vector- or matrix-like data structure the function returns an expression representing the binary logarithm of the elements of the vector/matrix.
BLAZE_ALWAYS_INLINE SparseMatrixProxy< PT, MT >::Iterator blaze::lowerBound | ( | const SparseMatrixProxy< PT, MT > & | proxy, |
size_t | i, | ||
size_t | j | ||
) |
Returns an iterator to the first index not less than the given index.
proxy | The given access proxy. |
i | The row index of the search element. The index has to be in the range ![]() |
j | The column index of the search element. The index has to be in the range ![]() |
BLAZE_ALWAYS_INLINE SparseVectorProxy< PT, VT >::Iterator blaze::lowerBound | ( | const SparseVectorProxy< PT, VT > & | proxy, |
size_t | index | ||
) |
Returns an iterator to the first index not less then the given index.
proxy | The given access proxy. |
index | The index of the search element. The index has to be in the range ![]() |
|
constexprnoexcept |
Rounds up an integral value to the next multiple of a given factor.
value | The integral value to be rounded up ![]() |
factor | The factor of the multiple ![]() |
This function rounds up the given integral value to the next multiple of the given integral factor. In case the integral value is already a multiple of the given factor, the value itself is returned. Note that the attempt to use the function with non-integral types results in a compilation error!
BLAZE_ALWAYS_INLINE size_t blaze::nonZeros | ( | const DenseMatrixProxy< PT, MT > & | proxy | ) |
Returns the number of non-zero elements in the represented matrix.
proxy | The given access proxy. |
BLAZE_ALWAYS_INLINE size_t blaze::nonZeros | ( | const DenseMatrixProxy< PT, MT > & | proxy, |
size_t | i | ||
) |
Returns the number of non-zero elements in the specified row/column of the represented matrix.
proxy | The given access proxy. |
i | The index of the row/column. |
This function returns the current number of non-zero elements in the specified row/column. In case the storage order is set to rowMajor the function returns the number of non-zero elements in row i, in case the storage flag is set to columnMajor the function returns the number of non-zero elements in column i.
BLAZE_ALWAYS_INLINE size_t blaze::nonZeros | ( | const DenseVectorProxy< PT, VT > & | proxy | ) |
Returns the number of non-zero elements in the represented vector.
proxy | The given access proxy. |
Note that the number of non-zero elements is always less than or equal to the current size of the vector.
BLAZE_ALWAYS_INLINE size_t blaze::nonZeros | ( | const SparseMatrixProxy< PT, MT > & | proxy | ) |
Returns the number of non-zero elements in the represented matrix.
proxy | The given access proxy. |
BLAZE_ALWAYS_INLINE size_t blaze::nonZeros | ( | const SparseMatrixProxy< PT, MT > & | proxy, |
size_t | i | ||
) |
Returns the number of non-zero elements in the specified row/column of the represented matrix.
proxy | The given access proxy. |
i | The index of the row/column. |
This function returns the current number of non-zero elements in the specified row/column. In case the storage order is set to rowMajor the function returns the number of non-zero elements in row i, in case the storage flag is set to columnMajor the function returns the number of non-zero elements in column i.
BLAZE_ALWAYS_INLINE size_t blaze::nonZeros | ( | const SparseVectorProxy< PT, VT > & | proxy | ) |
Returns the number of non-zero elements in the represented vector.
proxy | The given access proxy. |
Note that the number of non-zero elements is always less than or equal to the current size of the vector.
|
inlinenoexcept |
Determines the number of non-zero elements contained in the given initializer list.
list | The given initializer list |
|
inlinenoexcept |
Determines the number of non-zero elements contained in the given initializer list.
list | The given initializer list |
|
constexprnoexcept |
Negating the given alignment flag.
flag | The given alignment flag to be negated. |
This logical NOT operator negates the given alignment flag. In case the given flag represents unaligned, the function returns aligned, in case it represents aligned it returns unaligned.
|
constexprnoexcept |
Negating the given padding flag.
flag | The given padding flag to be negated. |
This logical NOT operator negates the given padding flag. In case the given flag represents unpadded, the function returns padded, in case it represents padded it returns unpadded.
|
constexprnoexcept |
Negating the given relaxation flag.
flag | The given relaxation flag to be negated. |
This logical NOT operator negates the given relaxation flag. In case the given flag represents strict, the function returns relaxed, in case it represents relaxed it returns strict.
|
constexpr |
Inequality comparison between an Accuracy object and a floating point value.
rhs | The right-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
constexpr |
Inequality comparison between an Epsilon object and a floating point value.
rhs | The right-hand side floating point value. |
This operator works only for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
Inequality comparison between two Infinity objects.
|
constexpr |
Inequality comparison between an Infinity object and a NegativeInfinity object.
|
constexpr |
Inequality comparison between an Infinity object and a built-in data type.
lhs | The left-hand side Infinity object. |
rhs | The right-hand side built-in data value. |
This operator works only for built-in data types. The attempt to compare user-defined class types will result in a compile time error.
|
constexpr |
Inequality comparison between a NegativeAccuracy object and a floating point value.
rhs | The right-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
constexpr |
Inequality comparison between a NegativeEpsilon object and a floating point value.
rhs | The right-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
constexpr |
Inequality comparison between a NegativeInfinity object and an Infinity object.
|
constexpr |
Inequality comparison between an NegativeInfinity object and a built-in data type.
lhs | The left-hand side NegativeInfinity object. |
rhs | The right-hand side built-in data value. |
This operator works only for built-in data types. The attempt to compare user-defined class types will result in a compile time error.
|
constexpr |
Inequality comparison between two NegativeInfinity objects.
|
inline |
|
constexpr |
Inequality comparison between a floating point value and an Accuracy object.
lhs | The left-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
constexpr |
Inequality comparison between a floating point value and an Epsilon object.
lhs | The left-hand side floating point value. |
This operator works only for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
constexpr |
Inequality comparison between a built-in data type and an Infinity object.
lhs | The left-hand side built-in data value. |
rhs | The right-hand side Infinity object. |
This operator works only for built-in data types. The attempt to compare user-defined class types will result in a compile time error.
|
constexpr |
Inequality comparison between a floating point value and a NegativeAccuracy object.
lhs | The left-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
constexpr |
Inequality comparison between a floating point value and a NegativeEpsilon object.
lhs | The left-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
constexpr |
Inequality comparison between a built-in data type and an NegativeInfinity object.
lhs | The left-hand side built-in data value. |
rhs | The right-hand side NegativeInfinity object. |
This operator works only for built-in data types. The attempt to compare user-defined class types will result in a compile time error.
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
inline |
|
constexpr |
Less-than comparison between an Accuracy object and a floating point value.
rhs | The right-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
constexpr |
Less-than comparison between an Epsilon object and a floating point value.
rhs | The right-hand side floating point value. |
This operator works only for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
constexpr |
Less-than comparison between a NegativeAccuracy object and a floating point value.
rhs | The right-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
constexpr |
Less-than comparison between a NegativeEpsilon object and a floating point value.
rhs | The right-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
|
constexpr |
Less-than comparison between a floating point value and an Accuracy object.
lhs | The left-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
constexpr |
Less-than comparison between a floating point value and an Epsilon object.
lhs | The left-hand side floating point value. |
This operator works only for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
constexpr |
Less-than comparison between a floating point value and a NegativeAccuracy object.
lhs | The left-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
constexpr |
Less-than comparison between a floating point value and a NegativeEpsilon object.
lhs | The left-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
|
inline |
Global output operator for the Proxy class template.
os | Reference to the output stream. |
proxy | Reference to a constant proxy object. |
|
constexpr |
Less-or-equal-than comparison between an Accuracy object and a floating point value.
rhs | The right-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
constexpr |
Less-or-equal-than comparison between an Epsilon object and a floating point value.
rhs | The right-hand side floating point value. |
This operator works only for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
constexpr |
Less-or-equal-than comparison between a NegativeAccuracy object and a floating point value.
rhs | The right-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
constexpr |
Less-or-equal-than comparison between a NegativeEpsilon object and a floating point value.
rhs | The right-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
|
constexpr |
Less-or-equal-than comparison between a floating point value and an Accuracy object.
lhs | The left-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
constexpr |
Less-or-equal-than comparison between a floating point value and an Epsilon object.
lhs | The left-hand side floating point value. |
This operator works only for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
constexpr |
Less-or-equal-than comparison between a floating point value and a NegativeAccuracy object.
lhs | The left-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
constexpr |
Less-or-equal-than comparison between a floating point value and a NegativeEpsilon object.
lhs | The left-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
|
constexpr |
Equality comparison between an Accuracy object and a floating point value.
rhs | The right-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
constexpr |
Equality comparison between an Epsilon object and a floating point value.
rhs | The right-hand side floating point value. |
This operator works only for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
Equality comparison between two Infinity objects.
|
constexpr |
Equality comparison between an Infinity object and a NegativeInfinity object.
|
constexpr |
Equality comparison between an Infinity object and a built-in data type.
lhs | The left-hand side Infinity object. |
rhs | The right-hand side built-in data value. |
This operator works only for built-in data types. The attempt to compare user-defined class types will result in a compile time error.
|
constexpr |
Equality comparison between a NegativeAccuracy object and a floating point value.
rhs | The right-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
constexpr |
Equality comparison between a NegativeEpsilon object and a floating point value.
rhs | The right-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
constexpr |
Equality comparison between a NegativeInfinity object and an Infinity object.
|
constexpr |
Equality comparison between an NegativeInfinity object and a built-in data type.
lhs | The left-hand side NegativeInfinity object. |
rhs | The right-hand side built-in data value. |
This operator works only for built-in data types. The attempt to compare user-defined class types will result in a compile time error.
|
constexpr |
Equality comparison between two NegativeInfinity objects.
|
inline |
|
constexpr |
Equality comparison between a floating point value and an Accuracy object.
lhs | The left-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
constexpr |
Equality comparison between a floating point value and an Epsilon object.
lhs | The left-hand side floating point value. |
This operator works only for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
constexpr |
Equality comparison between a built-in data type and an Infinity object.
lhs | The left-hand side built-in data value. |
rhs | The right-hand side Infinity object. |
This operator works only for built-in data types. The attempt to compare user-defined class types will result in a compile time error.
|
constexpr |
Equality comparison between a floating point value and a NegativeAccuracy object.
lhs | The left-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
constexpr |
Equality comparison between a floating point value and a NegativeEpsilon object.
lhs | The left-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
constexpr |
Equality comparison between a built-in data type and an NegativeInfinity object.
lhs | The left-hand side built-in data value. |
rhs | The right-hand side NegativeInfinity object. |
This operator works only for built-in data types. The attempt to compare user-defined class types will result in a compile time error.
|
inline |
|
constexpr |
Greater-than comparison between an Accuracy object and a floating point value.
rhs | The right-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
constexpr |
Greater-than comparison between an Epsilon object and a floating point value.
rhs | The right-hand side floating point value. |
This operator works only for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
constexpr |
Greater-than comparison between a NegativeAccuracy object and a floating point value.
rhs | The right-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
constexpr |
Greater-than comparison between a NegativeEpsilon object and a floating point value.
rhs | The right-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
|
constexpr |
Greater-than comparison between a floating point value and an Accuracy object.
lhs | The left-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
constexpr |
Greater-than comparison between a floating point value and an Epsilon object.
lhs | The left-hand side floating point value. |
This operator works only for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
constexpr |
Greater-than comparison between a floating point value and a NegativeAccuracy object.
lhs | The left-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
constexpr |
Greater-than comparison between a floating point value and a NegativeEpsilon object.
lhs | The left-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
|
constexpr |
Greater-or-equal-than comparison between an Accuracy object and a floating point value.
rhs | The right-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
constexpr |
Greater-or-equal-than comparison between an Epsilon object and a floating point value.
rhs | The right-hand side floating point value. |
This operator works only for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
constexpr |
Greater-or-equal-than comparison between a NegativeAccuracy object and a floating point value.
rhs | The right-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
constexpr |
Greater-or-equal-than comparison between a NegativeEpsilon object and a floating point value.
rhs | The right-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
|
constexpr |
Less-or-equal-than comparison between a floating point value and an Accuracy object.
lhs | The left-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
constexpr |
Less-or-equal-than comparison between a floating point value and an Epsilon object.
lhs | The left-hand side floating point value. |
This operator works only for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
constexpr |
Less-or-equal-than comparison between a floating point value and a NegativeAccuracy object.
lhs | The left-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
constexpr |
Less-or-equal-than comparison between a floating point value and a NegativeEpsilon object.
lhs | The left-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
|
inline |
Computing the exponential value of the represented element.
proxy | The given proxy instance. |
exp | The exponent. |
This function computes the exponential value of the element represented by the proxy. In case the proxy represents a vector- or matrix-like data structure the function returns an expression representing the exponential value of the elements of the vector/matrix.
|
inline |
Computing the square value of the represented element.
proxy | The given proxy instance. |
This function squares the element represented by the proxy. In case the proxy represents a vector- or matrix-like data structure the function returns an expression representing the squared value of the elements of the vector/matrix.
|
inline |
Computing the cube value of the represented element.
proxy | The given proxy instance. |
This function cubes the element represented by the proxy. In case the proxy represents a vector- or matrix-like data structure the function returns an expression representing the cubed value of the elements of the vector/matrix.
|
inline |
Computing the quadruple value of the represented element.
proxy | The given proxy instance. |
This function quadruples the element represented by the proxy. In case the proxy represents a vector- or matrix-like data structure the function returns an expression representing the quadrupled value of the elements of the vector/matrix.
|
constexprnoexcept |
Rounds down an integral value to the previous multiple of a given factor.
value | The integral value to be rounded down ![]() |
factor | The factor of the multiple ![]() |
This function rounds down the given integral value to the previous multiple of the given integral factor. In case the integral value is already a multiple of the given factor, the value itself is returned. Note that the attempt to use the function with non-integral types results in a compilation error!
|
inline |
Computing the real part of the represented element.
proxy | The given proxy instance. |
This function returns the real part of the element represented by the proxy. In case the proxy represents a vector- or matrix-like data structure the function returns an expression representing the real part of each each element of the vector/matrix.
|
inline |
Resetting the represented element to the default initial values.
proxy | The given proxy instance. |
|
inline |
Reset the specified row/column of the represented matrix.
proxy | The given proxy instance. |
i | The index of the row/column to be resetted. |
This function resets all elements in the specified row/column of the given matrix to their default value. In case the given matrix is a rowMajor matrix the function resets the values in row i, if it is a columnMajor matrix the function resets the values in column i. Note that the capacity of the row/column remains unchanged.
BLAZE_ALWAYS_INLINE void blaze::resize | ( | const DenseMatrixProxy< PT, MT > & | proxy, |
size_t | m, | ||
size_t | n, | ||
bool | preserve | ||
) |
Changing the size of the represented matrix.
proxy | The given access proxy. |
m | The new number of rows of the matrix. |
n | The new number of columns of the matrix. |
preserve | true if the old values of the matrix should be preserved, false if not. |
std::invalid_argument | Invalid resize arguments for square matrix. |
std::invalid_argument | Matrix cannot be resized. |
This function resizes the represented matrix to the specified dimensions. In contrast to the resize()
member function, which is only available on resizable matrix types, this function can be used on both resizable and non-resizable matrices. In case the given matrix of type MT is resizable (i.e. provides a resize
function) the type-specific resize()
member function is called. Depending on the type MT, this may result in the allocation of new dynamic memory and the invalidation of existing views (submatrices, rows, columns, ...). Note that in case the matrix is a compile time square matrix (as for instance the blaze::SymmetricMatrix adaptor, ...) the specified number of rows must be identical to the number of columns. Otherwise a std::invalid_argument exception is thrown. If the matrix type MT is non-resizable (i.e. does not provide a resize()
function) and if the specified number of rows and columns is not identical to the current number of rows and columns of the matrix, a std::invalid_argument exception is thrown.
BLAZE_ALWAYS_INLINE void blaze::resize | ( | const DenseVectorProxy< PT, VT > & | proxy, |
size_t | n, | ||
bool | preserve | ||
) |
Changing the size of the represented vector.
proxy | The given access proxy. |
n | The new size of the vector. |
preserve | true if the old values of the vector should be preserved, false if not. |
std::invalid_argument | Vector cannot be resized. |
This function resizes the represented vector to the specified size. Note that in contrast to the resize()
member function, which is only available on resizable vector types, this function can be used on both resizable and non-resizable vectors. In case the type VT of the represented vector is resizable (i.e. provides a resize()
function), the type-specific resize()
member function is called. Depending on the type VT, this may result in the allocation of new dynamic memory and the invalidation of existing views (subvectors, ...). In case VT is non-resizable (i.e. does not provide a resize()
function) and if the specified size is not identical to the current size of the vector, a std::invalid_argument exception is thrown.
BLAZE_ALWAYS_INLINE void blaze::resize | ( | const SparseMatrixProxy< PT, MT > & | proxy, |
size_t | m, | ||
size_t | n, | ||
bool | preserve | ||
) |
Changing the size of the represented matrix.
proxy | The given access proxy. |
m | The new number of rows of the matrix. |
n | The new number of columns of the matrix. |
preserve | true if the old values of the matrix should be preserved, false if not. |
std::invalid_argument | Invalid resize arguments for square matrix. |
This function resizes the represented matrix to the specified dimensions. Note that in case the matrix is a compile time square matrix (as for instance the blaze::SymmetricMatrix adaptor, ...) the specified number of rows must be identical to the number of columns. Otherwise a std::invalid_argument exception is thrown.
BLAZE_ALWAYS_INLINE void blaze::resize | ( | const SparseVectorProxy< PT, VT > & | proxy, |
size_t | n, | ||
bool | preserve | ||
) |
Changing the size of the represented vector.
proxy | The given access proxy. |
n | The new size of the vector. |
preserve | true if the old values of the vector should be preserved, false if not. |
This function resizes the represented vector to the specified size.
|
inline |
Computes the nearest integral value to the represented element.
proxy | The given proxy instance. |
This function computes the nearest integral value to the element represented by the proxy. In case the proxy represents a vector- or matrix-like data structure the function returns an expression representing the operation.
BLAZE_ALWAYS_INLINE size_t blaze::rows | ( | const DenseMatrixProxy< PT, MT > & | proxy | ) |
Returns the current number of rows of the represented matrix.
proxy | The given access proxy. |
BLAZE_ALWAYS_INLINE size_t blaze::rows | ( | const SparseMatrixProxy< PT, MT > & | proxy | ) |
Returns the current number of rows of the represented matrix.
proxy | The given access proxy. |
|
inline |
Evaluating the sign of the represented element.
proxy | The given proxy instance. |
This function evaluates the sign of the element represented by the proxy. In case the proxy represents a vector- or matrix-like data structure the function returns an expression representing the operation.
|
inline |
Computing the sine of the represented element.
proxy | The given proxy instance. |
This function computes the sine of the element represented by the proxy. In case the proxy represents a vector- or matrix-like data structure the function returns an expression representing the sines of the elements of the vector/matrix.
|
inline |
Computing the hyperbolic sine of the represented element.
proxy | The given proxy instance. |
This function computes the hyperbolic sine of the element represented by the proxy. In case the proxy represents a vector- or matrix-like data structure the function returns an expression representing the hyperbolic sines of the elements of the vector/matrix.
BLAZE_ALWAYS_INLINE size_t blaze::size | ( | const DenseVectorProxy< PT, VT > & | proxy | ) |
Returns the current size/dimension of the represented vector.
proxy | The given access proxy. |
BLAZE_ALWAYS_INLINE size_t blaze::size | ( | const SparseVectorProxy< PT, VT > & | proxy | ) |
Returns the current size/dimension of the represented vector.
proxy | The given access proxy. |
|
inline |
Computing the square root of the represented element.
proxy | The given proxy instance. |
This function computes the square root of the element represented by the proxy. In case the proxy represents a vector- or matrix-like data structure the function returns an expression representing the square roots of the elements of the vector/matrix.
|
inline |
Computing the tangent of the represented element.
proxy | The given proxy instance. |
This function computes the tangent of the element represented by the proxy. In case the proxy represents a vector- or matrix-like data structure the function returns an expression representing the tangents of the elements of the vector/matrix.
|
inline |
Computing the hyperbolic tangent of the represented element.
proxy | The given proxy instance. |
This function computes the hyperbolic tangent of the element represented by the proxy. In case the proxy represents a vector- or matrix-like data structure the function returns an expression representing the hyperbolic tangents of the elements of the vector/matrix.
|
inline |
Computing the transpose of the represented element.
proxy | The given proxy instance. |
This function returns an expression representing the transpose of the element represented by the proxy.
|
inline |
In-place transpose of the represented matrix element.
proxy | The given proxy instance. |
std::invalid_argument | Invalid access to restricted element. |
std::logic_error | Matrix cannot be transposed. |
This function transposes the represented matrix in-place. The transpose operation fails if ...
In all failure cases a std::logic_error exception is thrown. Additionally, in case the represented matrix cannot be modified, a std::invalid_argument exception is thrown.
|
inline |
Computes the nearest integral value that is not greater than the represented element.
proxy | The given proxy instance. |
This function computes the nearest integral value that is not greater than the element represented by the proxy. In case the proxy represents a vector- or matrix-like data structure the function returns an expression representing the operation.
BLAZE_ALWAYS_INLINE SparseMatrixProxy< PT, MT >::Iterator blaze::upperBound | ( | const SparseMatrixProxy< PT, MT > & | proxy, |
size_t | i, | ||
size_t | j | ||
) |
Returns an iterator to the first index greater than the given index.
proxy | The given access proxy. |
i | The row index of the search element. The index has to be in the range ![]() |
j | The column index of the search element. The index has to be in the range ![]() |
BLAZE_ALWAYS_INLINE SparseVectorProxy< PT, VT >::Iterator blaze::upperBound | ( | const SparseVectorProxy< PT, VT > & | proxy, |
size_t | index | ||
) |
Returns an iterator to the first index greater then the given index.
proxy | The given access proxy. |
index | The index of the search element. The index has to be in the range ![]() |
|
constexpr |
Global Accuracy instance.
The blaze::accuracy instance can be used wherever a floating point data type is expected. It is implicitly converted to the corresponding floating point data type and represents the computation accuracy of the Blaze library for the according data type.
|
constexpr |
Global Epsilon instance.
The blaze::epsilon instance can be used wherever a floating point data type is expected. It is implicitly converted to the corresponding floating point data type and represents the smallest possible difference between two values of the according data type.