Modules | Classes | Macros | Functions | Variables
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.The NegativeAccuracy class is a wrapper class around the functionality of the blaze::Limits class. It represents the negative computation accuracy of the Blaze library for any floating point data type. In order to assign a negative accuracy value, the NegativeAccuracy class can be implicitly converted to the three built-in floating point data types float, double and long double. More...
 
class  blaze::Accuracy
 Computation accuracy for floating point data types.The Accuracy class is a wrapper class around the functionality of the blaze::Limits class. It represents the computation accuracy of the Blaze library for any floating point data type. In order to assign an accuracy value, the Accuracy class can be implicitly converted to the three built-in floating point data types float, double and long double.
In order to handle accuracy values conveniently, the global Accuracy instance blaze::accuracy is provided, which can be used wherever a floating point data value is required. More...
 
class  blaze::DenseIterator< Type, AF >
 Implementation of a generic iterator for dense vectors and matrices.The DenseIterator represents a generic random-access iterator that can be used for dense vectors and specific rows/columns of dense matrices. More...
 
class  blaze::NegativeEpsilon< E >
 Negative epsilon value for floating point data types.The NegativeEpsilon class is a wrapper class around the functionality of the blaze::Limits class. It represents the negative smallest difference between two values of any floating point data type. In order to assign a negative epsilon value, the Epsilon class can be implicitly converted to the three built-in floating point data types float, double and long double. More...
 
class  blaze::Epsilon
 Numerical epsilon value for floating point data types.The Epsilon class is a wrapper class around the functionality of the blaze::Limits class. It represents the smallest difference between two values of any floating point data type. In order to assign an epsilon value, the Epsilon class can be implicitly converted to the three built-in floating point data types float, double and long double.
In order to handle epsilon values conveniently, the global Epsilon instance blaze::epsilon is provided, which can be used wherever a floating point data type is required. More...
 
struct  blaze::AddExpr
 Base class for all addition expression templates.The AddExpr class serves as a tag for all expression templates that implement mathematical additions. All classes, that represent a mathematical addition (vector additions and matrix additions) and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as addition expression template. Only in case a class is derived from the AddExpr base class, the IsAddExpr type trait recognizes the class as valid addition expression template. More...
 
struct  blaze::Computation
 Base class for all compute expression templates.The Computation class serves as a tag for all computational expression templates. All classes, that represent a mathematical computation (addition, subtraction, multiplication, division, absolute value calculation, ...) and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as computational expression template. Only in case a class is derived from the Computation base class, the IsComputation type trait recognizes the class as valid computational expression template. More...
 
struct  blaze::CrossExpr
 Base class for all cross product expression templates.The CrossExpr class serves as a tag for all expression templates that implement mathematical cross products. All classes, that represent a mathematical cross product and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as cross product expression template. Only in case a class is derived from the CrossExpr base class, the IsCrossExpr type trait recognizes the class as valid cross product expression template. More...
 
struct  blaze::DivExpr
 Base class for all division expression templates.The DivExpr class serves as a tag for all expression templates that implement mathematical divisions. All classes, that represent a mathematical division (vector/scalar divisions and matrix/scalar division) and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as division expression template. Only in case a class is derived from the DivExpr base class, the IsDivExpr type trait recognizes the class as valid division expression template. More...
 
struct  blaze::EvalExpr
 Base class for all evaluation expression templates.The EvalExpr class serves as a tag for all expression templates that implement an evaluation operation. All classes, that represent an evaluation operation and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as evaluation expression template. Only in case a class is derived from the EvalExpr base class, the IsEvalExpr type trait recognizes the class as valid evaluation expression template. More...
 
struct  blaze::Expression
 Base class for all expression templates.The Expression class is the base class for all expression templates. All classes, that represent a mathematical operation and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as expression template. Only in case a class is derived from the Expression base class, the IsExpression type trait recognizes the class as valid expression template. More...
 
struct  blaze::ForEachExpr
 Base class for all for-each expression templates.The ForEachExpr class serves as a tag for all expression templates that represent a unary, custom operation. All classes, that represent a custom operation and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as for-each expression template. Only in case a class is derived from the ForEachExpr base class, the IsForEachExpr type trait recognizes the class as valid for-each expression template. More...
 
struct  blaze::MatEvalExpr
 Base class for all matrix evaluation expression templates.The MatEvalExpr class serves as a tag for all expression templates that implement a matrix evaluation operation. All classes, that represent a matrix evaluation operation and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as matrix evaluation expression template. Only in case a class is derived from the MatEvalExpr base class, the IsMatEvalExpr type trait recognizes the class as valid matrix evaluation expression template. More...
 
struct  blaze::MatForEachExpr
 Base class for all matrix for-each expression templates.The MatForEachExpr class serves as a tag for all expression templates that represent a unary, custom operation on a matrix. All classes, that represent a matrix custom operation and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as matrix for-each expression template. Only in case a class is derived from the MatForEachExpr base class, the IsMatForEachExpr type trait recognizes the class as valid matrix for-each expression template. More...
 
struct  blaze::MatInvExpr
 Base class for all matrix inversion expression templates.The MatInvExpr class serves as a tag for all expression templates that implement a matrix inversion operation. All classes, that represent a matrix inversion operation and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as matrix inversion expression template. Only in case a class is derived from the MatInvExpr base class, the IsMatInvExpr type trait recognizes the class as valid matrix inversion expression template. More...
 
struct  blaze::MatMatAddExpr
 Base class for all matrix/matrix addition expression templates.The MatMatAddExpr class serves as a tag for all expression templates that implement a matrix/matrix addition. All classes, that represent a matrix addition and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as matrix addition expression template. Only in case a class is derived from the MatMatAddExpr base class, the IsMatMatAddExpr type trait recognizes the class as valid matrix addition expression template. More...
 
struct  blaze::MatMatMultExpr
 Base class for all matrix/matrix multiplication expression templates.The MatMatMultExpr class serves as a tag for all expression templates that implement a matrix/matrix multiplication. All classes, that represent a matrix multiplication and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as matrix multiplication expression template. Only in case a class is derived from the MatMatMultExpr base class, the IsMatMatMultExpr type trait recognizes the class as valid matrix multiplication expression template. More...
 
struct  blaze::MatMatSubExpr
 Base class for all matrix/matrix subtraction expression templates.The MatMatSubExpr class serves as a tag for all expression templates that implement a matrix/matrix subtraction. All classes, that represent a matrix subtraction and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as matrix subtraction expression template. Only in case a class is derived from the MatMatSubExpr base class, the IsMatMatSubExpr type trait recognizes the class as valid matrix subtraction expression template. More...
 
struct  blaze::MatScalarDivExpr
 Base class for all matrix/scalar divsion expression templates.The MatScalarDivExpr class serves as a tag for all expression templates that implement a matrix/scalar divsion. All classes, that represent a matrix/scalar divsion and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as matrix/scalar divsion expression template. Only in case a class is derived from the MatScalarDivExpr base class, the IsMatScalarDivExpr type trait recognizes the class as valid matrix/scalar divsion expression template. More...
 
struct  blaze::MatScalarMultExpr
 Base class for all matrix/scalar multiplication expression templates.The MatScalarMultExpr class serves as a tag for all expression templates that implement a matrix/scalar multiplication. All classes, that represent a matrix/scalar multiplication and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as matrix/scalar multiplication expression template. Only in case a class is derived from the MatScalarMultExpr base class, the IsMatScalarMultExpr type trait recognizes the class as valid matrix/scalar multiplication expression template. More...
 
