Blaze 3.9
Modules | Classes | Macros | Typedefs | Enumerations | Functions
Math module

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...
 

Detailed Description

Macro Definition Documentation

◆ BLAZE_THROW_DIVISION_BY_ZERO

#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:

#define BLAZE_THROW_DIVISION_BY_ZERO( MESSAGE ) \
BLAZE_THROW_RUNTIME_ERROR( MESSAGE )

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:

class DivisionByZero
{
public:
DivisionByZero();
explicit DivisionByZero( const std::string& message );
// ...
};
#define BLAZE_THROW_DIVISION_BY_ZERO( MESSAGE ) \
throw DivisionByZero( MESSAGE )
#include <blaze/Blaze.h>
Primary include file of the Blaze library.
Note
It is recommended to define the macro such that a subsequent semicolon is required!
Warning
This macro is provided with the intention to assist in adapting Blaze to special conditions and environments. However, the customization of the type of exception via this macro may have an effect on the library. Thus be advised to use the macro with due care!

◆ BLAZE_THROW_LAPACK_ERROR

#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:

#define BLAZE_THROW_LAPACK_ERROR( MESSAGE ) \
BLAZE_THROW_RUNTIME_ERROR( MESSAGE )

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:

class LapackError
{
public:
LapackError();
explicit LapackError( const std::string& message );
// ...
};
#define BLAZE_THROW_LAPACK_ERROR( MESSAGE ) \
throw LapackError( MESSAGE )
#include <blaze/Blaze.h>
Note
It is recommended to define the macro such that a subsequent semicolon is required!
Warning
This macro is provided with the intention to assist in adapting Blaze to special conditions and environments. However, the customization of the type of exception via this macro may have an effect on the library. Thus be advised to use the macro with due care!

Enumeration Type Documentation

◆ AlignmentFlag

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:

auto sv = subvector<unaligned>( v, 10UL, 20UL );
Efficient implementation of an arbitrary sized vector.
Definition: DynamicVector.h:223
@ unaligned
Flag for unaligned vectors and matrices.
Definition: AlignmentFlag.h:64
constexpr bool columnVector
Transpose flag for column vectors.
Definition: TransposeFlag.h:58
Enumerator
unaligned 

Flag for unaligned vectors and matrices.

aligned 

Flag for aligned vectors and matrices.

◆ 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 ( $ A = P L U $). If no permutations are required, P is the identity matrix.
  • byLDLT: The Bunch-Kaufman inversion algorithm for symmetric indefinite matrices. It decomposes the given matrix into either $ A = U D U^{T} $ or $ A = L D L^{T} $, where 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 $ A = U D U^{H} $ or $ A = L D L^{H} $, where 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 $ A = L L^H $, where L is a lower triangular matrix, or $ A = U^H U $, where 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.
Enumerator
byLU 

Flag for the LU-based matrix inversion.

byLDLT 

Flag for the Bunch-Kaufman-based inversion for symmetric matrices.

byLDLH 

Flag for the Bunch-Kaufman-based inversion for Hermitian matrices.

byLLH 

Flag for the Cholesky-based inversion for positive-definite matrices.

asGeneral 

Flag for the inversion of a general matrix (same as byLU).

asSymmetric 

Flag for the inversion of a symmetric matrix (same as byLDLT).

asHermitian 

Flag for the inversion of a Hermitian matrix (same as byLDLH).

asLower 

Flag for the inversion of a lower triangular matrix.

asUniLower 

Flag for the inversion of a lower unitriangular matrix.

asUpper 

Flag for the inversion of a upper triangular matrix.

asUniUpper 

Flag for the inversion of a upper unitriangular matrix.

asDiagonal 

Flag for the inversion of a diagonal matrix.

◆ PaddingFlag

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:

std::vector<int> vec( 7UL );
Efficient implementation of a customizable vector.
Definition: CustomVector.h:407
@ unpadded
Flag for unpadded vectors and matrices.
Definition: PaddingFlag.h:78
std::vector<int> vec( 16UL );
@ padded
Flag for padded vectors and matrices.
Definition: PaddingFlag.h:79
@ aligned
Flag for aligned vectors and matrices.
Definition: AlignmentFlag.h:65
Array-delete policy class.
Definition: ArrayDelete.h:64
Enumerator
unpadded 

Flag for unpadded vectors and matrices.

padded 

Flag for padded vectors and matrices.

◆ RelaxationFlag

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:

blaze::StaticVector<double,3UL> v{ 0.0, 1E-9, 0.0 };
isDefault<strict> ( v ); // Returns false
isDefault<relaxed>( v ); // Returns true
Efficient implementation of a fixed-sized vector.
Definition: StaticVector.h:230
@ relaxed
Flag for relaxed semantics.
Definition: RelaxationFlag.h:68
@ strict
Flag for strict semantics.
Definition: RelaxationFlag.h:67
Enumerator
strict 

Flag for strict semantics.

relaxed 

Flag for relaxed semantics.

Function Documentation

◆ abs()

template<typename PT , typename RT >
decltype(auto) blaze::abs ( const Proxy< PT, RT > &  proxy)
inline

Computing the absolute value of the represented element.

Parameters
proxyThe given proxy instance.
Returns
The absolute value of the represented element.

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.

◆ acos()

template<typename PT , typename RT >
decltype(auto) blaze::acos ( const Proxy< PT, RT > &  proxy)
inline

Computing the inverse cosine of the represented element.

Parameters
proxyThe given proxy instance.
Returns
The inverse cosine of the represented element.

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.

◆ acosh()

template<typename PT , typename RT >
decltype(auto) blaze::acosh ( const Proxy< PT, RT > &  proxy)
inline

Computing the inverse hyperbolic cosine of the represented element.

Parameters
proxyThe given proxy instance.
Returns
The inverse hyperbolic cosine of the represented element.

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.

◆ asin()

template<typename PT , typename RT >
decltype(auto) blaze::asin ( const Proxy< PT, RT > &  proxy)
inline

Computing the inverse sine of the represented element.

Parameters
proxyThe given proxy instance.
Returns
The inverse sine of the represented element.

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.

◆ asinh()

template<typename PT , typename RT >
decltype(auto) blaze::asinh ( const Proxy< PT, RT > &  proxy)
inline

Computing the inverse hyperbolic sine of the represented element.

Parameters
proxyThe given proxy instance.
Returns
The inverse hyperbolic sine of the represented element.

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.

◆ atan()

template<typename PT , typename RT >
decltype(auto) blaze::atan ( const Proxy< PT, RT > &  proxy)
inline

Computing the inverse tangent of the represented element.

Parameters
proxyThe given proxy instance.
Returns
The inverse tangent of the represented element.

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.

◆ atan2() [1/3]

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

Computes the multi-valued inverse tangent of a Proxy object and an object of different type.

Parameters
lhsThe left-hand side Proxy object.
rhsThe right-hand side object of other type.
Returns
The multi-valued inverse tangent of the given objects.

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.

◆ atan2() [2/3]

template<typename PT1 , typename RT1 , typename PT2 , typename RT2 >
decltype(auto) blaze::atan2 ( const Proxy< PT1, RT1 > &  lhs,
const Proxy< PT2, RT2 > &  rhs 
)
inline

Computes the multi-valued inverse tangent of two Proxy objects.

Parameters
lhsThe left-hand side Proxy object.
rhsThe right-hand side Proxy object.
Returns
The multi-valued inverse tangent of the given 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.

◆ atan2() [3/3]

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

Computes the multi-valued inverse tangent of an object of different type and a Proxy object.

Parameters
lhsThe left-hand side object of other type.
rhsThe right-hand side Proxy object.
Returns
The multi-valued inverse tangent of the given objects.

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.

◆ atanh()

template<typename PT , typename RT >
decltype(auto) blaze::atanh ( const Proxy< PT, RT > &  proxy)
inline

Computing the inverse hyperbolic tangent of the represented element.

Parameters
proxyThe given proxy instance.
Returns
The inverse hyperbolic tangent of the represented element.

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.

◆ begin() [1/4]

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.

Parameters
proxyThe given access proxy.
iThe row/column index.
Returns
Iterator to the first element of row/column i.

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.

◆ begin() [2/4]

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.

Parameters
proxyThe given access proxy.
Returns
Iterator to the first element of the vector.

◆ begin() [3/4]

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.

Parameters
proxyThe given access proxy.
iThe row/column index.
Returns
Iterator to the first element of row/column i.

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.

◆ begin() [4/4]

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.

Parameters
proxyThe given access proxy.
Returns
Iterator to the first element of the vector.

◆ capacity() [1/6]

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.

Parameters
proxyThe given access proxy.
Returns
The capacity of the matrix.

◆ capacity() [2/6]

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.

Parameters
proxyThe given access proxy.
iThe index of the row/column.
Returns
The current capacity of row/column i.

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.

◆ capacity() [3/6]

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.

Parameters
proxyThe given access proxy.
Returns
The capacity of the vector.

◆ capacity() [4/6]

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.

Parameters
proxyThe given access proxy.
Returns
The capacity of the matrix.

◆ capacity() [5/6]

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.