struct  blaze::MatSerialExpr
 Base class for all matrix serial evaluation expression templates.The MatSerialExpr class serves as a tag for all expression templates that enforce a serial evaluation of a matrix. All classes, that represent a matrix serialization operation and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as matrix serial evaluation expression template. Only in case a class is derived from the MatSerialExpr base class, the IsMatSerialExpr type trait recognizes the class as valid matrix serial evaluation expression template. More...
 
struct  blaze::MatTransExpr
 Base class for all matrix transposition expression templates.The MatTransExpr class serves as a tag for all expression templates that implement a matrix transposition operation. All classes, that represent a matrix transposition operation and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as matrix transposition expression template. Only in case a class is derived from the MatTransExpr base class, the IsMatTransExpr type trait recognizes the class as valid matrix transposition expression template. More...
 
struct  blaze::MatVecMultExpr
 Base class for all matrix/vector multiplication expression templates.The MatVecMultExpr class serves as a tag for all expression templates that implement a matrix/vector multiplication. All classes, that represent a matrix/vector multiplication and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as matrix/vector multiplication expression template. Only in case a class is derived from the MatVecMultExpr base class, the IsMatVecMultExpr type trait recognizes the class as valid matrix/vector multiplication expression template. More...
 
struct  blaze::MultExpr
 Base class for all multiplication expression templates.The MultExpr class serves as a tag for all expression templates that implement mathematical multiplications. All classes, that represent a mathematical multiplication (element-wise vector multiplications, matrix/vector multiplications, vector/matrix multiplications and matrix/matrix multiplications) and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as multiplication expression template. Only in case a class is derived from the MultExpr base class, the IsMultExpr type trait recognizes the class as valid multiplication expression template. More...
 
struct  blaze::SerialExpr
 Base class for all serial evaluation expression templates.The SerialExpr class serves as a tag for all expression templates that enforce a serial evaluation. All classes, that represent a serialization operation and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as serial evaluation expression template. Only in case a class is derived from the SerialExpr base class, the IsSerialExpr type trait recognizes the class as valid serial evaluation expression template. More...
 
struct  blaze::SubExpr
 Base class for all subtraction expression templates.The SubExpr class serves as a tag for all expression templates that implement mathematical subtractions. All classes, that represent a mathematical subtraction (vector subtractions and matrix subtractions) and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as subtraction expression template. Only in case a class is derived from the SubExpr base class, the IsSubExpr type trait recognizes the class as valid subtraction expression template. More...
 
struct  blaze::TransExpr
 Base class for all transposition expression templates.The TransExpr class serves as a tag for all expression templates that implement mathematical transpositions. All classes, that represent a mathematical transposition (vector transpositions and matrix transpositions) and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as transposition expression template. Only in case a class is derived from the TransExpr base class, the IsTransExpr type trait recognizes the class as valid transposition expression template. More...
 
struct  blaze::TVecMatMultExpr
 Base class for all vector/matrix multiplication expression templates.The TVecMatMultExpr class serves as a tag for all expression templates that implement a vector/matrix multiplication. All classes, that represent a vector/matrix multiplication and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as vector/matrix multiplication expression template. Only in case a class is derived from the TVecMatMultExpr base class, the IsTVecMatMultExpr type trait recognizes the class as valid vector/matrix multiplication expression template. More...
 
struct  blaze::VecEvalExpr
 Base class for all vector evaluation expression templates.The VecEvalExpr class serves as a tag for all expression templates that implement a vector evaluation operation. All classes, that represent a vector evaluation operation and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as vector evaluation expression template. Only in case a class is derived from the VecEvalExpr base class, the IsVecEvalExpr type trait recognizes the class as valid vector evaluation expression template. More...
 
struct  blaze::VecForEachExpr
 Base class for all vector for-each expression templates.The VecForEachExpr class serves as a tag for all expression templates that represent a unary, custom operation on a vector. All classes, that represent a vector custom operation and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as vector for-each expression template. Only in case a class is derived from the VecForEachExpr base class, the IsVecForEachExpr type trait recognizes the class as valid vector for-each expression template. More...
 
struct  blaze::VecScalarDivExpr
 Base class for all vector/scalar division expression templates.The VecScalarDivExpr class serves as a tag for all expression templates that implement a vector/scalar division. All classes, that represent a vector/scalar division and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as vector/scalar division expression template. Only in case a class is derived from the VecScalarDivExpr base class, the IsVecScalarDivExpr type trait recognizes the class as valid vector/scalar division expression template. More...
 
struct  blaze::VecScalarMultExpr
 Base class for all vector/scalar multiplication expression templates.The VecScalarMultExpr class serves as a tag for all expression templates that implement a vector/scalar multiplication. All classes, that represent a vector/scalar multiplication and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as vector/scalar multiplication expression template. Only in case a class is derived from the VecScalarMultExpr base class, the IsVecScalarMultExpr type trait recognizes the class as valid vector/scalar multiplication expression template. More...
 
struct  blaze::VecSerialExpr
 Base class for all vector serial evaluation expression templates.The VecSerialExpr class serves as a tag for all expression templates that enforce a serial evaluation of a vector. All classes, that represent a vector serialization operation and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as vector serial evaluation expression template. Only in case a class is derived from the VecSerialExpr base class, the IsVecSerialExpr type trait recognizes the class as valid vector serial evaluation expression template. More...
 
struct  blaze::VecTransExpr
 Base class for all vector transposition expression templates.The VecTransExpr class serves as a tag for all expression templates that implement a vector transposition operation. All classes, that represent a vector transposition operation and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as vector transposition expression template. Only in case a class is derived from the VecTransExpr base class, the IsVecTransExpr type trait recognizes the class as valid vector transposition expression template. More...
 
struct  blaze::VecTVecMultExpr
 Base class for all outer product expression templates.The VecTVecMultExpr class serves as a tag for all expression templates that implement mathematical outer products (i.e. multiplications between a column vector and a row vector). All classes, that represent a mathematical outer product and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as outer product expression template. Only in case a class is derived from the VecTVecMultExpr base class, the IsVecTVecMultExpr type trait recognizes the class as valid outer product expression template. More...
 
struct  blaze::VecVecAddExpr
 Base class for all vector/vector addition expression templates.The VecVecAddExpr class serves as a tag for all expression templates that implement a vector/vector addition. All classes, that represent a vector addition and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as vector addition expression template. Only in case a class is derived from the VecVecAddExpr base class, the IsVecVecAddExpr type trait recognizes the class as valid vector addition expression template. More...
 
struct  blaze::VecVecDivExpr
 Base class for all vector/vector division expression templates.The VecVecDivExpr class serves as a tag for all expression templates that implement a vector/vector division. All classes, that represent a vector division and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as vector division expression template. Only in case a class is derived from the VecVecDivExpr base class, the IsVecVecDivExpr type trait recognizes the class as valid vector division expression template. More...
 
struct  blaze::VecVecMultExpr
 Base class for all vector/vector multiplication expression templates.The VecVecMultExpr class serves as a tag for all expression templates that implement a vector/vector multiplication. All classes, that represent a vector multiplication and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as vector multiplication expression template. Only in case a class is derived from the VecVecMultExpr base class, the IsVecVecMultExpr type trait recognizes the class as valid vector multiplication expression template. More...
 