Parameters
proxyThe given access proxy.
iThe index of the row/column.
Returns
The current capacity of row/column i.

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.

◆ capacity() [6/6]

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.

Parameters
proxyThe given access proxy.
Returns
The capacity of the vector.

◆ cbegin() [1/4]

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.

Parameters
proxyThe given access proxy.
iThe row/column index.
Returns
Iterator to the first element of row/column i.

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.

◆ cbegin() [2/4]

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.

Parameters
proxyThe given access proxy.
Returns
Iterator to the first element of the vector.

◆ cbegin() [3/4]

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.

Parameters
proxyThe given access proxy.
iThe row/column index.
Returns
Iterator to the first element of row/column i.

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.

◆ cbegin() [4/4]

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.

Parameters
proxyThe given access proxy.
Returns
Iterator to the first element of the vector.

◆ cbrt()

template<typename PT , typename RT >
decltype(auto) blaze::cbrt ( const Proxy< PT, RT > &  proxy)
inline

Computing the cubic root of the represented element.

Parameters
proxyThe given proxy instance.
Returns
The cubic root of the represented element.

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.

◆ ceil()

template<typename PT , typename RT >
decltype(auto) blaze::ceil ( const Proxy< PT, RT > &  proxy)
inline

Computes the smallest integral value that is not less than the represented element.

Parameters
proxyThe given proxy instance.
Returns
The smallest integral value that is not less than the represented element.

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.

◆ cend() [1/4]

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.

Parameters
proxyThe given access proxy.
iThe row/column index.
Returns
Iterator just past the last element of row/column i.

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.

◆ cend() [2/4]

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.

Parameters
proxyThe given access proxy.
Returns
Iterator just past the last element of the vector.

◆ cend() [3/4]

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.

Parameters
proxyThe given access proxy.
iThe row/column index.
Returns
Iterator just past the last element of row/column i.

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.

◆ cend() [4/4]

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.

Parameters
proxyThe given access proxy.
Returns
Iterator just past the last element of the vector.

◆ clear()

template<typename PT , typename RT >
void blaze::clear ( const Proxy< PT, RT > &  proxy)
inline

Clearing the represented element.

Parameters
proxyThe given proxy instance.
Returns
void

◆ columns() [1/2]

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.

Parameters
proxyThe given access proxy.
Returns
The number of columns of the matrix.

◆ columns() [2/2]

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.

Parameters
proxyThe given access proxy.
Returns
The number of columns of the matrix.

◆ conj()

template<typename PT , typename RT >
decltype(auto) blaze::conj ( const Proxy< PT, RT > &  proxy)
inline

Computing the complex conjugate of the represented element.

Parameters
proxyThe given proxy instance.
Returns
The complex conjugate of the represented element.

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.

◆ cos()

template<typename PT , typename RT >
decltype(auto) blaze::cos ( const Proxy< PT, RT > &  proxy)
inline

Computing the cosine of the represented element.

Parameters
proxyThe given proxy instance.
Returns
The cosine of the represented element.

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.

◆ cosh()

template<typename PT , typename RT >
decltype(auto) blaze::cosh ( const Proxy< PT, RT > &  proxy)
inline

Computing the hyperbolic cosine of the represented element.

Parameters
proxyThe given proxy instance.
Returns
The hyperbolic cosine of the represented element.

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.

◆ ctrans()

template<typename PT , typename RT >
decltype(auto) blaze::ctrans ( const Proxy< PT, RT > &  proxy)
inline

Computing the conjugate transpose of the represented element.

Parameters
proxyThe given proxy instance.
Returns
The conjugate transpose of the represented element.

This function returns an expression representing the conjugate transpose of the element represented by the proxy.

◆ ctranspose()

template<typename PT , typename RT >
void blaze::ctranspose ( const Proxy< PT, RT > &  proxy)
inline

In-place conjugate transpose of the represented matrix element.

Parameters
proxyThe given proxy instance.
Returns
void
Exceptions
std::invalid_argumentInvalid access to restricted element.
std::logic_errorMatrix cannot be transposed.

This function transposes the represented matrix in-place. The transpose operation fails if ...

  • ... the represented matrix has a fixed size and is non-square;
  • ... the represented matrix is a triangular matrix.

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.

◆ determineColumns()

template<typename Type >
constexpr size_t blaze::determineColumns ( initializer_list< initializer_list< Type > >  list)
constexprnoexcept

Determines the maximum number of columns specified by the given initializer list.

Parameters
listThe given initializer list
Returns
The maximum number of columns.

◆ end() [1/4]

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.

Parameters
proxyThe given access proxy.
iThe row/column index.
Returns
Iterator just past the last element of row/column i.

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.

◆ end() [2/4]

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.

Parameters
proxyThe given access proxy.
Returns
Iterator just past the last element of the vector.

◆ end() [3/4]

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.

Parameters
proxyThe given access proxy.
iThe row/column index.
Returns
Iterator just past the last element of row/column i.

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.

◆ end() [4/4]

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.

Parameters
proxyThe given access proxy.
Returns
Iterator just past the last element of the vector.

◆ equal() [1/3]

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

Equality comparison between a Proxy object and an object of different type.

Parameters
lhsThe left-hand side Proxy object.
rhsThe right-hand side object of other type.
Returns
true if the referenced value and the other object are equal, false if they are not.

◆ equal() [2/3]

template<RelaxationFlag RF, typename PT1 , typename RT1 , typename PT2 , typename RT2 >
bool blaze::equal ( const Proxy< PT1, RT1 > &  lhs,
const Proxy< PT2, RT2 > &  rhs 
)
inline

Equality comparison between two Proxy objects.

Parameters
lhsThe left-hand side Proxy object.
rhsThe right-hand side Proxy object.
Returns
true if both referenced values are equal, false if they are not.

◆ equal() [3/3]

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

Equality comparison between an object of different type and a Proxy object.

Parameters
lhsThe left-hand side object of other type.
rhsThe right-hand side Proxy object.
Returns
true if the other object and the referenced value are equal, false if they are not.

◆ erf()

template<typename PT , typename RT >
decltype(auto) blaze::erf ( const Proxy< PT, RT > &  proxy)
inline

Computing the error function of the represented element.

Parameters
proxyThe given proxy instance.
Returns
The error function of the represented element.

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.

◆ erfc()

template<typename PT , typename RT >
decltype(auto) blaze::erfc ( const Proxy< PT, RT > &  proxy)
inline

Computing the complementary error function of the represented element.

Parameters
proxyThe given proxy instance.
Returns
The complementary error function of the represented element.

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.

◆ evaluate()

template<typename PT , typename RT >
decltype(auto) blaze::evaluate ( const Proxy< PT, RT > &  proxy)
inline

Returns whether the represented element is finite.

Parameters
proxyThe given proxy instance.
Returns
true in case the represented element is finite, false otherwise.

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.

◆ exp()

template<typename PT , typename RT >
decltype(auto) blaze::exp ( const Proxy< PT, RT > &  proxy)
inline

Computing the base-e exponential of the represented element.

Parameters
proxyThe given proxy instance.
Returns
The base-e exponential of the represented element.

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.

◆ exp10()

template<typename PT , typename RT >
decltype(auto) blaze::exp10 ( const Proxy< PT, RT > &  proxy)
inline

Computing the base-10 exponential of the represented element.

Parameters
proxyThe given proxy instance.
Returns
The base-10 exponential of the represented element.

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.

◆ exp2()

template<typename PT , typename RT >
decltype(auto) blaze::exp2 ( const Proxy< PT, RT > &  proxy)
inline

Computing the base-2 exponential of the represented element.

Parameters
proxyThe given proxy instance.
Returns
The base-2 exponential of the represented element.

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.

◆ find() [1/2]

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.

Parameters
proxyThe given access proxy.
iThe row index of the search element. The index has to be in the range $[0..M-1]$.
jThe column index of the search element. The index has to be in the range $[0..N-1]$.
Returns
Iterator to the element in case the index is found, end() iterator otherwise.

◆ find() [2/2]

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.

Parameters
proxyThe given access proxy.
indexThe index of the search element. The index has to be in the range $[0..N-1]$.
Returns
Iterator to the element in case the index is found, end() iterator otherwise.

◆ floor()

template<typename PT , typename RT >
decltype(auto) blaze::floor ( const Proxy< PT, RT > &  proxy)
inline

Computes the largest integral value that is not greater than the represented element.

Parameters
proxyThe given proxy instance.
Returns
The largest integral value that is not greater than the represented element.

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.

◆ hypot() [1/3]

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

Computes the hypotenous of a Proxy object and an object of different type.

Parameters
lhsThe left-hand side Proxy object.
rhsThe right-hand side object of other type.
Returns
The hypotenous of the given objects.

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.

◆ hypot() [2/3]

template<typename PT1 , typename RT1 , typename PT2 , typename RT2 >
decltype(auto) blaze::hypot ( const Proxy< PT1, RT1 > &  lhs,
const Proxy< PT2, RT2 > &  rhs 
)
inline

Computes the hypotenous of the two Proxy objects.