struct  blaze::VecVecSubExpr
 Base class for all vector/vector subtraction expression templates.The VecVecSubExpr class serves as a tag for all expression templates that implement a vector/vector subtraction. All classes, that represent a vector subtraction and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as vector subtraction expression template. Only in case a class is derived from the VecVecSubExpr base class, the IsVecVecSubExpr type trait recognizes the class as valid vector subtraction expression template. More...
 
struct  blaze::View
 Base class for all views.The View class serves as a tag for all views (subvectors, submatrices, rows, columns, ...). All classes that represent a view and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as a view. Only in case a class is derived from the View base class, the IsView type trait recognizes the class as valid view. More...
 
class  blaze::NegativeInfinity< I >
 Negative infinity for built-in data types.The NegativeInfinity class is a wrapper class around the functionality of the blaze::Limits class to provide the possibility to assign negative infinity values to built-in data types. As negative infinity value, the largest possible negative value of the corresponding data type is used. In order to assign the negative infinity value, the NegativeInfinity class can be implicitly converted to all signed integral and floating point data types: More...
 
class  blaze::Infinity
 Positive infinity for built-in data types.The Infinity class is a wrapper class around the functionality of the blaze::Limits class to provide the possiblity to assign a positive infinity value to built-in data types. As positive infinity value, the largest possible positive value of the corresponding data type is used. In order to assign the positive infinity value, the Infinity class can be implicitly converted to the following 13 built-in integral and floating point data types: More...
 
class  blaze::ComplexProxy< PT, CT >
 Proxy backend for complex types.The ComplexProxy class serves as a backend for the Proxy class. It is used in case the data type represented by the proxy is a complex number and augments the Proxy interface by the complete interface required of complex numbers. More...
 
class  blaze::DefaultProxy< PT, RT >
 Default proxy backend for built-in and alternate user-specific class types.The DefaultProxy class serves as a backend for the Proxy class. It is used in case the data type represented by the proxy is a built-in or alternate user-specific class type. This proxy does not augment the Proxy interface by any additional interface. More...
 
class  blaze::DenseMatrixProxy< PT, MT >
 Proxy backend for dense matrix types.The DenseMatrixProxy class serves as a backend for the Proxy class. It is used in case the data type represented by the proxy is a dense matrix and augments the Proxy interface by the complete interface required of dense matrices. More...
 
class  blaze::DenseVectorProxy< PT, VT >
 Proxy backend for dense vector types.The DenseVectorProxy class serves as a backend for the Proxy class. It is used in case the data type represented by the proxy is a dense vector and augments the Proxy interface by the complete interface required of dense vectors. More...
 
class  blaze::Proxy< PT, RT >
 Proxy base class.The Proxy class is a base class for all proxy classes within the Blaze library that may represent non-numeric data types (vectors, matrices, ...). It augments the interface of the deriving proxy class depending on the data type represented by the proxy. In addition, it provides an abstraction from the actual type of the proxy, but enables a type-safe conversion back to this type via the 'Curiously Recurring Template Pattern' (CRTP). More...
 
class  blaze::SparseMatrixProxy< PT, MT >
 Proxy backend for sparse matrix types.The SparseMatrixProxy class serves as a backend for the Proxy class. It is used in case the data type represented by the proxy is a sparse matrix and augments the Proxy interface by the complete interface required of sparse matrices. More...
 
class  blaze::SparseVectorProxy< PT, VT >
 Proxy backend for sparse vector types.The SparseVectorProxy class serves as a backend for the Proxy class. It is used in case the data type represented by the proxy is a sparse vector and augments the Proxy interface by the complete interface required of sparse vectors. More...
 
struct  blaze::SparseElement
 Base class for all sparse element types.The SparseElement class is the base class for all sparse element types. All types that conceptually represent a sparse vector or matrix element and that provide a value() and an index() member function have to derive from this class in order to qualify as sparse element. Only in case a class is derived from the SparseElement base class, the IsSparseElement type trait recognizes the class as valid sparse element. More...
 
class  blaze::ValueIndexPair< Type >
 Index-value-pair for sparse vectors and matrices.The ValueIndexPair class represents a single index-value-pair of a sparse vector or sparse matrix. More...
 
class  blaze::initializer_list
 Initializer list type of the Blaze library. 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.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. 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.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. More...
 

Functions

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE constexpr bool blaze::lessThan (const T1 &a, const T2 &b) noexcept(IsBuiltin< CommonType_< T1, T2 > >::value)
 Generic less-than comparison. More...
 
template<typename Type >
size_t blaze::determineColumns (initializer_list< initializer_list< Type > > list) noexcept
 Determine the maximum number of columns specified by the given initializer list. More...
 
template<typename PT , typename RT >
auto blaze::erf (const Proxy< PT, RT > &proxy) -> decltype(erf(std::declval< RepresentedType_< PT > >()))
 Computing the error function of the represented element. More...
 
template<typename PT , typename RT >
auto blaze::erfc (const Proxy< PT, RT > &proxy) -> decltype(erfc(std::declval< RepresentedType_< PT > >()))
 Computing the complementary error function of the represented element. More...
 

Variables

const Accuracy blaze::accuracy
 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.
 
const bool blaze::unaligned = false
 Alignment flag for unaligned vectors and matrices.Via this flag it is possible to specify subvectors, submatrices, custom vectors and matrices as unaligned. The following example demonstrates the setup of an unaligned subvector: More...
 
const bool blaze::aligned = true
 Alignment flag for aligned vectors and matrices.Via this flag it is possible to specify subvectors, submatrices, custom vectors and matrices as aligned. The following example demonstrates the setup of an aligned subvector: More...
 
const real_t blaze::M_E = 2.7182818284590452353602874713526625
 Definition of the mathematical constant $ e $.
 
const real_t blaze::M_LOG2E = 1.4426950408889634073599246810018921
 Definition of the mathematical constant $ \log_2 e $.
 
const real_t blaze::M_LOG10E = 0.4342944819032518276511289189166051
 Definition of the mathematical constant $ \log_{10} e $.
 
const real_t blaze::M_LN2 = 0.6931471805599453094172321214581766
 Definition of the mathematical constant $ \ln 2 $.
 
const real_t blaze::M_LN10 = 2.3025850929940456840179914546843642
 Definition of the mathematical constant $ \ln 10 $.
 
const real_t blaze::M_PI = 3.1415926535897932384626433832795029
 Definition of the mathematical constant $ \pi $.
 
const real_t blaze::M_SQRT2 = 1.4142135623730950488016887242096981
 Definition of the mathematical constant $ \sqrt{2} $.
 
const real_t blaze::M_SQRT3 = 1.7320508075688772935274463415058724
 Definition of the mathematical constant $ \sqrt{3} $.
 
const Epsilon blaze::epsilon
 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.
 
const Infinity blaze::inf
 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.
 
const bool blaze::unpadded = false
 Padding flag for unpadded vectors and matrices.Via this flag it is possible to specify custom vectors and matrices as unpadded. The following example demonstrates the setup of an unaligned, unpadded custom row vector of size 7: More...
 
const bool blaze::padded = true
 Padding flag for padded vectors and matrices.Via this flag it is possible to specify custom vectors and matrices as aligned. The following example demonstrates the setup of an aligned, padded custom row vector of size 7: More...
 

Accuracy operators

template<typename A , typename T >
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 >
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 >
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 >
bool blaze::operator!= (const T &lhs, const NegativeAccuracy< A > & )
 Inequality comparison between a floating point value and a NegativeAccuracy object. More...
 
template<typename T >
bool blaze::operator== (const Accuracy &, const T &rhs)
 Equality comparison between an Accuracy object and a floating point value. More...
 
template<typename T >
bool blaze::operator== (const T &lhs, const Accuracy & )
 Equality comparison between a floating point value and an Accuracy object. More...
 
template<typename T >
bool blaze::operator!= (const Accuracy &, const T &rhs)
 Inequality comparison between an Accuracy object and a floating point value. More...
 
template<typename T >
bool blaze::operator!= (const T &lhs, const Accuracy & )
 Inequality comparison between a floating point value and an Accuracy object. More...
 
template<typename A , typename T >
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 >
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 >
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 >
bool blaze::operator> (const T &lhs, const NegativeAccuracy< A > & )
 Greater-than comparison between a floating point value and a NegativeAccuracy object. More...
 
template<typename T >
bool blaze::operator< (const Accuracy &, const T &rhs)
 Less-than comparison between an Accuracy object and a floating point value. More...
 
template<typename T >
bool blaze::operator< (const T &lhs, const Accuracy & )
 Less-than comparison between a floating point value and an Accuracy object. More...
 
template<typename T >
bool blaze::operator> (const Accuracy &, const T &rhs)
 Greater-than comparison between an Accuracy object and a floating point value. More...
 
template<typename T >
bool blaze::operator> (const T &lhs, const Accuracy & )
 Greater-than comparison between a floating point value and an Accuracy object. More...
 
template<typename T >
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 >
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 >
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 >
bool blaze::operator>= (const T &lhs, const Accuracy & )
 Less-or-equal-than comparison between a floating point value and an Accuracy object. More...
 

NegativeEpsilon operators

template<typename E , typename T >
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 >
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 >
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 >
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 >
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 >
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 >
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 >
bool blaze::operator> (const T &lhs, const NegativeEpsilon< E > & )
 Greater-than comparison between a floating point value and a NegativeEpsilon object. More...
 

Epsilon operators

template<typename T >
bool blaze::operator== (const Epsilon &, const T &rhs)
 Equality comparison between an Epsilon object and a floating point value. More...
 
template<typename T >
bool blaze::operator== (const T &lhs, const Epsilon & )
 Equality comparison between a floating point value and an Epsilon object. More...
 
template<typename T >
bool blaze::operator!= (const Epsilon &, const T &rhs)
 Inequality comparison between an Epsilon object and a floating point value. More...
 
template<typename T >
bool blaze::operator!= (const T &lhs, const Epsilon & )
 Inequality comparison between a floating point value and an Epsilon object. More...
 
template<typename T >
bool blaze::operator< (const Epsilon &, const T &rhs)
 Less-than comparison between an Epsilon object and a floating point value. More...
 
template<typename T >
bool blaze::operator< (const T &lhs, const Epsilon & )
 Less-than comparison between a floating point value and an Epsilon object. More...
 
template<typename T >
bool blaze::operator> (const Epsilon &, const T &rhs)
 Greater-than comparison between an Epsilon object and a floating point value. More...
 
template<typename T >
bool blaze::operator> (const T &lhs, const Epsilon & )
 Greater-than comparison between a floating point value and an Epsilon object. More...
 
template<typename T >
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 >
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 >
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 >
bool blaze::operator>= (const T &lhs, const Epsilon & )
 Less-or-equal-than comparison between a floating point value and an Epsilon object. More...
 

Mathematical utility functions

template<typename T >
constexpr int blaze::sign (T a) noexcept
 Sign function. More...
 
template<typename T >
size_t blaze::digits (T a) noexcept
 Returns the number of valid digits of an integral value. More...
 
template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE constexpr CommonType_< T1, T2 > blaze::min (const T1 &a, const T2 &b) noexcept(All< IsNumeric, T1, T2 >::value)
 Minimum function for two data values. More...
 
template<typename T1 , typename T2 , typename... Ts>
BLAZE_ALWAYS_INLINE constexpr CommonType_< T1, T2, Ts... > blaze::min (const T1 &a, const T2 &b, const Ts &...args) noexcept(All< IsNumeric, T1, T2, Ts... >::value)
 Minimum function for at least three data values. More...
 
template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE constexpr CommonType_< T1, T2 > blaze::max (const T1 &a, const T2 &b) noexcept(All< IsNumeric, T1, T2 >::value)
 Maximum function for two data values. More...
 