Parameters
lhsThe left-hand side Proxy object.
rhsThe right-hand side Proxy object.
Returns
The hypotenous of the given 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.

◆ hypot() [3/3]

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

Computes the hypotenous of an object of different type and a Proxy object.

Parameters
lhsThe left-hand side object of other type.
rhsThe right-hand side Proxy object.
Returns
The hypotenous of the given objects.

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.

◆ imag()

template<typename PT , typename RT >
decltype(auto) blaze::imag ( const Proxy< PT, RT > &  proxy)
inline

Computing the imaginary part of the represented element.

Parameters
proxyThe given proxy instance.
Returns
The imaginary part of the represented element.

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.

◆ invcbrt()

template<typename PT , typename RT >
decltype(auto) blaze::invcbrt ( const Proxy< PT, RT > &  proxy)
inline

Computing the inverse cubic root of the represented element.

Parameters
proxyThe given proxy instance.
Returns
The inverse cubic root of the represented element.

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.

◆ invert() [1/2]

template<typename PT , typename RT >
void blaze::invert ( const Proxy< PT, RT > &  proxy)
inline

In-place inversion of the represented element.

Parameters
proxyThe given proxy instance.
Returns
void
Exceptions
std::invalid_argumentInvalid access to restricted element.
std::invalid_argumentInversion of singular matrix failed.
std::invalid_argumentInvalid 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 ...

  • ... is not a square matrix;
  • ... is singular and not invertible.

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.

Note
In case the represented element is a dense matrix, this function does not provide any exception safety guarantee, i.e. in case an exception is thrown the matrix may already have been modified.
In case the represented element is a dense matrix, this function can only be used if the fitting LAPACK library is available and linked to the executable. Otherwise a linker error will be created.

◆ invert() [2/2]

template<InversionFlag IF, typename PT , typename RT >
void blaze::invert ( const Proxy< PT, RT > &  proxy)
inline

In-place inversion of the represented element.

Parameters
proxyThe given proxy instance.
Returns
void
Exceptions
std::invalid_argumentInvalid access to restricted element.
std::invalid_argumentInversion of singular matrix failed.
std::invalid_argumentInvalid non-square matrix provided.

This function inverts the represented dense matrix element by means of the specified matrix inversion algorithm IF:

invert<byLU>( A ); // Inversion of a general matrix
invert<byLDLT>( A ); // Inversion of a symmetric indefinite matrix
invert<byLDLH>( A ); // Inversion of a Hermitian indefinite matrix
invert<byLLH>( A ); // Inversion of a Hermitian positive definite matrix

The inversion fails if the represented dense matrix element ...

  • ... is not a square matrix;
  • ... is singular and not invertible.

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.

Note
In case the represented element is a dense matrix, this function does not provide any exception safety guarantee, i.e. in case an exception is thrown the matrix may already have been modified.
In case the represented element is a dense matrix, this function can only be used if the fitting LAPACK library is available and linked to the executable. Otherwise a linker error will be created.

◆ invsqrt()

template<typename PT , typename RT >
decltype(auto) blaze::invsqrt ( const Proxy< PT, RT > &  proxy)
inline

Computing the inverse square root of the represented element.

Parameters
proxyThe given proxy instance.
Returns
The inverse square root of the represented element.

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.

◆ isDefault()

template<RelaxationFlag RF, typename PT , typename RT >
bool blaze::isDefault ( const Proxy< PT, RT > &  proxy)
inline

Returns whether the represented element is in default state.

Parameters
proxyThe given proxy instance.
Returns
true in case the represented element is in default state, false otherwise.

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.

◆ isfinite()

template<typename PT , typename RT >
bool blaze::isfinite ( const Proxy< PT, RT > &  proxy)
inline

Returns whether the represented element is finite.

Parameters
proxyThe given proxy instance.
Returns
true in case the represented element is finite, false otherwise.

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.

◆ isinf()

template<typename PT , typename RT >
bool blaze::isinf ( const Proxy< PT, RT > &  proxy)
inline

Returns whether the represented element is infinite.

Parameters
proxyThe given proxy instance.
Returns
true in case the represented element is infinite, false otherwise.

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.

◆ isnan()

template<typename PT , typename RT >
bool blaze::isnan ( const Proxy< PT, RT > &  proxy)
inline

Returns whether the represented element is not-a-number.

Parameters
proxyThe given proxy instance.
Returns
true in case the represented element is not-a-number, false otherwise.

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.

◆ isOne()

template<RelaxationFlag RF, typename PT , typename RT >
bool blaze::isOne ( const Proxy< PT, RT > &  proxy)
inline

Returns whether the represented element is 1.

Parameters
proxyThe given proxy instance.
Returns
true in case the represented element is 1, false otherwise.

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.

◆ isReal()

template<RelaxationFlag RF, typename PT , typename RT >
bool blaze::isReal ( const Proxy< PT, RT > &  proxy)
inline

Returns whether the element represents a real number.

Parameters
proxyThe given proxy instance.
Returns
true in case the element represents a real number, false otherwise.

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.

◆ isZero()

template<RelaxationFlag RF, typename PT , typename RT >
bool blaze::isZero ( const Proxy< PT, RT > &  proxy)
inline

Returns whether the represented element is 0.

Parameters
proxyThe given proxy instance.
Returns
true in case the represented element is 0, false otherwise.

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.

◆ lgamma()

template<typename PT , typename RT >
decltype(auto) blaze::lgamma ( const Proxy< PT, RT > &  proxy)
inline

Computing the natural logarithm of the absolute value of the gamma function of the represented element.

Parameters
proxyThe given proxy instance.
Returns
The natural logarithm of the absolute value of the gamma function of the represented element.

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.

◆ log()

template<typename PT , typename RT >
decltype(auto) blaze::log ( const Proxy< PT, RT > &  proxy)
inline

Computing the natural logarithm of the represented element.

Parameters
proxyThe given proxy instance.
Returns
The natural logarithm of the represented element.

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.

◆ log10()

template<typename PT , typename RT >
decltype(auto) blaze::log10 ( const Proxy< PT, RT > &  proxy)
inline

Computing the common logarithm of the represented element.

Parameters
proxyThe given proxy instance.
Returns
The common logarithm of the represented element.

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.

◆ log1p()

template<typename PT , typename RT >
decltype(auto) blaze::log1p ( const Proxy< PT, RT > &  proxy)
inline

Computing the natural logarithm of x+1 of the represented element.

Parameters
proxyThe given proxy instance.
Returns
The natural logarithm of x+1 of the represented element.

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.

◆ log2()

template<typename PT , typename RT >
decltype(auto) blaze::log2 ( const Proxy< PT, RT > &  proxy)
inline

Computing the binary logarithm of the represented element.

Parameters
proxyThe given proxy instance.
Returns
The binary logarithm of the represented element.

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.

◆ lowerBound() [1/2]

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.

Parameters
proxyThe given access proxy.
iThe row index of the search element. The index has to be in the range $[0..M-1]$.
jThe column index of the search element. The index has to be in the range $[0..N-1]$.
Returns
Iterator to the first index not less than the given index, end() iterator otherwise.

◆ lowerBound() [2/2]

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.

Parameters
proxyThe given access proxy.
indexThe index of the search element. The index has to be in the range $[0..N-1]$.
Returns
Iterator to the first index not less then the given index, end() iterator otherwise.

◆ nextMultiple()

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE constexpr auto blaze::nextMultiple ( T1  value,
T2  factor 
)
constexprnoexcept

Rounds up an integral value to the next multiple of a given factor.

Parameters
valueThe integral value to be rounded up $[1..\infty)$.
factorThe factor of the multiple $[1..\infty)$.
Returns
The next multiple of the given factor.

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!

◆ nonZeros() [1/8]

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.

Parameters
proxyThe given access proxy.
Returns
The number of non-zero elements in the matrix.

◆ nonZeros() [2/8]

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.

Parameters
proxyThe given access proxy.
iThe index of the row/column.
Returns
The number of non-zero elements of row/column i.

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.

◆ nonZeros() [3/8]

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.

Parameters
proxyThe given access proxy.
Returns
The number of non-zero elements in the vector.

Note that the number of non-zero elements is always less than or equal to the current size of the vector.

◆ nonZeros() [4/8]

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.

Parameters
proxyThe given access proxy.
Returns
The number of non-zero elements in the matrix.

◆ nonZeros() [5/8]

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.

Parameters
proxyThe given access proxy.
iThe index of the row/column.
Returns
The number of non-zero elements of row/column i.

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.

◆ nonZeros() [6/8]

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.

Parameters
proxyThe given access proxy.
Returns
The number of non-zero elements in the vector.

Note that the number of non-zero elements is always less than or equal to the current size of the vector.

◆ nonZeros() [7/8]

template<typename Type >
size_t blaze::nonZeros ( initializer_list< initializer_list< Type > >  list)
inlinenoexcept

Determines the number of non-zero elements contained in the given initializer list.

Parameters
listThe given initializer list
Returns
The number of non-zeros elements.

◆ nonZeros() [8/8]

template<typename Type >
size_t blaze::nonZeros ( initializer_list< Type >  list)
inlinenoexcept

Determines the number of non-zero elements contained in the given initializer list.

Parameters
listThe given initializer list
Returns
The number of non-zeros elements.

◆ operator!() [1/3]

constexpr AlignmentFlag blaze::operator! ( AlignmentFlag  flag)
constexprnoexcept

Negating the given alignment flag.

Parameters
flagThe given alignment flag to be negated.
Returns
The negated alignment flag.

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.

◆ operator!() [2/3]

constexpr PaddingFlag blaze::operator! ( PaddingFlag  flag)
constexprnoexcept

Negating the given padding flag.

Parameters
flagThe given padding flag to be negated.
Returns
The negated padding flag.

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.

◆ operator!() [3/3]

constexpr RelaxationFlag blaze::operator! ( RelaxationFlag  flag)
constexprnoexcept

Negating the given relaxation flag.

Parameters
flagThe given relaxation flag to be negated.
Returns
The negated relaxation flag.

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.

◆ operator!=() [1/19]

template<typename T >
constexpr bool blaze::operator!= ( const Accuracy ,
const T &  rhs 
)
constexpr

Inequality comparison between an Accuracy object and a floating point value.

Parameters
rhsThe right-hand side floating point value.
Returns
true if the floating point value is unequal to the accuracy, false if not.

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.

◆ operator!=() [2/19]

template<typename T >
constexpr bool blaze::operator!= ( const Epsilon ,
const T &  rhs 
)
constexpr

Inequality comparison between an Epsilon object and a floating point value.

Parameters
rhsThe right-hand side floating point value.
Returns
true if the floating point value is unequal to epsilon, false if not.

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.

◆ operator!=() [3/19]

constexpr bool blaze::operator!= ( const Infinity ,
const Infinity  
)
constexpr

Inequality comparison between two Infinity objects.

Returns
false.

◆ operator!=() [4/19]

template<typename I >
constexpr bool blaze::operator!= ( const Infinity ,
const NegativeInfinity< I > &   
)
constexpr

Inequality comparison between an Infinity object and a NegativeInfinity object.

Returns
true.

◆ operator!=() [5/19]

template<typename T >
constexpr bool blaze::operator!= ( const Infinity lhs,
const T &  rhs 
)
constexpr

Inequality comparison between an Infinity object and a built-in data type.

Parameters
lhsThe left-hand side Infinity object.
rhsThe right-hand side built-in data value.
Returns
true if the built-in data value is not infinity, false if it is.

This operator works only for built-in data types. The attempt to compare user-defined class types will result in a compile time error.

◆ operator!=() [6/19]

template<typename A , typename T >
constexpr bool blaze::operator!= ( const NegativeAccuracy< A > &  ,
const T &  rhs 
)
constexpr

Inequality comparison between a NegativeAccuracy object and a floating point value.

Parameters
rhsThe right-hand side floating point value.
Returns
true if the value is unequal to the negative accuracy, false if not.

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.

◆ operator!=() [7/19]

template<typename E , typename T >
constexpr bool blaze::operator!= ( const NegativeEpsilon< E > &  ,
const T &  rhs 
)
constexpr

Inequality comparison between a NegativeEpsilon object and a floating point value.

Parameters
rhsThe right-hand side floating point value.
Returns
true if the value is unequal to the negative epsilon, false if not.

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.

◆ operator!=() [8/19]

template<typename I >
constexpr bool blaze::operator!= ( const NegativeInfinity< I > &  ,
const Infinity  
)
constexpr

Inequality comparison between a NegativeInfinity object and an Infinity object.

Returns
true.

◆ operator!=() [9/19]

template<typename I , typename T >
constexpr bool blaze::operator!= ( const NegativeInfinity< I > &  lhs,
const T &  rhs 
)
constexpr

Inequality comparison between an NegativeInfinity object and a built-in data type.

Parameters
lhsThe left-hand side NegativeInfinity object.
rhsThe right-hand side built-in data value.
Returns
true if the built-in data value is not negative infinity, false if it is.

This operator works only for built-in data types. The attempt to compare user-defined class types will result in a compile time error.

◆ operator!=() [10/19]

template<typename I1 , typename I2 >
constexpr bool blaze::operator!= ( const NegativeInfinity< I1 > &  ,
const NegativeInfinity< I2 > &   
)
constexpr

Inequality comparison between two NegativeInfinity objects.

Returns
false.

◆ operator!=() [11/19]

template<typename PT , typename RT , typename T , typename = DisableIf_t< IsProxy_v<T> >>
bool blaze::operator!= ( const Proxy< PT, RT > &  lhs,
const T &  rhs 
)
inline

Inequality comparison between a Proxy object and an object of different type.

Parameters
lhsThe left-hand side Proxy object.
rhsThe right-hand side object of other type.
Returns
true if the referenced value and the other object are not equal, false if they are.

◆ operator!=() [12/19]

template<typename PT1 , typename RT1 , typename PT2 , typename RT2 >
bool blaze::operator!= ( const Proxy< PT1, RT1 > &  lhs,
const Proxy< PT2, RT2 > &  rhs 
)
inline

Inequality comparison between two Proxy objects.

Parameters
lhsThe left-hand side Proxy object.
rhsThe right-hand side Proxy object.
Returns
true if both referenced values are not equal, false if they are.

◆ operator!=() [13/19]

template<typename T >
constexpr bool blaze::operator!= ( const T &  lhs,
const Accuracy  
)
constexpr

Inequality comparison between a floating point value and an Accuracy object.

Parameters
lhsThe left-hand side floating point value.
Returns
true if the floating point value is unequal to the accuracy, false if not.

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.

◆ operator!=() [14/19]

template<typename T >
constexpr bool blaze::operator!= ( const T &  lhs,
const Epsilon  
)
constexpr

Inequality comparison between a floating point value and an Epsilon object.

Parameters
lhsThe left-hand side floating point value.
Returns
true if the floating point value is unequal to epsilon, false if not.

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.

◆ operator!=() [15/19]

template<typename T >
constexpr bool blaze::operator!= ( const T &  lhs,
const Infinity rhs 
)
constexpr

Inequality comparison between a built-in data type and an Infinity object.

Parameters
lhsThe left-hand side built-in data value.
rhsThe right-hand side Infinity object.
Returns
true if the built-in data value is not infinity, false if it is.

This operator works only for built-in data types. The attempt to compare user-defined class types will result in a compile time error.

◆ operator!=() [16/19]

template<typename A , typename T >
constexpr bool blaze::operator!= ( const T &  lhs,
const NegativeAccuracy< A > &   
)
constexpr

Inequality comparison between a floating point value and a NegativeAccuracy object.

Parameters
lhsThe left-hand side floating point value.
Returns
true if the value is unequal to the negative accuracy, false if not.

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.

◆ operator!=() [17/19]

template<typename E , typename T >
constexpr bool blaze::operator!= ( const T &  lhs,
const NegativeEpsilon< E > &   
)
constexpr

Inequality comparison between a floating point value and a NegativeEpsilon object.

Parameters
lhsThe left-hand side floating point value.
Returns
true if the value is unequal to the negative epsilon, false if not.

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.

◆ operator!=() [18/19]

template<typename I , typename T >
constexpr bool blaze::operator!= ( const T &  lhs,
const NegativeInfinity< I > &  rhs 
)
constexpr

Inequality comparison between a built-in data type and an NegativeInfinity object.

Parameters
lhsThe left-hand side built-in data value.
rhsThe right-hand side NegativeInfinity object.
Returns
true if the built-in data value is not negative infinity, false if it is.

This operator works only for built-in data types. The attempt to compare user-defined class types will result in a compile time error.

◆ operator!=() [19/19]

template<typename T , typename PT , typename RT , typename = DisableIf_t< IsProxy_v<T> >>
bool blaze::operator!= ( const T &  lhs,
const Proxy< PT, RT > &  rhs 
)
inline

Inquality comparison between an object of different type and a Proxy object.

Parameters
lhsThe left-hand side object of other type.
rhsThe right-hand side Proxy object.
Returns
true if the other object and the referenced value are not equal, false if they are.

◆ operator*() [1/3]

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

Multiplication between a Proxy object and an object of different type.

Parameters
lhsThe left-hand side Proxy object.
rhsThe right-hand side object of other type.
Returns
The result of the multiplication.

◆ operator*() [2/3]

template<typename PT1 , typename RT1 , typename PT2 , typename RT2 >
decltype(auto) blaze::operator* ( const Proxy< PT1, RT1 > &  lhs,
const Proxy< PT2, RT2 > &  rhs 
)
inline

Multiplication between two Proxy objects.

Parameters
lhsThe left-hand side Proxy object.
rhsThe right-hand side Proxy object.
Returns
The result of the multiplication.

◆ operator*() [3/3]

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

Multiplication between an object of different type and a Proxy object.

Parameters
lhsThe left-hand side object of other type.
rhsThe right-hand side Proxy object.
Returns
The result of the multiplication.

◆ operator*=()

template<typename T , typename PT , typename RT >
decltype(auto) blaze::operator*= ( T &  lhs,
const Proxy< PT, RT > &  rhs 
)
inline