template<typename T1 , typename T2 , typename... Ts>
BLAZE_ALWAYS_INLINE constexpr CommonType_< T1, T2, Ts... > blaze::max (const T1 &a, const T2 &b, const Ts &...args) noexcept(All< IsNumeric, T1, T2, Ts... >::value)
 Maximum function for at least three data values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE constexpr T blaze::nextMultiple (T value, T 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 bool blaze::lessThan (T1 a, T2 b) noexcept(IsBuiltin< CommonType_< T1, T2 > >::value)
 

NegativeInfinity operators

template<typename I1 , typename I2 >
bool blaze::operator== (const NegativeInfinity< I1 > &lhs, const NegativeInfinity< I2 > &rhs)
 Equality comparison between two NegativeInfinity objects. More...
 
template<typename I , typename T >
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 >
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 >
bool blaze::operator!= (const NegativeInfinity< I1 > &lhs, const NegativeInfinity< I2 > &rhs)
 Inequality comparison between two NegativeInfinity objects. More...
 
template<typename I , typename T >
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 >
bool blaze::operator!= (const T &lhs, const NegativeInfinity< I > &rhs)
 Inequality comparison between a built-in data type and an NegativeInfinity object. More...
 

Infinity operators

bool blaze::operator== (const Infinity &lhs, const Infinity &rhs)
 Equality comparison between two Infinity objects. More...
 
template<typename I >
bool blaze::operator== (const Infinity &lhs, const NegativeInfinity< I > &rhs)
 Equality comparison between an Infinity object and a NegativeInfinity object. More...
 
template<typename I >
bool blaze::operator== (const NegativeInfinity< I > &lhs, const Infinity &rhs)
 Equality comparison between a NegativeInfinity object and an Infinity object. More...
 
template<typename T >
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 >
bool blaze::operator== (const T &lhs, const Infinity &rhs)
 Equality comparison between a built-in data type and an Infinity object. More...
 
bool blaze::operator!= (const Infinity &lhs, const Infinity &rhs)
 Inequality comparison between two Infinity objects. More...
 
template<typename I >
bool blaze::operator!= (const Infinity &lhs, const NegativeInfinity< I > &rhs)
 Inequality comparison between an Infinity object and a NegativeInfinity object. More...
 
template<typename I >
bool blaze::operator!= (const NegativeInfinity< I > &lhs, const Infinity &rhs)
 Inequality comparison between a NegativeInfinity object and an Infinity object. More...
 
template<typename T >
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 >
bool blaze::operator!= (const T &lhs, const Infinity &rhs)
 Inequality comparison between a built-in data type and an Infinity 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...
 
template<typename PT , typename MT >
BLAZE_ALWAYS_INLINE void blaze::reset (const DenseMatrixProxy< PT, MT > &proxy)
 Resetting the represented element to the default initial values. More...
 
template<typename PT , typename MT >
BLAZE_ALWAYS_INLINE void blaze::reset (const DenseMatrixProxy< PT, MT > &proxy, size_t i)
 Reset the specified row/column of the represented matrix. More...
 
template<typename PT , typename MT >
BLAZE_ALWAYS_INLINE void blaze::clear (const DenseMatrixProxy< PT, MT > &proxy)
 Clearing 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...
 
template<typename PT , typename VT >
BLAZE_ALWAYS_INLINE void blaze::reset (const DenseVectorProxy< PT, VT > &proxy)
 Resetting the represented vector to the default initial values. More...
 
template<typename PT , typename VT >
BLAZE_ALWAYS_INLINE void blaze::clear (const DenseVectorProxy< PT, VT > &proxy)
 Clearing the represented vector. More...
 

Proxy operators

template<typename PT1 , typename RT1 , typename PT2 , typename RT2 >
AddExprTrait_< RT1, RT2 > 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 >
DisableIf_< IsProxy< T >, AddExprTrait_< RT, T > > 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 >
DisableIf_< IsProxy< T >, AddExprTrait_< T, RT > > 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 >
SubExprTrait_< RT1, RT2 > 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 >
DisableIf_< IsProxy< T >, SubExprTrait_< RT, T > > 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 >
DisableIf_< IsProxy< T >, SubExprTrait_< T, RT > > 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 >
MultExprTrait_< RT1, RT2 > 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 >
DisableIf_< IsProxy< T >, MultExprTrait_< RT, T > > 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 >
DisableIf_< IsProxy< T >, MultExprTrait_< T, RT > > 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 >
DivExprTrait_< RT1, RT2 > 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 >
DisableIf_< IsProxy< T >, DivExprTrait_< RT, T > > 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 >
DisableIf_< IsProxy< T >, DivExprTrait_< T, RT > > 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 >
DisableIf_< IsProxy< 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 >
DisableIf_< IsProxy< 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 >
DisableIf_< IsProxy< 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 >
DisableIf_< IsProxy< 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 >
DisableIf_< IsProxy< 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 >
DisableIf_< IsProxy< 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 >
DisableIf_< IsProxy< 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 >
DisableIf_< IsProxy< 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 >
DisableIf_< IsProxy< 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 >
DisableIf_< IsProxy< 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 >
DisableIf_< IsProxy< 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 >
DisableIf_< IsProxy< 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 >
auto blaze::trans (const Proxy< PT, RT > &proxy) -> decltype(trans(std::declval< RepresentedType_< PT > >()))
 Computing the transpose of the represented element. More...
 
template<typename PT , typename RT >
auto blaze::ctrans (const Proxy< PT, RT > &proxy) -> decltype(ctrans(std::declval< RepresentedType_< PT > >()))
 Computing the conjugate transpose of the represented element. More...
 
template<typename PT , typename RT >
auto blaze::abs (const Proxy< PT, RT > &proxy) -> decltype(abs(std::declval< RepresentedType_< PT > >()))
 Computing the absolute value of the represented element. More...
 
template<typename PT , typename RT >
auto blaze::conj (const Proxy< PT, RT > &proxy) -> decltype(conj(std::declval< RepresentedType_< PT > >()))
 Computing the complex conjugate of the represented element. More...
 
template<typename PT , typename RT >
auto blaze::real (const Proxy< PT, RT > &proxy) -> decltype(real(std::declval< RepresentedType_< PT > >()))
 Computing the real part of the represented element. More...
 
template<typename PT , typename RT >
auto blaze::imag (const Proxy< PT, RT > &proxy) -> decltype(imag(std::declval< RepresentedType_< PT > >()))
 Computing the imaginary part of the represented element. More...
 
template<typename PT , typename RT >
auto blaze::sqrt (const Proxy< PT, RT > &proxy) -> decltype(sqrt(std::declval< RepresentedType_< PT > >()))
 Computing the square root of the represented element. More...
 
template<typename PT , typename RT >
auto blaze::invsqrt (const Proxy< PT, RT > &proxy) -> decltype(invsqrt(std::declval< RepresentedType_< PT > >()))
 Computing the inverse square root of the represented element. More...
 
template<typename PT , typename RT >
auto blaze::cbrt (const Proxy< PT, RT > &proxy) -> decltype(cbrt(std::declval< RepresentedType_< PT > >()))
 Computing the cubic root of the represented element. More...
 
template<typename PT , typename RT >
auto blaze::invcbrt (const Proxy< PT, RT > &proxy) -> decltype(invcbrt(std::declval< RepresentedType_< PT > >()))
 Computing the inverse cubic root of the represented element. More...
 
template<typename PT , typename RT >
auto blaze::floor (const Proxy< PT, RT > &proxy) -> decltype(floor(std::declval< RepresentedType_< PT > >()))
 Computes the largest integral value that is not greater than the represented element. More...
 
template<typename PT , typename RT >
auto blaze::ceil (const Proxy< PT, RT > &proxy) -> decltype(ceil(std::declval< RepresentedType_< PT > >()))
 Computes the smallest integral value that is not less than the represented element. More...
 
template<typename PT , typename RT , typename ET >
auto blaze::pow (const Proxy< PT, RT > &proxy, const ET &exp) -> decltype(pow(std::declval< RepresentedType_< PT > >(), exp))
 Computing the exponential value of the represented element. More...
 
template<typename PT , typename RT >
auto blaze::exp (const Proxy< PT, RT > &proxy) -> decltype(exp(std::declval< RepresentedType_< PT > >()))
 Computing the base-e exponential of the represented element. More...
 
template<typename PT , typename RT >
auto blaze::sin (const Proxy< PT, RT > &proxy) -> decltype(sin(std::declval< RepresentedType_< PT > >()))
 Computing the sine of the represented element. More...
 
template<typename PT , typename RT >
auto blaze::asin (const Proxy< PT, RT > &proxy) -> decltype(asin(std::declval< RepresentedType_< PT > >()))
 Computing the inverse sine of the represented element. More...
 
template<typename PT , typename RT >
auto blaze::sinh (const Proxy< PT, RT > &proxy) -> decltype(sinh(std::declval< RepresentedType_< PT > >()))
 Computing the hyperbolic sine of the represented element. More...
 
template<typename PT , typename RT >
auto blaze::asinh (const Proxy< PT, RT > &proxy) -> decltype(asinh(std::declval< RepresentedType_< PT > >()))
 Computing the inverse hyperbolic sine of the represented element. More...
 
template<typename PT , typename RT >
auto blaze::cos (const Proxy< PT, RT > &proxy) -> decltype(cos(std::declval< RepresentedType_< PT > >()))
 Computing the cosine of the represented element. More...
 
template<typename PT , typename RT >
auto blaze::acos (const Proxy< PT, RT > &proxy) -> decltype(acos(std::declval< RepresentedType_< PT > >()))
 Computing the inverse cosine of the represented element. More...
 
template<typename PT , typename RT >
auto blaze::cosh (const Proxy< PT, RT > &proxy) -> decltype(cosh(std::declval< RepresentedType_< PT > >()))
 Computing the hyperbolic cosine of the represented element. More...
 
template<typename PT , typename RT >
auto blaze::acosh (const Proxy< PT, RT > &proxy) -> decltype(acosh(std::declval< RepresentedType_< PT > >()))
 Computing the inverse hyperbolic cosine of the represented element. More...
 
template<typename PT , typename RT >
auto blaze::tan (const Proxy< PT, RT > &proxy) -> decltype(tan(std::declval< RepresentedType_< PT > >()))
 Computing the tangent of the represented element. More...
 
template<typename PT , typename RT >
auto blaze::atan (const Proxy< PT, RT > &proxy) -> decltype(atan(std::declval< RepresentedType_< PT > >()))
 Computing the inverse tangent of the represented element. More...
 
template<typename PT , typename RT >
auto blaze::tanh (const Proxy< PT, RT > &proxy) -> decltype(tanh(std::declval< RepresentedType_< PT > >()))
 Computing the hyperbolic tangent of the represented element. More...
 
template<typename PT , typename RT >
auto blaze::atanh (const Proxy< PT, RT > &proxy) -> decltype(atanh(std::declval< RepresentedType_< PT > >()))
 Computing the inverse hyperbolic tangent of 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<typename PT , typename RT >
bool blaze::isReal (const Proxy< PT, RT > &proxy)
 Returns whether the element represents a real number. More...
 
template<typename PT , typename RT >
bool blaze::isZero (const Proxy< PT, RT > &proxy)
 Returns whether the represented element is 0. More...
 
template<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...
 

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 void blaze::reset (const SparseMatrixProxy< PT, MT > &proxy)
 Resetting the represented element to the default initial values. More...
 
template<typename PT , typename MT >
BLAZE_ALWAYS_INLINE void blaze::reset (const SparseMatrixProxy< PT, MT > &proxy, size_t i)
 Reset the specified row/column of the represented matrix. More...
 
template<typename PT , typename MT >
BLAZE_ALWAYS_INLINE void blaze::clear (const SparseMatrixProxy< PT, MT > &proxy)
 Clearing the represented matrix. 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 void blaze::reset (const SparseVectorProxy< PT, VT > &proxy)
 Resetting the represented element to the default initial values. More...
 
template<typename PT , typename VT >
BLAZE_ALWAYS_INLINE void blaze::clear (const SparseVectorProxy< PT, VT > &proxy)
 Clearing the represented element. More...
 

Detailed Description

Macro Definition Documentation

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

1 #define BLAZE_THROW_DIVISION_BY_ZERO( MESSAGE ) \
2  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:

1 class DivisionByZero
2 {
3  public:
4  DivisionByZero();
5  explicit DivisionByZero( const std::string& message );
6  // ...
7 };
8 
9 #define BLAZE_THROW_DIVISION_BY_ZERO( MESSAGE ) \
10  throw DivisionByZero( MESSAGE )
11 
12 #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!
#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:

1 #define BLAZE_THROW_LAPACK_ERROR( MESSAGE ) \
2  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:

1 class LapackError
2 {
3  public:
4  LapackError();
5  explicit LapackError( const std::string& message );
6  // ...
7 };
8 
9 #define BLAZE_THROW_LAPACK_ERROR( MESSAGE ) \
10  throw LapackError( MESSAGE )
11 
12 #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!

Function Documentation

template<typename PT , typename RT >
auto blaze::abs ( const Proxy< PT, RT > &  proxy) -> decltype(abs(std::declval< RepresentedType_< PT > >()))
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.

template<typename PT , typename RT >
auto blaze::acos ( const Proxy< PT, RT > &  proxy) -> decltype(acos(std::declval< RepresentedType_< PT > >()))
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.

template<typename PT , typename RT >
auto blaze::acosh ( const Proxy< PT, RT > &  proxy) -> decltype(acosh(std::declval< RepresentedType_< PT > >()))
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.

template<typename PT , typename RT >
auto blaze::asin ( const Proxy< PT, RT > &  proxy) -> decltype(asin(std::declval< RepresentedType_< PT > >()))
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.

template<typename PT , typename RT >
auto blaze::asinh ( const Proxy< PT, RT > &  proxy) -> decltype(asinh(std::declval< RepresentedType_< PT > >()))
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.

template<typename PT , typename RT >
auto blaze::atan ( const Proxy< PT, RT > &  proxy) -> decltype(atan(std::declval< RepresentedType_< PT > >()))
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.

template<typename PT , typename RT >
auto blaze::atanh ( const Proxy< PT, RT > &  proxy) -> decltype(atanh(std::declval< RepresentedType_< PT > >()))
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.

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

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.

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

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

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

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.

template<typename PT , typename RT >
auto blaze::cbrt ( const Proxy< PT, RT > &  proxy) -> decltype(cbrt(std::declval< RepresentedType_< PT > >()))
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.

template<typename PT , typename RT >
auto blaze::ceil ( const Proxy< PT, RT > &  proxy) -> decltype(ceil(std::declval< RepresentedType_< PT > >()))
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.

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

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.

template<typename PT , typename VT >
BLAZE_ALWAYS_INLINE void blaze::clear ( const DenseVectorProxy< PT, VT > &  proxy)

Clearing the represented vector.

Parameters
proxyThe given access proxy.
Returns
void

This function clears the vector to its default initial state.

template<typename PT , typename VT >
BLAZE_ALWAYS_INLINE void blaze::clear ( const SparseVectorProxy< PT, VT > &  proxy)

Clearing the represented element.

Parameters
proxyThe given access proxy.
Returns
void

This function clears the vector to its default initial state.

template<typename PT , typename MT >
BLAZE_ALWAYS_INLINE void blaze::clear ( const DenseMatrixProxy< PT, MT > &  proxy)

Clearing the represented matrix.

Parameters
proxyThe given access proxy.
Returns
void

This function clears the matrix to its default initial state.

template<typename PT , typename MT >
BLAZE_ALWAYS_INLINE void blaze::clear ( const SparseMatrixProxy< PT, MT > &  proxy)

Clearing the represented matrix.

Parameters
proxyThe given access proxy.
Returns
void

This function clears the matrix to its default initial state.

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.
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.
template<typename PT , typename RT >
auto blaze::conj ( const Proxy< PT, RT > &  proxy) -> decltype(conj(std::declval< RepresentedType_< PT > >()))
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.

template<typename PT , typename RT >
auto blaze::cos ( const Proxy< PT, RT > &  proxy) -> decltype(cos(std::declval< RepresentedType_< PT > >()))
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.

template<typename PT , typename RT >
auto blaze::cosh ( const Proxy< PT, RT > &  proxy) -> decltype(cosh(std::declval< RepresentedType_< PT > >()))
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.

template<typename PT , typename RT >
auto blaze::ctrans ( const Proxy< PT, RT > &  proxy) -> decltype(ctrans(std::declval< RepresentedType_< PT > >()))
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.

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.

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

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

Parameters
listThe given initializer list
Returns
The maximum number of columns.
template<typename T >
size_t blaze::digits ( a)
inlinenoexcept

Returns the number of valid digits of an integral value.

Parameters
aThe integral value.
Returns
The number of valid digits.

This function counts the number of valid digits in the given integral value.

digits( 100 ); // Returns 3
digits( 12345 ); // Returns 5
digits( 0 ); // Returns 0

The digits function only works for integral built-in data types. The attempt to use any other type will result in a compile time error.

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

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.

template<typename PT , typename RT >
auto blaze::erf ( const Proxy< PT, RT > &  proxy) -> decltype( erf( std::declval< RepresentedType_<PT> >() ) )
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.

template<typename PT , typename RT >
auto blaze::erfc ( const Proxy< PT, RT > &  proxy) -> decltype( erfc( std::declval< RepresentedType_<PT> >() ) )
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.

template<typename PT , typename RT >
auto blaze::exp ( const Proxy< PT, RT > &  proxy) -> decltype(exp(std::declval< RepresentedType_< PT > >()))
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.

template<typename PT , typename RT >
auto blaze::floor ( const Proxy< PT, RT > &  proxy) -> decltype(floor(std::declval< RepresentedType_< PT > >()))
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.

template<typename PT , typename RT >
auto blaze::imag ( const Proxy< PT, RT > &  proxy) -> decltype(imag(std::declval< RepresentedType_< PT > >()))
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.

template<typename PT , typename RT >
auto blaze::invcbrt ( const Proxy< PT, RT > &  proxy) -> decltype(invcbrt(std::declval< RepresentedType_< PT > >()))
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.

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.
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.
template<typename PT , typename RT >
auto blaze::invsqrt ( const Proxy< PT, RT > &  proxy) -> decltype(invsqrt(std::declval< RepresentedType_< PT > >()))
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.

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

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

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

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

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE constexpr bool blaze::lessThan ( const T1 &  a,
const T2 &  b 
)
noexcept

Generic less-than comparison.

Parameters
aFirst value.
bSecond value.
Returns
true if the first value is smaller than the second, false if not.

Generic less-than comparison between to numeric values. Depending on the types of the two arguments, a special comparison for floating point values is selected that takes the limited machine accuracy into account.

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE constexpr CommonType_< T1, T2 > blaze::max ( const T1 &  a,
const T2 &  b 
)
noexcept

Maximum function for two data values.

Parameters
aThe first value.
bThe second value.
Returns
The maximum of the two values.

This function returns the maximum of the two given data values. The return type of the function is determined by the data types of the given arguments (for further detail see the CommonType class description).

template<typename T1 , typename T2 , typename... Ts>
BLAZE_ALWAYS_INLINE constexpr CommonType_< T1, T2, Ts... > blaze::max ( const T1 &  a,
const T2 &  b,
const Ts &...  args 
)
noexcept

Maximum function for at least three data values.

Parameters
aThe first value.
bThe second value.
argsThe pack of additional values.
Returns
The maximum of the given values.

This function returns the maximum of the given data values. The return type of the function is determined by the data types of the given arguments (for further detail see the CommonType class description).

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE constexpr CommonType_< T1, T2 > blaze::min ( const T1 &  a,
const T2 &  b 
)
noexcept

Minimum function for two data values.

Parameters
aThe first value.
bThe second value.
Returns
The minimum of the two values.

This function returns the minimum of the two given data values. The return type of the function is determined by the data types of the given arguments (for further detail see the CommonType class description).

template<typename T1 , typename T2 , typename... Ts>
BLAZE_ALWAYS_INLINE constexpr CommonType_< T1, T2, Ts... > blaze::min ( const T1 &  a,
const T2 &  b,
const Ts &...  args 
)
noexcept

Minimum function for at least three data values.

Parameters
aThe first value.
bThe second value.
argsThe pack of additional values.
Returns
The minimum of the given values.

This function returns the minimum of the given data values. The return type of the function is determined by the data types of the given arguments (for further detail see the CommonType class description).

template<typename T >
BLAZE_ALWAYS_INLINE constexpr T blaze::nextMultiple ( value,
factor 
)
noexcept

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 multiple of the given factor.

This function rounds up the given integral value to the next multiple of the given factor. In case the integral value is already a multiple of the given factor, the value itself is returned. Note that both value and factor are expected to be positive integrals. In case any of them is negative, the function returns 0. Note that the attempt to use the function with non-integral types results in a compilation error!

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.

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.

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

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

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

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.

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

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.

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

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.

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

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.

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.
template<typename PT , typename RT , typename T >
DisableIf_< IsProxy< 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.
template<typename T , typename PT , typename RT >
DisableIf_< IsProxy< 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.
template<typename I1 , typename I2 >
bool blaze::operator!= ( const NegativeInfinity< I1 > &  lhs,
const NegativeInfinity< I2 > &  rhs 
)
inline

Inequality comparison between two NegativeInfinity objects.

Parameters
lhsThe left-hand side NegativeInfinity object.
rhsThe right-hand side NegativeInfinity object.
Returns
false.
template<typename I , typename T >
bool blaze::operator!= ( const NegativeInfinity< I > &  lhs,
const T &  rhs 
)
inline

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.

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

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.

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

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.

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

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.

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

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.

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

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.

bool blaze::operator!= ( const Infinity lhs,
const Infinity rhs 
)
inline

Inequality comparison between two Infinity objects.

Parameters
lhsThe left-hand side Infinity object.
rhsThe right-hand side Infinity object.
Returns
false.
template<typename I >
bool blaze::operator!= ( const Infinity lhs,
const NegativeInfinity< I > &  rhs 
)
inline

Inequality comparison between an Infinity object and a NegativeInfinity object.

Parameters
lhsThe left-hand side Infinity object.
rhsThe right-hand side NegativeInfinity object.
Returns
true.
template<typename I >
bool blaze::operator!= ( const NegativeInfinity< I > &  lhs,
const Infinity rhs 
)
inline

Inequality comparison between a NegativeInfinity object and an Infinity object.

Parameters
rhsThe left-hand side NegativeInfinity object.
lhsThe right-hand side Infinity object.
Returns
true.
template<typename T >
bool blaze::operator!= ( const Infinity lhs,
const T &  rhs 
)
inline

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.

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

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.

template<typename PT1 , typename RT1 , typename PT2 , typename RT2 >
MultExprTrait_< RT1, RT2 > 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.
template<typename PT , typename RT , typename T >
DisableIf_< IsProxy< T >, MultExprTrait_< RT, T > > 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.
template<typename T , typename PT , typename RT >
DisableIf_< IsProxy< T >, MultExprTrait_< T, RT > > 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.
template<typename PT1 , typename RT1 , typename PT2 , typename RT2 >
AddExprTrait_< RT1, RT2 > 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.
template<typename PT , typename RT , typename T >
DisableIf_< IsProxy< T >, AddExprTrait_< RT, T > > 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.
template<typename T , typename PT , typename RT >
DisableIf_< IsProxy< T >, AddExprTrait_< T, RT > > 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.
template<typename PT1 , typename RT1 , typename PT2 , typename RT2 >
SubExprTrait_< RT1, RT2 > 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.
template<typename PT , typename RT , typename T >
DisableIf_< IsProxy< T >, SubExprTrait_< RT, T > > 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.
template<typename T , typename PT , typename RT >
DisableIf_< IsProxy< T >, SubExprTrait_< T, RT > > 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.
template<typename PT1 , typename RT1 , typename PT2 , typename RT2 >
DivExprTrait_< RT1, RT2 > 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.
template<typename PT , typename RT , typename T >
DisableIf_< IsProxy< T >, DivExprTrait_< RT, T > > 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.
template<typename T , typename PT , typename RT >
DisableIf_< IsProxy< T >, DivExprTrait_< T, RT > > 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.
template<typename A , typename T >
bool blaze::operator< ( const NegativeAccuracy< A > &  ,
const T &  rhs 
)
inline

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.

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

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.

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

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.

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

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.

template<typename T , typename PT , typename RT >
DisableIf_< IsProxy< 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.
template<typename PT , typename RT , typename T >
DisableIf_< IsProxy< 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.
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.
template<typename T >
bool blaze::operator< ( const Accuracy ,
const T &  rhs 
)
inline

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.

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

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.

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

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.

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

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.

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.
template<typename PT , typename RT , typename T >
DisableIf_< IsProxy< 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.
template<typename T , typename PT , typename RT >
DisableIf_< IsProxy< 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.
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.
template<typename T >
bool blaze::operator<= ( const Epsilon ,
const T &  rhs 
)
inline

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.

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

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.

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

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.

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

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.

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

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.

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

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.

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

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.

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

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.

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.
template<typename PT , typename RT , typename T >
DisableIf_< IsProxy< 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.
template<typename T , typename PT , typename RT >
DisableIf_< IsProxy< 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.
template<typename I1 , typename I2 >
bool blaze::operator== ( const NegativeInfinity< I1 > &  lhs,
const NegativeInfinity< I2 > &  rhs 
)
inline

Equality comparison between two NegativeInfinity objects.

Parameters
lhsThe left-hand side NegativeInfinity object.
rhsThe right-hand side NegativeInfinity object.
Returns
true.
template<typename I , typename T >
bool blaze::operator== ( const NegativeInfinity< I > &  lhs,
const T &  rhs 
)
inline

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.

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

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.

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

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.

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

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.

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

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.

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

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.

bool blaze::operator== ( const Infinity lhs,
const Infinity rhs 
)
inline

Equality comparison between two Infinity objects.

Parameters
lhsThe left-hand side Infinity object.
rhsThe right-hand side Infinity object.
Returns
true.
template<typename I >
bool blaze::operator== ( const Infinity lhs,
const NegativeInfinity< I > &  rhs 
)
inline

Equality comparison between an Infinity object and a NegativeInfinity object.

Parameters
lhsThe left-hand side Infinity object.
rhsThe right-hand side NegativeInfinity object.
Returns
false.
template<typename I >
bool blaze::operator== ( const NegativeInfinity< I > &  lhs,
const Infinity rhs 
)
inline

Equality comparison between a NegativeInfinity object and an Infinity object.

Parameters
rhsThe left-hand side NegativeInfinity object.
lhsThe right-hand side Infinity object.
Returns
false.
template<typename T >
bool blaze::operator== ( const Infinity lhs,
const T &  rhs 
)
inline

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.

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

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.

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

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.

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

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.

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

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.

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

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.

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.
template<typename PT , typename RT , typename T >
DisableIf_< IsProxy< 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.
template<typename T , typename PT , typename RT >
DisableIf_< IsProxy< 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.
template<typename T >
bool blaze::operator> ( const Accuracy ,
const T &  rhs 
)
inline

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.

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

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.

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

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.

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

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.

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.
template<typename PT , typename RT , typename T >
DisableIf_< IsProxy< 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.
template<typename T , typename PT , typename RT >
DisableIf_< IsProxy< 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.
template<typename T >
bool blaze::operator>= ( const Epsilon ,
const T &  rhs 
)
inline

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.

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

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.

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

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.

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

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.

template<typename PT , typename RT , typename ET >
auto blaze::pow ( const Proxy< PT, RT > &  proxy,
const ET &  exp 
) -> decltype(pow(std::declval< RepresentedType_< PT > >(), 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.

template<typename PT , typename RT >
auto blaze::real ( const Proxy< PT, RT > &  proxy) -> decltype(real(std::declval< RepresentedType_< PT > >()))
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.

template<typename PT , typename VT >
BLAZE_ALWAYS_INLINE void blaze::reset ( const DenseVectorProxy< PT, VT > &  proxy)

Resetting the represented vector to the default initial values.

Parameters
proxyThe given access proxy.
Returns
void

This function resets all elements of the vector to the default initial values.

template<typename PT , typename VT >
BLAZE_ALWAYS_INLINE void blaze::reset ( const SparseVectorProxy< PT, VT > &  proxy)

Resetting the represented element to the default initial values.

Parameters
proxyThe given access proxy.
Returns
void

This function resets all elements of the vector to the default initial values.

template<typename PT , typename MT >
BLAZE_ALWAYS_INLINE void blaze::reset ( const DenseMatrixProxy< PT, MT > &  proxy)

Resetting the represented element to the default initial values.

Parameters
proxyThe given access proxy.
Returns
void

This function resets all elements of the matrix to the default initial values.

template<typename PT , typename MT >
BLAZE_ALWAYS_INLINE void blaze::reset ( const DenseMatrixProxy< PT, MT > &  proxy,
size_t  i 
)

Reset the specified row/column of the represented matrix.

Parameters
proxyThe given access proxy.
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.

template<typename PT , typename MT >
BLAZE_ALWAYS_INLINE void blaze::reset ( const SparseMatrixProxy< PT, MT > &  proxy)

Resetting the represented element to the default initial values.

Parameters
proxyThe given access proxy.
Returns
void

This function resets all elements of the matrix to the default initial values.

template<typename PT , typename MT >
BLAZE_ALWAYS_INLINE void blaze::reset ( const SparseMatrixProxy< PT, MT > &  proxy,
size_t  i 
)

Reset the specified row/column of the represented matrix.

Parameters
proxyThe given access proxy.
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.

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.

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.

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.

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.

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.
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.
template<typename T >
constexpr int blaze::sign ( a)
inlinenoexcept

Sign function.

Parameters
aThe given value.
Returns
1 if the value is greater than zero, 0 if it is zero, and -1 if it is smaller than zero.

The sign function only works for built-in data types. The attempt to use any user-defined class type will result in a compile time error.

template<typename PT , typename RT >
auto blaze::sin ( const Proxy< PT, RT > &  proxy) -> decltype(sin(std::declval< RepresentedType_< PT > >()))
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.

template<typename PT , typename RT >
auto blaze::sinh ( const Proxy< PT, RT > &  proxy) -> decltype(sinh(std::declval< RepresentedType_< PT > >()))
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.

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.
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.
template<typename PT , typename RT >
auto blaze::sqrt ( const Proxy< PT, RT > &  proxy) -> decltype(sqrt(std::declval< RepresentedType_< PT > >()))
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.

template<typename PT , typename RT >
auto blaze::tan ( const Proxy< PT, RT > &  proxy) -> decltype(tan(std::declval< RepresentedType_< PT > >()))
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.

template<typename PT , typename RT >
auto blaze::tanh ( const Proxy< PT, RT > &  proxy) -> decltype(tanh(std::declval< RepresentedType_< PT > >()))
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.

template<typename PT , typename RT >
auto blaze::trans ( const Proxy< PT, RT > &  proxy) -> decltype(trans(std::declval< RepresentedType_< PT > >()))
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.

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.

Variable Documentation

const bool blaze::aligned = true

Alignment flag for aligned vectors and matrices.Via this flag it is possible to specify subvectors, submatrices, custom vectors and matrices as aligned. The following example demonstrates the setup of an aligned subvector:

VectorType v( 100UL );
Subvector<VectorType,aligned> sv = subvector<aligned>( v, 8UL, 32UL );
const bool blaze::padded = true

Padding flag for padded vectors and matrices.Via this flag it is possible to specify custom vectors and matrices as aligned. The following example demonstrates the setup of an aligned, padded custom row vector of size 7:

std::vector<int> vec( 16UL );
CustomVector<int,unaligned,padded,columnVector> a( &vec[0], 7UL, 16UL );
const bool blaze::unaligned = false

Alignment flag for unaligned vectors and matrices.Via this flag it is possible to specify subvectors, submatrices, custom vectors and matrices as unaligned. The following example demonstrates the setup of an unaligned subvector:

VectorType v( 100UL );
Subvector<VectorType,unaligned> sv = subvector<unaligned>( v, 10UL, 20UL );
const bool blaze::unpadded = false

Padding flag for unpadded vectors and matrices.Via this flag it is possible to specify custom vectors and matrices as unpadded. The following example demonstrates the setup of an unaligned, unpadded custom row vector of size 7:

std::vector<int> vec( 7UL );
CustomVector<int,unaligned,unpadded,columnVector> a( &vec[0], 7UL );