Multiplication assignment of an object of different type with a Proxy object.

Parameters
lhsThe left-hand side object of other type.
rhsThe right-hand side Proxy object.
Returns
The result of the multiplication assignment.

◆ operator+() [1/3]

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

Addition between a Proxy object and an object of different type.

Parameters
lhsThe left-hand side Proxy object.
rhsThe right-hand side object of other type.
Returns
The result of the addition.

◆ operator+() [2/3]

template<typename PT1 , typename RT1 , typename PT2 , typename RT2 >
decltype(auto) blaze::operator+ ( const Proxy< PT1, RT1 > &  lhs,
const Proxy< PT2, RT2 > &  rhs 
)
inline

Addition between two Proxy objects.

Parameters
lhsThe left-hand side Proxy object.
rhsThe right-hand side Proxy object.
Returns
The result of the addition.

◆ operator+() [3/3]

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

Addition between an object of different type and a Proxy object.

Parameters
lhsThe left-hand side object of other type.
rhsThe right-hand side Proxy object.
Returns
The result of the addition.

◆ operator+=()

template<typename T , typename PT , typename RT >
decltype(auto) blaze::operator+= ( T &  lhs,
const Proxy< PT, RT > &  rhs 
)
inline

Addition assignment of an object of different type with a Proxy object.

Parameters
lhsThe left-hand side object of other type.
rhsThe right-hand side Proxy object.
Returns
The result of the addition assignment.

◆ operator-() [1/3]

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

Subtraction between a Proxy object and an object of different type.

Parameters
lhsThe left-hand side Proxy object.
rhsThe right-hand side object of other type.
Returns
The result of the subtraction.

◆ operator-() [2/3]

template<typename PT1 , typename RT1 , typename PT2 , typename RT2 >
decltype(auto) blaze::operator- ( const Proxy< PT1, RT1 > &  lhs,
const Proxy< PT2, RT2 > &  rhs 
)
inline

Subtraction between two Proxy objects.

Parameters
lhsThe left-hand side Proxy object.
rhsThe right-hand side Proxy object.
Returns
The result of the subtraction.

◆ operator-() [3/3]

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

Subtraction between an object of different type and a Proxy object.

Parameters
lhsThe left-hand side object of other type.
rhsThe right-hand side Proxy object.
Returns
The result of the subtraction.

◆ operator-=()

template<typename T , typename PT , typename RT >
decltype(auto) blaze::operator-= ( T &  lhs,
const Proxy< PT, RT > &  rhs 
)
inline

Subtraction assignment of an object of different type with a Proxy object.

Parameters
lhsThe left-hand side object of other type.
rhsThe right-hand side Proxy object.
Returns
The result of the subtraction assignment.

◆ operator/() [1/3]

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

Division between a Proxy object and an object of different type.

Parameters
lhsThe left-hand side Proxy object.
rhsThe right-hand side object of other type.
Returns
The result of the division.

◆ operator/() [2/3]

template<typename PT1 , typename RT1 , typename PT2 , typename RT2 >
decltype(auto) blaze::operator/ ( const Proxy< PT1, RT1 > &  lhs,
const Proxy< PT2, RT2 > &  rhs 
)
inline

Division between two Proxy objects.

Parameters
lhsThe left-hand side Proxy object.
rhsThe right-hand side Proxy object.
Returns
The result of the division.

◆ operator/() [3/3]

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

Division between an object of different type and a Proxy object.

Parameters
lhsThe left-hand side object of other type.
rhsThe right-hand side Proxy object.
Returns
The result of the division.

◆ operator/=()

template<typename T , typename PT , typename RT >
decltype(auto) blaze::operator/= ( T &  lhs,
const Proxy< PT, RT > &  rhs 
)
inline

Division assignment of an object of different type with a Proxy object.

Parameters
lhsThe left-hand side object of other type.
rhsThe right-hand side Proxy object.
Returns
The result of the division assignment.

◆ operator<() [1/11]

template<typename T >
constexpr bool blaze::operator< ( const Accuracy ,
const T &  rhs 
)
constexpr

Less-than comparison between an Accuracy object and a floating point value.

Parameters
rhsThe right-hand side floating point value.
Returns
true if the floatin point value is greater than the accuracy, false if not.

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.

◆ operator<() [2/11]

template<typename T >
constexpr bool blaze::operator< ( const Epsilon ,
const T &  rhs 
)
constexpr

Less-than comparison between an Epsilon object and a floating point value.

Parameters
rhsThe right-hand side floating point value.
Returns
true if the floating point value is greater than epsilon, false if not.

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.

◆ operator<() [3/11]

template<typename A , typename T >
constexpr bool blaze::operator< ( const NegativeAccuracy< A > &  ,
const T &  rhs 
)
constexpr

Less-than comparison between a NegativeAccuracy object and a floating point value.

Parameters
rhsThe right-hand side floating point value.
Returns
true if the value is greater than the negative accuracy, false if not.

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.

◆ operator<() [4/11]

template<typename E , typename T >
constexpr bool blaze::operator< ( const NegativeEpsilon< E > &  ,
const T &  rhs 
)
constexpr

Less-than comparison between a NegativeEpsilon object and a floating point value.

Parameters
rhsThe right-hand side floating point value.
Returns
true if the value is greater than the negative epsilon, false if not.

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.

◆ operator<() [5/11]

template<typename PT , typename RT , typename T , typename = DisableIf_t< IsProxy_v<T> >>
bool blaze::operator< ( const Proxy< PT, RT > &  lhs,
const T &  rhs 
)
inline

Less-than comparison between a Proxy object and an object of different type.

Parameters
lhsThe left-hand side Proxy object.
rhsThe right-hand side object of other type.
Returns
true if the left-hand side referenced value is smaller, false if not.

◆ operator<() [6/11]

template<typename PT1 , typename RT1 , typename PT2 , typename RT2 >
bool blaze::operator< ( const Proxy< PT1, RT1 > &  lhs,
const Proxy< PT2, RT2 > &  rhs 
)
inline

Less-than comparison between two Proxy objects.

Parameters
lhsThe left-hand side Proxy object.
rhsThe right-hand side Proxy object.
Returns
true if the left-hand side referenced value is smaller, false if not.

◆ operator<() [7/11]

template<typename T >
constexpr bool blaze::operator< ( const T &  lhs,
const Accuracy  
)
constexpr

Less-than comparison between a floating point value and an Accuracy object.

Parameters
lhsThe left-hand side floating point value.
Returns
true if the floating point value is smaller than the accuracy, false if not.

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.

◆ operator<() [8/11]

template<typename T >
constexpr bool blaze::operator< ( const T &  lhs,
const Epsilon  
)
constexpr

Less-than comparison between a floating point value and an Epsilon object.

Parameters
lhsThe left-hand side floating point value.
Returns
true if the floating point value is smaller than epsilon, false if not.

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.

◆ operator<() [9/11]

template<typename A , typename T >
constexpr bool blaze::operator< ( const T &  lhs,
const NegativeAccuracy< A > &   
)
constexpr

Less-than comparison between a floating point value and a NegativeAccuracy object.

Parameters
lhsThe left-hand side floating point value.
Returns
true if the value is smaller than the negative accuracy, false if not.

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.

◆ operator<() [10/11]

template<typename E , typename T >
constexpr bool blaze::operator< ( const T &  lhs,
const NegativeEpsilon< E > &   
)
constexpr

Less-than comparison between a floating point value and a NegativeEpsilon object.

Parameters
lhsThe left-hand side floating point value.
Returns
true if the value is smaller than the negative epsilon, false if not.

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.

◆ operator<() [11/11]

template<typename T , typename PT , typename RT , typename = DisableIf_t< IsProxy_v<T> >>
bool blaze::operator< ( const T &  lhs,
const Proxy< PT, RT > &  rhs 
)
inline

Less-than comparison between an object of different type and a Proxy object.

Parameters
lhsThe left-hand side object of other type.
rhsThe right-hand side Proxy object.
Returns
true if the left-hand side other object is smaller, false if not.

◆ operator<<()

template<typename PT , typename RT >
std::ostream & blaze::operator<< ( std::ostream &  os,
const Proxy< PT, RT > &  proxy 
)
inline

Global output operator for the Proxy class template.

Parameters
osReference to the output stream.
proxyReference to a constant proxy object.
Returns
Reference to the output stream.

◆ operator<=() [1/11]

template<typename T >
constexpr bool blaze::operator<= ( const Accuracy ,
const T &  rhs 
)
constexpr

Less-or-equal-than comparison between an Accuracy object and a floating point value.

Parameters
rhsThe right-hand side floating point value.
Returns
true if the floating point value is greater than or equal to the accuracy, false if not.

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.

◆ operator<=() [2/11]

template<typename T >
constexpr bool blaze::operator<= ( const Epsilon ,
const T &  rhs 
)
constexpr

Less-or-equal-than comparison between an Epsilon object and a floating point value.

Parameters
rhsThe right-hand side floating point value.
Returns
true if the floating point value is greater than or equal to epsilon, false if not.

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.

◆ operator<=() [3/11]

template<typename A , typename T >
constexpr bool blaze::operator<= ( const NegativeAccuracy< A > &  ,
const T &  rhs 
)
constexpr

Less-or-equal-than comparison between a NegativeAccuracy object and a floating point value.

Parameters
rhsThe right-hand side floating point value.
Returns
true if the value is greater than or equal to the negative accuracy, false if not.

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.

◆ operator<=() [4/11]

template<typename E , typename T >
constexpr bool blaze::operator<= ( const NegativeEpsilon< E > &  ,
const T &  rhs 
)
constexpr

Less-or-equal-than comparison between a NegativeEpsilon object and a floating point value.

Parameters
rhsThe right-hand side floating point value.
Returns
true if the value is greater than or equal to the negative epsilon, false if not.

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.

◆ operator<=() [5/11]

template<typename PT , typename RT , typename T , typename = DisableIf_t< IsProxy_v<T> >>
bool blaze::operator<= ( const Proxy< PT, RT > &  lhs,
const T &  rhs 
)
inline

Less-or-equal-than comparison between a Proxy object and an object of different type.

Parameters
lhsThe left-hand side Proxy object.
rhsThe right-hand side object of other type.
Returns
true if the left-hand side referenced value is smaller or equal, false if not.

◆ operator<=() [6/11]

template<typename PT1 , typename RT1 , typename PT2 , typename RT2 >
bool blaze::operator<= ( const Proxy< PT1, RT1 > &  lhs,
const Proxy< PT2, RT2 > &  rhs 
)
inline

Less-or-equal-than comparison between two Proxy objects.

Parameters
lhsThe left-hand side Proxy object.
rhsThe right-hand side Proxy object.
Returns
true if the left-hand side referenced value is smaller or equal, false if not.

◆ operator<=() [7/11]

template<typename T >
constexpr bool blaze::operator<= ( const T &  lhs,
const Accuracy  
)
constexpr

Less-or-equal-than comparison between a floating point value and an Accuracy object.

Parameters
lhsThe left-hand side floating point value.
Returns
true if the value is smaller than or equal to the accuracy, false if not.

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.

◆ operator<=() [8/11]

template<typename T >
constexpr bool blaze::operator<= ( const T &  lhs,
const Epsilon  
)
constexpr

Less-or-equal-than comparison between a floating point value and an Epsilon object.

Parameters
lhsThe left-hand side floating point value.
Returns
true if the floating point value is smaller than or equal to epsilon, false if not.

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.

◆ operator<=() [9/11]

template<typename A , typename T >
constexpr bool blaze::operator<= ( const T &  lhs,
const NegativeAccuracy< A > &   
)
constexpr

Less-or-equal-than comparison between a floating point value and a NegativeAccuracy object.

Parameters
lhsThe left-hand side floating point value.
Returns
true if the value is smaller than or equal to the negative accuracy, false if not.

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.

◆ operator<=() [10/11]

template<typename E , typename T >
constexpr bool blaze::operator<= ( const T &  lhs,
const NegativeEpsilon< E > &   
)
constexpr

Less-or-equal-than comparison between a floating point value and a NegativeEpsilon object.

Parameters
lhsThe left-hand side floating point value.
Returns
true if the value is smaller than or equal to the negative epsilon, false if not.

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.

◆ operator<=() [11/11]

template<typename T , typename PT , typename RT , typename = DisableIf_t< IsProxy_v<T> >>
bool blaze::operator<= ( const T &  lhs,
const Proxy< PT, RT > &  rhs 
)
inline

Less-or-equal-than comparison between an object of different type and a Proxy object.

Parameters
lhsThe left-hand side object of other type.
rhsThe right-hand side Proxy object.
Returns
true if the left-hand side other object is smaller or equal, false if not.

◆ operator==() [1/19]

template<typename T >
constexpr bool blaze::operator== ( const Accuracy ,
const T &  rhs 
)
constexpr

Equality comparison between an Accuracy object and a floating point value.

Parameters
rhsThe right-hand side floating point value.
Returns
true if the floating point value is equal to the accuracy, false if not.

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.

◆ operator==() [2/19]

template<typename T >
constexpr bool blaze::operator== ( const Epsilon ,
const T &  rhs 
)
constexpr

Equality comparison between an Epsilon object and a floating point value.

Parameters
rhsThe right-hand side floating point value.
Returns
true if the floating point value is equal to epsilon, false if not.

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.

◆ operator==() [3/19]

constexpr bool blaze::operator== ( const Infinity ,
const Infinity  
)
constexpr

Equality comparison between two Infinity objects.

Returns
true.

◆ operator==() [4/19]

template<typename I >
constexpr bool blaze::operator== ( const Infinity ,
const NegativeInfinity< I > &   
)
constexpr

Equality comparison between an Infinity object and a NegativeInfinity object.

Returns
false.

◆ operator==() [5/19]

template<typename T >
constexpr bool blaze::operator== ( const Infinity lhs,
const T &  rhs 
)
constexpr

Equality comparison between an Infinity object and a built-in data type.

Parameters
lhsThe left-hand side Infinity object.
rhsThe right-hand side built-in data value.
Returns
true if the built-in data value is infinity, false if not.

This operator works only for built-in data types. The attempt to compare user-defined class types will result in a compile time error.

◆ operator==() [6/19]

template<typename A , typename T >
constexpr bool blaze::operator== ( const NegativeAccuracy< A > &  ,
const T &  rhs 
)
constexpr

Equality comparison between a NegativeAccuracy object and a floating point value.

Parameters
rhsThe right-hand side floating point value.
Returns
true if the value is equal to the negative accuracy, false if not.

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.

◆ operator==() [7/19]

template<typename E , typename T >
constexpr bool blaze::operator== ( const NegativeEpsilon< E > &  ,
const T &  rhs 
)
constexpr

Equality comparison between a NegativeEpsilon object and a floating point value.

Parameters
rhsThe right-hand side floating point value.
Returns
true if the value is equal to the negative epsilon, false if not.

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.

◆ operator==() [8/19]

template<typename I >
constexpr bool blaze::operator== ( const NegativeInfinity< I > &  ,
const Infinity  
)
constexpr

Equality comparison between a NegativeInfinity object and an Infinity object.

Returns
false.

◆ operator==() [9/19]

template<typename I , typename T >
constexpr bool blaze::operator== ( const NegativeInfinity< I > &  lhs,
const T &  rhs 
)
constexpr

Equality comparison between an NegativeInfinity object and a built-in data type.

Parameters
lhsThe left-hand side NegativeInfinity object.
rhsThe right-hand side built-in data value.
Returns
true if the built-in data value is negative infinity, false if not.

This operator works only for built-in data types. The attempt to compare user-defined class types will result in a compile time error.

◆ operator==() [10/19]

template<typename I1 , typename I2 >
constexpr bool blaze::operator== ( const NegativeInfinity< I1 > &  ,
const NegativeInfinity< I2 > &   
)
constexpr

Equality comparison between two NegativeInfinity objects.

Returns
true.

◆ operator==() [11/19]

template<typename PT , typename RT , typename T , typename = DisableIf_t< IsProxy_v<T> >>
bool blaze::operator== ( const Proxy< PT, RT > &  lhs,
const T &  rhs 
)
inline

Equality comparison between a Proxy object and an object of different type.

Parameters
lhsThe left-hand side Proxy object.
rhsThe right-hand side object of other type.
Returns
true if the referenced value and the other object are equal, false if they are not.

◆ operator==() [12/19]

template<typename PT1 , typename RT1 , typename PT2 , typename RT2 >
bool blaze::operator== ( const Proxy< PT1, RT1 > &  lhs,
const Proxy< PT2, RT2 > &  rhs 
)
inline

Equality comparison between two Proxy objects.

Parameters
lhsThe left-hand side Proxy object.
rhsThe right-hand side Proxy object.
Returns
true if both referenced values are equal, false if they are not.

◆ operator==() [13/19]

template<typename T >
constexpr bool blaze::operator== ( const T &  lhs,
const Accuracy  
)
constexpr

Equality comparison between a floating point value and an Accuracy object.

Parameters
lhsThe left-hand side floating point value.
Returns
true if the floating point value is equal to the accuracy, false if not.

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.

◆ operator==() [14/19]

template<typename T >
constexpr bool blaze::operator== ( const T &  lhs,
const Epsilon  
)
constexpr

Equality comparison between a floating point value and an Epsilon object.

Parameters
lhsThe left-hand side floating point value.
Returns
true if the floating point value is equal to epsilon, false if not.

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.

◆ operator==() [15/19]

template<typename T >
constexpr bool blaze::operator== ( const T &  lhs,
const Infinity rhs 
)
constexpr

Equality comparison between a built-in data type and an Infinity object.

Parameters
lhsThe left-hand side built-in data value.
rhsThe right-hand side Infinity object.
Returns
true if the built-in data value is infinity, false if not.

This operator works only for built-in data types. The attempt to compare user-defined class types will result in a compile time error.

◆ operator==() [16/19]

template<typename A , typename T >
constexpr bool blaze::operator== ( const T &  lhs,
const NegativeAccuracy< A > &   
)
constexpr

Equality comparison between a floating point value and a NegativeAccuracy object.

Parameters
lhsThe left-hand side floating point value.
Returns
true if the value is equal to the negative accuracy, false if not.

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.

◆ operator==() [17/19]

template<typename E , typename T >
constexpr bool blaze::operator== ( const T &  lhs,
const NegativeEpsilon< E > &   
)
constexpr

Equality comparison between a floating point value and a NegativeEpsilon object.

Parameters
lhsThe left-hand side floating point value.
Returns
true if the value is equal to the negative epsilon, false if not.

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.

◆ operator==() [18/19]

template<typename I , typename T >
constexpr bool blaze::operator== ( const T &  lhs,
const NegativeInfinity< I > &  rhs 
)
constexpr

Equality comparison between a built-in data type and an NegativeInfinity object.

Parameters
lhsThe left-hand side built-in data value.
rhsThe right-hand side NegativeInfinity object.
Returns
true if the built-in data value is negative infinity, false if not.

This operator works only for built-in data types. The attempt to compare user-defined class types will result in a compile time error.

◆ operator==() [19/19]

template<typename T , typename PT , typename RT , typename = DisableIf_t< IsProxy_v<T> >>
bool blaze::operator== ( const T &  lhs,
const Proxy< PT, RT > &  rhs 
)
inline

Equality comparison between an object of different type and a Proxy object.

Parameters
lhsThe left-hand side object of other type.
rhsThe right-hand side Proxy object.
Returns
true if the other object and the referenced value are equal, false if they are not.

◆ operator>() [1/11]

template<typename T >
constexpr bool blaze::operator> ( const Accuracy ,
const T &  rhs 
)
constexpr

Greater-than comparison between an Accuracy object and a floating point value.

Parameters
rhsThe right-hand side floating point value.
Returns
true if the floating point value is smaller than the accuracy, false if not.

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.

◆ operator>() [2/11]

template<typename T >
constexpr bool blaze::operator> ( const Epsilon ,
const T &  rhs 
)
constexpr

Greater-than comparison between an Epsilon object and a floating point value.

Parameters
rhsThe right-hand side floating point value.
Returns
true if the floating point value is smaller than epsilon, false if not.

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.

◆ operator>() [3/11]

template<typename A , typename T >
constexpr bool blaze::operator> ( const NegativeAccuracy< A > &  ,
const T &  rhs 
)
constexpr

Greater-than comparison between a NegativeAccuracy object and a floating point value.

Parameters
rhsThe right-hand side floating point value.
Returns
true if the value is smaller than the negative accuracy, false if not.

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.

◆ operator>() [4/11]

template<typename E , typename T >
constexpr bool blaze::operator> ( const NegativeEpsilon< E > &  ,
const T &  rhs 
)
constexpr

Greater-than comparison between a NegativeEpsilon object and a floating point value.

Parameters
rhsThe right-hand side floating point value.
Returns
true if the value is smaller than the negative epsilon, false if not.

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.

◆ operator>() [5/11]

template<typename PT , typename RT , typename T , typename = DisableIf_t< IsProxy_v<T> >>
bool blaze::operator> ( const Proxy< PT, RT > &  lhs,
const T &  rhs 
)
inline

Greater-than comparison between a Proxy object and an object of different type.

Parameters
lhsThe left-hand side Proxy object.
rhsThe right-hand side object of other type.
Returns
true if the left-hand side referenced value is greater, false if not.

◆ operator>() [6/11]

template<typename PT1 , typename RT1 , typename PT2 , typename RT2 >
bool blaze::operator> ( const Proxy< PT1, RT1 > &  lhs,
const Proxy< PT2, RT2 > &  rhs 
)
inline

Greater-than comparison between two Proxy objects.

Parameters
lhsThe left-hand side Proxy object.
rhsThe right-hand side Proxy object.
Returns
true if the left-hand side referenced value is greater, false if not.

◆ operator>() [7/11]

template<typename T >
constexpr bool blaze::operator> ( const T &  lhs,
const Accuracy  
)
constexpr

Greater-than comparison between a floating point value and an Accuracy object.

Parameters
lhsThe left-hand side floating point value.
Returns
true if the floating point value is greater than the accuracy, false if not.

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.

◆ operator>() [8/11]

template<typename T >
constexpr bool blaze::operator> ( const T &  lhs,
const Epsilon  
)
constexpr

Greater-than comparison between a floating point value and an Epsilon object.

Parameters
lhsThe left-hand side floating point value.
Returns
true if the floating point value is greater than epsilon, false if not.

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.

◆ operator>() [9/11]

template<typename A , typename T >
constexpr bool blaze::operator> ( const T &  lhs,
const NegativeAccuracy< A > &   
)
constexpr

Greater-than comparison between a floating point value and a NegativeAccuracy object.

Parameters
lhsThe left-hand side floating point value.
Returns
true if the value is greater than the negative accuracy, false if not.

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.

◆ operator>() [10/11]

template<typename E , typename T >
constexpr bool blaze::operator> ( const T &  lhs,
const NegativeEpsilon< E > &   
)
constexpr

Greater-than comparison between a floating point value and a NegativeEpsilon object.

Parameters
lhsThe left-hand side floating point value.
Returns
true if the value is greater than the negative epsilon, false if not.

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.

◆ operator>() [11/11]

template<typename T , typename PT , typename RT , typename = DisableIf_t< IsProxy_v<T> >>
bool blaze::operator> ( const T &  lhs,
const Proxy< PT, RT > &  rhs 
)
inline

Greater-than comparison between an object of different type and a Proxy object.

Parameters
lhsThe left-hand side object of other type.
rhsThe right-hand side Proxy object.
Returns
true if the left-hand side other object is greater, false if not.

◆ operator>=() [1/11]

template<typename T >
constexpr bool blaze::operator>= ( const Accuracy ,
const T &  rhs 
)
constexpr

Greater-or-equal-than comparison between an Accuracy object and a floating point value.

Parameters
rhsThe right-hand side floating point value.
Returns
true if the value is smaller than or equal to the accuracy, false if not.

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.

◆ operator>=() [2/11]

template<typename T >
constexpr bool blaze::operator>= ( const Epsilon ,
const T &  rhs 
)
constexpr

Greater-or-equal-than comparison between an Epsilon object and a floating point value.

Parameters
rhsThe right-hand side floating point value.
Returns
true if the floating point value is smaller than or equal to epsilon, false if not.

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.

◆ operator>=() [3/11]

template<typename A , typename T >
constexpr bool blaze::operator>= ( const NegativeAccuracy< A > &  ,
const T &  rhs 
)
constexpr

Greater-or-equal-than comparison between a NegativeAccuracy object and a floating point value.

Parameters
rhsThe right-hand side floating point value.
Returns
true if the value is smaller than or equal to the negative accuracy, false if not.

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.

◆ operator>=() [4/11]

template<typename E , typename T >
constexpr bool blaze::operator>= ( const NegativeEpsilon< E > &  ,
const T &  rhs 
)
constexpr

Greater-or-equal-than comparison between a NegativeEpsilon object and a floating point value.

Parameters
rhsThe right-hand side floating point value.
Returns
true if the value is smaller than or equal to the negative epsilon, false if not.

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.

◆ operator>=() [5/11]

template<typename PT , typename RT , typename T , typename = DisableIf_t< IsProxy_v<T> >>
bool blaze::operator>= ( const Proxy< PT, RT > &  lhs,
const T &  rhs 
)
inline

Greater-or-equal-than comparison between a Proxy object and an object of different type.

Parameters
lhsThe left-hand side Proxy object.
rhsThe right-hand side object of other type.
Returns
true if the left-hand side referenced value is greater or equal, false if not.

◆ operator>=() [6/11]

template<typename PT1 , typename RT1 , typename PT2 , typename RT2 >
bool blaze::operator>= ( const Proxy< PT1, RT1 > &  lhs,
const Proxy< PT2, RT2 > &  rhs 
)
inline

Greater-or-equal-than comparison between two Proxy objects.

Parameters
lhsThe left-hand side Proxy object.
rhsThe right-hand side Proxy object.
Returns
true if the left-hand side referenced value is greater or equal, false if not.

◆ operator>=() [7/11]

template<typename T >
constexpr bool blaze::operator>= ( const T &  lhs,
const Accuracy  
)
constexpr

Less-or-equal-than comparison between a floating point value and an Accuracy object.

Parameters
lhsThe left-hand side floating point value.
Returns
true if the value is greater than or equal to the accuracy, false if not.

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.

◆ operator>=() [8/11]

template<typename T >
constexpr bool blaze::operator>= ( const T &  lhs,
const Epsilon  
)
constexpr

Less-or-equal-than comparison between a floating point value and an Epsilon object.

Parameters
lhsThe left-hand side floating point value.
Returns
true if the floating point value is greater than or equal to epsilon, false if not.

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.

◆ operator>=() [9/11]

template<typename A , typename T >
constexpr bool blaze::operator>= ( const T &  lhs,
const NegativeAccuracy< A > &   
)
constexpr

Less-or-equal-than comparison between a floating point value and a NegativeAccuracy object.

Parameters
lhsThe left-hand side floating point value.
Returns
true if the value is greater than or equal to the negative accuracy, false if not.

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.

◆ operator>=() [10/11]

template<typename E , typename T >
constexpr bool blaze::operator>= ( const T &  lhs,
const NegativeEpsilon< E > &   
)
constexpr

Less-or-equal-than comparison between a floating point value and a NegativeEpsilon object.

Parameters
lhsThe left-hand side floating point value.
Returns
true if the value is greater than or equal to the negative epsilon, false if not.

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.

◆ operator>=() [11/11]

template<typename T , typename PT , typename RT , typename = DisableIf_t< IsProxy_v<T> >>
bool blaze::operator>= ( const T &  lhs,
const Proxy< PT, RT > &  rhs 
)
inline

Greater-or-equal-than comparison between an object of different type and a Proxy object.

Parameters
lhsThe left-hand side object of other type.
rhsThe right-hand side Proxy object.
Returns
true if the left-hand side other object is greater or equal, false if not.

◆ pow()

template<typename PT , typename RT , typename ET >
decltype(auto) blaze::pow ( const Proxy< PT, RT > &  proxy,
const ET &  exp 
)
inline

Computing the exponential value of the represented element.

Parameters
proxyThe given proxy instance.
expThe exponent.
Returns
The exponential value of the represented element.

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.

◆ pow2()

template<typename PT , typename RT , typename ET >
decltype(auto) blaze::pow2 ( const Proxy< PT, RT > &  proxy)
inline

Computing the square value of the represented element.

Parameters
proxyThe given proxy instance.
Returns
The squared value of the represented element.

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.

◆ pow3()

template<typename PT , typename RT , typename ET >
decltype(auto) blaze::pow3 ( const Proxy< PT, RT > &  proxy)
inline

Computing the cube value of the represented element.

Parameters
proxyThe given proxy instance.
Returns
The cubed value of the represented element.

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.

◆ pow4()

template<typename PT , typename RT , typename ET >
decltype(auto) blaze::pow4 ( const Proxy< PT, RT > &  proxy)
inline

Computing the quadruple value of the represented element.

Parameters
proxyThe given proxy instance.
Returns
The quadrupled value of the represented element.

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.

◆ prevMultiple()

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE constexpr auto blaze::prevMultiple ( T1  value,
T2  factor 
)
constexprnoexcept

Rounds down an integral value to the previous multiple of a given factor.

Parameters
valueThe integral value to be rounded down $[1..\infty)$.
factorThe factor of the multiple $[1..\infty)$.
Returns
The previous multiple of the given factor.

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!

◆ real()

template<typename PT , typename RT >
decltype(auto) blaze::real ( const Proxy< PT, RT > &  proxy)
inline

Computing the real part of the represented element.

Parameters
proxyThe given proxy instance.
Returns
The real part of the represented element.

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.

◆ reset() [1/2]

template<typename PT , typename RT >
void blaze::reset ( const Proxy< PT, RT > &  proxy)
inline

Resetting the represented element to the default initial values.

Parameters
proxyThe given proxy instance.
Returns
void

◆ reset() [2/2]

template<typename PT , typename RT >
void blaze::reset ( const Proxy< PT, RT > &  proxy,
size_t  i 
)
inline

Reset the specified row/column of the represented matrix.

Parameters
proxyThe given proxy instance.
iThe index of the row/column to be resetted.
Returns
void

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.

◆ resize() [1/4]

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.

Parameters
proxyThe given access proxy.
mThe new number of rows of the matrix.
nThe new number of columns of the matrix.
preservetrue if the old values of the matrix should be preserved, false if not.
Returns
void
Exceptions
std::invalid_argumentInvalid resize arguments for square matrix.
std::invalid_argumentMatrix 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.

◆ resize() [2/4]

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.

Parameters
proxyThe given access proxy.
nThe new size of the vector.
preservetrue if the old values of the vector should be preserved, false if not.
Returns
void
Exceptions
std::invalid_argumentVector 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.

◆ resize() [3/4]

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.

Parameters
proxyThe given access proxy.
mThe new number of rows of the matrix.
nThe new number of columns of the matrix.
preservetrue if the old values of the matrix should be preserved, false if not.
Returns
void
Exceptions
std::invalid_argumentInvalid 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.

◆ resize() [4/4]

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.

Parameters
proxyThe given access proxy.
nThe new size of the vector.
preservetrue if the old values of the vector should be preserved, false if not.
Returns
void

This function resizes the represented vector to the specified size.

◆ round()

template<typename PT , typename RT >
decltype(auto) blaze::round ( const Proxy< PT, RT > &  proxy)
inline

Computes the nearest integral value to the represented element.

Parameters
proxyThe given proxy instance.
Returns
The nearest integral value to the represented element.

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.

◆ rows() [1/2]

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.

Parameters
proxyThe given access proxy.
Returns
The number of rows of the matrix.

◆ rows() [2/2]

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.

Parameters
proxyThe given access proxy.
Returns
The number of rows of the matrix.

◆ sign()

template<typename PT , typename RT >
decltype(auto) blaze::sign ( const Proxy< PT, RT > &  proxy)
inline

Evaluating the sign of the represented element.

Parameters
proxyThe given proxy instance.
Returns
1 if the value is greater than zero, 0 if it is zero, and -1 if it is less than zero.

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.

◆ sin()

template<typename PT , typename RT >
decltype(auto) blaze::sin ( const Proxy< PT, RT > &  proxy)
inline

Computing the sine of the represented element.

Parameters
proxyThe given proxy instance.
Returns
The sine of the represented element.

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.

◆ sinh()

template<typename PT , typename RT >
decltype(auto) blaze::sinh ( const Proxy< PT, RT > &  proxy)
inline

Computing the hyperbolic sine of the represented element.

Parameters
proxyThe given proxy instance.
Returns
The hyperbolic sine of the represented element.

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.

◆ size() [1/2]

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.

Parameters
proxyThe given access proxy.
Returns
The size of the vector.

◆ size() [2/2]

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.

Parameters
proxyThe given access proxy.
Returns
The size of the vector.

◆ sqrt()

template<typename PT , typename RT >
decltype(auto) blaze::sqrt ( const Proxy< PT, RT > &  proxy)
inline

Computing the square root of the represented element.

Parameters
proxyThe given proxy instance.
Returns
The square root of the represented element.

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.

◆ tan()

template<typename PT , typename RT >
decltype(auto) blaze::tan ( const Proxy< PT, RT > &  proxy)
inline

Computing the tangent of the represented element.

Parameters
proxyThe given proxy instance.
Returns
The tangent of the represented element.

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.

◆ tanh()

template<typename PT , typename RT >
decltype(auto) blaze::tanh ( const Proxy< PT, RT > &  proxy)
inline

Computing the hyperbolic tangent of the represented element.

Parameters
proxyThe given proxy instance.
Returns
The hyperbolic tangent of the represented element.

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.

◆ trans()

template<typename PT , typename RT >
decltype(auto) blaze::trans ( const Proxy< PT, RT > &  proxy)
inline

Computing the transpose of the represented element.

Parameters
proxyThe given proxy instance.
Returns
The transpose of the represented element.

This function returns an expression representing the transpose of the element represented by the proxy.

◆ transpose()

template<typename PT , typename RT >
void blaze::transpose ( const Proxy< PT, RT > &  proxy)
inline

In-place transpose of the represented matrix element.

Parameters
proxyThe given proxy instance.
Returns
void
Exceptions
std::invalid_argumentInvalid access to restricted element.
std::logic_errorMatrix cannot be transposed.

This function transposes the represented matrix in-place. The transpose operation fails if ...

  • ... the represented matrix has a fixed size and is non-square;
  • ... the represented matrix is a triangular matrix.

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.

◆ trunc()

template<typename PT , typename RT >
decltype(auto) blaze::trunc ( const Proxy< PT, RT > &  proxy)
inline

Computes the nearest integral value that is not greater than the represented element.

Parameters
proxyThe given proxy instance.
Returns
The nearest integral value that is not greater than the represented element.

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.

◆ upperBound() [1/2]

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.

Parameters
proxyThe given access proxy.
iThe row index of the search element. The index has to be in the range $[0..M-1]$.
jThe column index of the search element. The index has to be in the range $[0..N-1]$.
Returns
Iterator to the first index greater than the given index, end() iterator otherwise.

◆ upperBound() [2/2]

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.

Parameters
proxyThe given access proxy.
indexThe index of the search element. The index has to be in the range $[0..N-1]$.
Returns
Iterator to the first index greater then the given index, end() iterator otherwise.

Variable Documentation

◆ accuracy

constexpr Accuracy blaze::accuracy
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.

◆ epsilon

constexpr Epsilon blaze::epsilon
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.

◆ inf

constexpr Infinity blaze::inf
constexpr

Global Infinity instance.

The blaze::inf instance can be used wherever a built-in data type is expected. It is implicitly converted to the corresponding built-in data type and represents its largest possible data value.