![]() |
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::InitializerIterator< Type > |
Implementation of an iterator for (extended) initializer lists.The InitializerIterator represents a generic random-access iterator for (extended) initializer lists. It can be used for initializer lists representing dense vectors and specific rows of dense matrices. More... | |
class | blaze::UniformIterator< Type, AF > |
Implementation of a generic iterator for uniform vectors and matrices.The UniformIterator represents a generic random-access iterator that can be used for uniform vectors and specific rows/columns of uniform 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< T > |
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 publicly from this class in order to qualify as addition expression template. Only in case a class is derived publicly from the AddExpr base class, the IsAddExpr type trait recognizes the class as valid addition expression template. More... | |
struct | blaze::BinaryMapExpr< T > |
Base class for all for-each expression templates.The BinaryMapExpr class serves as a tag for all expression templates that represent a binary map operation. All classes, that represent a binary map operation and that are used within the expression template environment of the Blaze library have to derive publicly from this class in order to qualify as binary map expression template. Only in case a class is derived publicly from the BinaryMapExpr base class, the IsBinaryMapExpr type trait recognizes the class as valid binary map 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< VT > |
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 publicly from this class in order to qualify as cross product expression template. Only in case a class is derived publicly from the CrossExpr base class, the IsCrossExpr type trait recognizes the class as valid cross product expression template. More... | |
struct | blaze::Declaration< T > |
Base class for all declaration expression templates.The Declaration class serves as a tag for all declaration expression templates. All classes that represent a declaration and that are used within the expression template environment of the Blaze library have to derive publicly from this class in order to qualify as declaration expression template. Only in case a class is derived publicly from the Declaration base class, the IsDeclaration type trait recognizes the class as valid declaration expression template. More... | |
struct | blaze::DeclDiagExpr< MT > |
Base class for all decldiag expression templates.The DeclDiagExpr class serves as a tag for all expression templates that represent an explicit diagonal declaration (decldiag) operation. All classes, that represent a decldiag operation and that are used within the expression template environment of the Blaze library have to derive publicly from this class in order to qualify as decldiag expression template. Only in case a class is derived publicly from the DeclDiagExpr base class, the IsDeclDiagExpr type trait recognizes the class as valid decldiag expression template. More... | |
struct | blaze::DeclExpr< T > |
Base class for all matrix for-each expression templates.The DeclExpr class serves as a tag for all expression templates that represent an explicit declaration operation. All classes, that represent a declaration operation and that are used within the expression template environment of the Blaze library have to derive publicly from this class in order to qualify as declaration expression template. Only in case a class is derived publicly from the DeclExpr base class, the IsDeclExpr type trait recognizes the class as valid declaration expression template. More... | |
struct | blaze::DeclHermExpr< MT > |
Base class for all declherm expression templates.The DeclHermExpr class serves as a tag for all expression templates that represent an explicit Hermitian declaration (declherm) operation. All classes, that represent a declherm operation and that are used within the expression template environment of the Blaze library have to derive publicly from this class in order to qualify as declherm expression template. Only in case a class is derived publicly from the DeclHermExpr base class, the IsDeclHermExpr type trait recognizes the class as valid declherm expression template. More... | |
struct | blaze::DeclLowExpr< MT > |
Base class for all decllow expression templates.The DeclLowExpr class serves as a tag for all expression templates that represent an explicit lower declaration (decllow) operation. All classes, that represent a decllow operation and that are used within the expression template environment of the Blaze library have to derive publicly from this class in order to qualify as decllow expression template. Only in case a class is derived publicly from the DeclLowExpr base class, the IsDeclLowExpr type trait recognizes the class as valid decllow expression template. More... | |
struct | blaze::DeclSymExpr< MT > |
Base class for all declsym expression templates.The DeclSymExpr class serves as a tag for all expression templates that represent an explicit symmetry declaration (declsym) operation. All classes, that represent a declsym operation and that are used within the expression template environment of the Blaze library have to derive publicly from this class in order to qualify as declsym expression template. Only in case a class is derived publicly from the DeclSymExpr base class, the IsDeclSymExpr type trait recognizes the class as valid declsym expression template. More... | |
struct | blaze::DeclUppExpr< MT > |
Base class for all declupp expression templates.The DeclUppExpr class serves as a tag for all expression templates that represent an explicit upper declaration (declupp) operation. All classes, that represent a declupp operation and that are used within the expression template environment of the Blaze library have to derive publicly from this class in order to qualify as declupp expression template. Only in case class is derived publicly from the DeclUppExpr base class, the IsDeclUppExpr type trait a recognizes the class as valid declupp expression template. More... | |
struct | blaze::DivExpr< T > |
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/vector divisions, vector/scalar divisions and matrix/scalar divisions) and that are used within the expression template environment of the Blaze library have to derive publicly from this class in order to qualify as division expression template. Only in case a class is derived publicly from the DivExpr base class, the IsDivExpr type trait recognizes the class as valid division expression template. More... | |
struct | blaze::EvalExpr< T > |
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 publicly from this class in order to qualify as evaluation expression template. Only in case a class is derived publicly from the EvalExpr base class, the IsEvalExpr type trait recognizes the class as valid evaluation expression template. More... | |
struct | blaze::ExpandExpr< T > |
Base class for all expansion expression templates.The ExpandExpr class serves as a tag for all expression templates that implement expansion operations. All classes, that represent an expansion operation (e.g. vector expansions) and that are used within the expression template environment of the Blaze library have to derive publicly from this class in order to qualify as expansion expression template. Only in case a class is derived publicly from the ExpandExpr base class, the IsExpandExpr type trait recognizes the class as valid expansion expression template. More... | |
class | blaze::ExpandExprData< CEAs > |
Auxiliary class template for the data members of expressions expression classes.The auxiliary ExpandExprData class template represents an abstraction of the data members of expansion expression template classes. The necessary set of data member is selected depending on the number of compile time expansion arguments. More... | |
struct | blaze::Expression< T > |
Base class for all expression templates.The Expression class is the base class for all expression templates. All classes that represent an expression and that are used within the expression template environment of the Blaze library have to derive publicly from this class in order to qualify as expression template. Only in case a class is derived publicly from the Expression base class, the IsExpression type trait recognizes the class as valid expression template. More... | |
struct | blaze::MatEvalExpr< MT > |
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 publicly from this class in order to qualify as matrix evaluation expression template. Only in case a class is derived publicly from the MatEvalExpr base class, the IsMatEvalExpr type trait recognizes the class as valid matrix evaluation expression template. More... | |
struct | blaze::MatInvExpr< MT > |
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 publicly from this class in order to qualify as matrix inversion expression template. Only in case a class is derived publicly from the MatInvExpr base class, the IsMatInvExpr type trait recognizes the class as valid matrix inversion expression template. More... | |
struct | blaze::MatMapExpr< MT > |
Base class for all unary matrix map expression templates.The MatMapExpr class serves as a tag for all expression templates that represent a unary map operation on a matrix. All classes, that represent a unary matrix map operation and that are used within the expression template environment of the Blaze library have to derive publicly from this class in order to qualify as unary matrix map expression template. Only in case a class is derived publicly from the MatMapExpr base class, the IsMatMapExpr type trait recognizes the class as valid unary matrix map expression template. More... | |
struct | blaze::MatMatAddExpr< MT > |
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 publicly from this class in order to qualify as matrix addition expression template. Only in case a class is derived publicly from the MatMatAddExpr base class, the IsMatMatAddExpr type trait recognizes the class as valid matrix addition expression template. More... | |
struct | blaze::MatMatMapExpr< MT > |
Base class for all binary matrix map expression templates.The MatMatMapExpr class serves as a tag for all expression templates that implement a binary matrix map operation. All classes, that represent a binary matrix map operation and that are used within the expression template environment of the Blaze library have to derive publicly from this class in order to qualify as binary matrix map expression template. Only in case a class is derived publicly from the MatMatMapExpr base class, the IsMatMatMapExpr type trait recognizes the class as valid binary matrix map expression template. More... | |
struct | blaze::MatMatMultExpr< MT > |
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 publicly from this class in order to qualify as matrix multiplication expression template. Only in case a class is derived publicly from the MatMatMultExpr base class, the IsMatMatMultExpr type trait recognizes the class as valid matrix multiplication expression template. More... | |
struct | blaze::MatMatSubExpr< MT > |
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 publicly from this class in order to qualify as matrix subtraction expression template. Only in case a class is derived publicly from the MatMatSubExpr base class, the IsMatMatSubExpr type trait recognizes the class as valid matrix subtraction expression template. More... | |
struct | blaze::MatReduceExpr< VT, RF > |
Base class for all matrix reduction expression templates.The MatReduceExpr class serves as a tag for all expression templates that implement a matrix reduction. All classes, that represent a matrix reduction and and that are used within the expression template environment of the Blaze library have to derive publicly from this class in order to qualify as matrix reduction expression template. Only in case a class is derived publicly from the MatReduceExpr base class, the IsMatReduceExpr type trait recognizes the class as valid matrix reduction expression template. More... | |
struct | blaze::MatScalarDivExpr< MT > |
Base class for all matrix/scalar division expression templates.The MatScalarDivExpr class serves as a tag for all expression templates that implement a matrix/scalar division. All classes, that represent a matrix/scalar division and that are used within the expression template environment of the Blaze library have to derive publicly from this class in order to qualify as matrix/scalar division expression template. Only in case a class is derived publicly from the MatScalarDivExpr base class, the IsMatScalarDivExpr type trait recognizes the class as valid matrix/scalar division expression template. More... | |
struct | blaze::MatScalarMultExpr< MT > |
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 publicly from this class in order to qualify as matrix/scalar multiplication expression template. Only in case a class is derived publicly from the MatScalarMultExpr base class, the IsMatScalarMultExpr type trait recognizes the class as valid matrix/scalar multiplication expression template. More... | |
struct | blaze::MatSerialExpr< MT > |
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 publicly from this class in order to qualify as matrix serial evaluation expression template. Only in case a class is derived publicly from the MatSerialExpr base class, the IsMatSerialExpr type trait recognizes the class as valid matrix serial evaluation expression template. More... | |
struct | blaze::MatTransExpr< MT > |
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 publicly from this class in order to qualify as matrix transposition expression template. Only in case a class is derived publicly from the MatTransExpr base class, the IsMatTransExpr type trait recognizes the class as valid matrix transposition expression template. More... | |
struct | blaze::MatVecMultExpr< VT > |
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 publicly from this class in order to qualify as matrix/vector multiplication expression template. Only in case a class is derived publicly from the MatVecMultExpr base class, the IsMatVecMultExpr type trait recognizes the class as valid matrix/vector multiplication expression template. More... | |
struct | blaze::MultExpr< T > |
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 publicly from this class in order to qualify as multiplication expression template. Only in case a class is derived publicly from the MultExpr base class, the IsMultExpr type trait recognizes the class as valid multiplication expression template. More... | |
struct | blaze::Operation |
Base class for all operational expression templates.The Operation class serves as a tag for all operational expression templates. All classes that represent either a transformation (transpositions, ...) or 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 operational expression template. Only in case a class is derived from the Operation base class, the IsOperation type trait recognizes the class as valid operational expression template. More... | |
struct | blaze::ReduceExpr< T > |
Base class for all reduction expression templates.The ReduceExpr class serves as a tag for all expression templates that implement reduction operations. All classes, that represent a reduction operation (e.g. row-wise or column-wise matrix reductions) and that are used within the expression template environment of the Blaze library have to derive publicly from this class in order to qualify as reduction expression template. Only in case a class is derived publicly from the ReduceExpr base class, the IsReduceExpr type trait recognizes the class as valid reduction expression template. More... | |
struct | blaze::SchurExpr< MT > |
Base class for all Schur product expression templates.The SchurExpr class serves as a tag for all expression templates that implement mathematical Schur products. All classes, that represent a mathematical Schur product and that are used within the expression template environment of the Blaze library have to derive publicly from this class in order to qualify as Schur product expression template. Only in case a class is derived publicly from the SchurExpr base class, the IsSchurExpr type trait recognizes the class as valid Schur product expression template. More... | |
struct | blaze::SerialExpr< T > |
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 publicly from this class in order to qualify as serial evaluation expression template. Only in case a class is derived publicly from the SerialExpr base class, the IsSerialExpr type trait recognizes the class as valid serial evaluation expression template. More... | |
struct | blaze::SubExpr< T > |
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 publicly from this class in order to qualify as subtraction expression template. Only in case a class is derived publicly from the SubExpr base class, the IsSubExpr type trait recognizes the class as valid subtraction expression template. More... | |
struct | blaze::TransExpr< T > |
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 publicly from this class in order to qualify as transposition expression template. Only in case a class is derived publicly from the TransExpr base class, the IsTransExpr type trait recognizes the class as valid transposition expression template. More... | |
struct | blaze::Transformation |
Base class for all transform expression templates.The Transformation class serves as a tag for all transformation expression templates. All classes, that represent a transformation (e.g. 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 transformation expression template. Only in case a class is derived from the Transformation base class, the IsTransformation type trait recognizes the class as valid transformation expression template. More... | |
struct | blaze::TVecMatMultExpr< VT > |
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 publicly from this class in order to qualify as vector/matrix multiplication expression template. Only in case a class is derived publicly from the TVecMatMultExpr base class, the IsTVecMatMultExpr type trait recognizes the class as valid vector/matrix multiplication expression template. More... | |
struct | blaze::UnaryMapExpr< T > |
Base class for all for-each expression templates.The UnaryMapExpr class serves as a tag for all expression templates that represent a unary map operation. All classes, that represent a unary map operation and that are used within the expression template environment of the Blaze library have to derive publicly from this class in order to qualify as unary map expression template. Only in case a class is derived publicly from the UnaryMapExpr base class, the IsUnaryMapExpr type trait recognizes the class as valid unary map expression template. More... | |
struct | blaze::VecEvalExpr< VT > |
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 publicly from this class in order to qualify as vector evaluation expression template. Only in case a class is derived publicly from the VecEvalExpr base class, the IsVecEvalExpr type trait recognizes the class as valid vector evaluation expression template. More... | |
struct | blaze::VecExpandExpr< MT, CEAs > |
Base class for all vector expansion expression templates.The VecExpandExpr class serves as a tag for all expression templates that implement a vector expansion. All classes, that represent a vector expansion and and that are used within the expression template environment of the Blaze library have to derive publicly from this class in order to qualify as vector expansion expression template. Only in case a class is derived publicly from the VecExpandExpr base class, the IsVecExpandExpr type trait recognizes the class as valid vector expansion expression template. More... | |
struct | blaze::VecMapExpr< VT > |
Base class for all unary vector map expression templates.The VecMapExpr class serves as a tag for all expression templates that represent a unary map operation on a vector. All classes, that represent a unary vector map operation and that are used within the expression template environment of the Blaze library have to derive publicly from this class in order to qualify as unary vector map expression template. Only in case a class is derived publicly from the VecMapExpr base class, the IsVecMapExpr type trait recognizes the class as valid unary vector map expression template. More... | |
struct | blaze::VecScalarDivExpr< VT > |
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 publicly from this class in order to qualify as vector/scalar division expression template. Only in case a class is derived publicly from the VecScalarDivExpr base class, the IsVecScalarDivExpr type trait recognizes the class as valid vector/scalar division expression template. More... | |
struct | blaze::VecScalarMultExpr< VT > |
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 publicly from this class in order to qualify as vector/scalar multiplication expression template. Only in case a class is derived publicly from the VecScalarMultExpr base class, the IsVecScalarMultExpr type trait recognizes the class as valid vector/scalar multiplication expression template. More... | |
struct | blaze::VecSerialExpr< VT > |
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 publicly from this class in order to qualify as vector serial evaluation expression template. Only in case a class is derived publicly from the VecSerialExpr base class, the IsVecSerialExpr type trait recognizes the class as valid vector serial evaluation expression template. More... | |
struct | blaze::VecTransExpr< VT > |
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 publicly from this class in order to qualify as vector transposition expression template. Only in case a class is derived publicly from the VecTransExpr base class, the IsVecTransExpr type trait recognizes the class as valid vector transposition expression template. More... | |
struct | blaze::VecTVecMultExpr< MT > |
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 publicly from this class in order to qualify as outer product expression template. Only in case a class is derived publicly from the VecTVecMultExpr base class, the IsVecTVecMultExpr type trait recognizes the class as valid outer product expression template. More... | |
struct | blaze::VecVecAddExpr< VT > |
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 publicly from this class in order to qualify as vector addition expression template. Only in case a class is derived publicly from the VecVecAddExpr base class, the IsVecVecAddExpr type trait recognizes the class as valid vector addition expression template. More... | |
struct | blaze::VecVecDivExpr< VT > |
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 publicly from this class in order to qualify as vector division expression template. Only in case a class is derived publicly from the VecVecDivExpr base class, the IsVecVecDivExpr type trait recognizes the class as valid vector division expression template. More... | |
struct | blaze::VecVecMapExpr< VT > |
Base class for all binary vector map expression templates.The VecVecMapExpr class serves as a tag for all expression templates that implement a binary vector map operation. All classes, that represent a binary vector map operation and that are used within the expression template environment of the Blaze library have to derive publicly from this class in order to qualify as binary vector map expression template. Only in case a class is derived publicly from the VecVecMapExpr base class, the IsVecVecMapExpr type trait recognizes the class as valid binary vector map expression template. More... | |
struct | blaze::VecVecMultExpr< VT > |
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 publicly from this class in order to qualify as vector multiplication expression template. Only in case a class is derived publicly from the VecVecMultExpr base class, the IsVecVecMultExpr type trait recognizes the class as valid vector multiplication expression template. More... | |
struct | blaze::VecVecSubExpr< VT > |
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 publicly from this class in order to qualify as vector subtraction expression template. Only in case a class is derived publicly from the VecVecSubExpr base class, the IsVecVecSubExpr type trait recognizes the class as valid vector subtraction expression template. More... | |
struct | blaze::View< T > |
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 publicly from this class in order to qualify as a view. Only in case a class is derived publicly 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... | |
struct | blaze::Check< C > |
Template for the blaze::checked and blaze::unchecked instances.blaze::Check is the template for the blaze::checked and blaze::unchecked instance, which is an optional token for the creation of views. It can be used to enforce or skip all runtime checks during the creation of a view (subvectors, submatrices, rows, columns, bands, ...). More... | |
class | blaze::integer_sequence |
Integer sequence type of the Blaze library. More... | |
class | blaze::index_sequence |
Index sequence type of the Blaze library. More... | |
class | blaze::make_integer_sequence |
Import of the std::make_integer_sequence alias template into the Blaze namespace. More... | |
class | blaze::make_index_sequence |
Import of the std::make_index_sequence alias template into the Blaze namespace. 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... | |
Typedefs | |
template<size_t Offset, size_t N> | |
using | blaze::make_shifted_index_sequence = decltype(shift< Offset >(make_index_sequence< N >())) |
Auxiliary alias declaration for the setup of shifted index sequences.The make_shifted_index_sequence alias template provides a convenient way to create index sequences with specific initial index and a specific number of indices. The following code example demonstrates the use of make_shifted_index_sequence: More... | |
template<size_t Offset, size_t N, size_t ... Is> | |
using | blaze::make_shifted_index_subsequence = decltype(subsequence< Is... >(shift< Offset >(make_index_sequence< N >()))) |
Auxiliary alias declaration for the setup of shifted index subsequences.The make_shifted_index_subsequence alias template provides a convenient way to create a subsequence of an index sequences with specific initial index and a specific number of indices. The following code example demonstrates the use of make_shifted_index_subsequence: More... | |
using | blaze::Checked = Check< true > |
Type of the blaze::checked instance.blaze::Checked is the type of the blaze::checked instance, which is an optional token for the creation of views. It can be used to enforce runtime checks during the creation of a view (subvectors, submatrices, rows, columns, bands, ...). | |
using | blaze::Unchecked = Check< false > |
Type of the blaze::unchecked instance.blaze::Unchecked is the type of the blaze::unchecked instance, which is an optional token for the creation of views. It can be used to skip all runtime checks during the creation of a view (subvectors, submatrices, rows, columns, bands, ...). | |
Enumerations | |
enum | blaze::AlignmentFlag : bool { blaze::unaligned = false, blaze::aligned = true } |
Alignment flag for (un-)aligned vectors and matrices.Via these flags it is possible to specify subvectors, submatrices, custom vectors and matrices as unaligned or aligned. The following example demonstrates the setup of an unaligned subvector: More... | |
enum | blaze::InversionFlag { blaze::byLU = 0, blaze::byLDLT = 1, blaze::byLDLH = 2, blaze::byLLH = 3, blaze::asGeneral = 4, blaze::asSymmetric = 5, blaze::asHermitian = 6, blaze::asLower = 7, blaze::asUniLower = 8, blaze::asUpper = 9, blaze::asUniUpper = 10, blaze::asDiagonal = 11 } |
Inversion flag.The InversionFlag type enumeration represents the different types of matrix inversion algorithms that are available within the Blaze library. The following flags are available: More... | |
Functions | |
template<typename Type > | |
size_t | blaze::nonZeros (initializer_list< Type > list) noexcept |
Determines the number of non-zero elements contained in the given initializer list. More... | |
template<typename Type > | |
size_t | blaze::nonZeros (initializer_list< initializer_list< Type > > list) noexcept |
Determines the number of non-zero elements contained in the given initializer list. More... | |
template<typename Type > | |
constexpr size_t | blaze::determineColumns (initializer_list< initializer_list< Type > > list) noexcept |
Determines the maximum number of columns specified by the given initializer list. More... | |
template<size_t... I1s, size_t... I2s> | |
constexpr bool | blaze::operator== (index_sequence< I1s... > lhs, index_sequence< I2s... > rhs) noexcept |
Equality operator for the comparison of two index sequences. More... | |
template<size_t... I1s, size_t... I2s> | |
constexpr bool | blaze::operator!= (index_sequence< I1s... > lhs, index_sequence< I2s... > rhs) noexcept |
Inequality operator for the comparison of two index sequences. More... | |
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... | |
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... | |
template<typename PT , typename RT , typename ET > | |
decltype(auto) | blaze::pow2 (const Proxy< PT, RT > &proxy) |
Computing the square value of the represented element. More... | |
template<typename PT , typename RT , typename ET > | |
decltype(auto) | blaze::pow3 (const Proxy< PT, RT > &proxy) |
Computing the cube value of the represented element. More... | |
template<typename PT , typename RT , typename ET > | |
decltype(auto) | blaze::pow4 (const Proxy< PT, RT > &proxy) |
Computing the quadruple value of the represented element. More... | |
template<typename PT , typename 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... | |
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... | |
template<typename T1 , typename T2 > | |
BLAZE_ALWAYS_INLINE constexpr auto | blaze::nextMultiple (T1 value, T2 factor) noexcept |
Rounds up an integral value to the next multiple of a given factor. More... | |
Variables | |
constexpr 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. | |
constexpr 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. | |
constexpr 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. | |
constexpr 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 column vector of size 7: More... | |
constexpr 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 column vector of size 7: More... | |
constexpr Checked | blaze::checked |
Global Checked instance.The blaze::checked instance is an optional token for the creation of views. It can be used used to enforce runtime checks during the creation of a view (subvectors, submatrices, rows, columns, bands, ...). The following example demonstrates the setup of a checked subvector: More... | |
constexpr Unchecked | blaze::unchecked |
Global Unchecked instance.The blaze::unchecked instance is an optional token for the creation of views. It can be used to skip all runtime checks during the creation of a view (subvectors, submatrices, rows, columns, bands, ...). The following example demonstrates the setup of an unchecked subvector: More... | |
NegativeAccuracy operators | |
template<typename A , typename T > | |
constexpr bool | blaze::operator== (const NegativeAccuracy< A > &, const T &rhs) |
Equality comparison between a NegativeAccuracy object and a floating point value. More... | |
template<typename A , typename T > | |
constexpr bool | blaze::operator== (const T &lhs, const NegativeAccuracy< A > &) |
Equality comparison between a floating point value and a NegativeAccuracy object. More... | |
template<typename A , typename T > | |
constexpr bool | blaze::operator!= (const NegativeAccuracy< A > &, const T &rhs) |
Inequality comparison between a NegativeAccuracy object and a floating point value. More... | |
template<typename A , typename T > | |
constexpr bool | blaze::operator!= (const T &lhs, const NegativeAccuracy< A > &) |
Inequality comparison between a floating point value and a NegativeAccuracy object. More... | |
template<typename A , typename T > | |
constexpr bool | blaze::operator< (const NegativeAccuracy< A > &, const T &rhs) |
Less-than comparison between a NegativeAccuracy object and a floating point value. More... | |
template<typename A , typename T > | |
constexpr bool | blaze::operator< (const T &lhs, const NegativeAccuracy< A > &) |
Less-than comparison between a floating point value and a NegativeAccuracy object. More... | |
template<typename A , typename T > | |
constexpr bool | blaze::operator> (const NegativeAccuracy< A > &, const T &rhs) |
Greater-than comparison between a NegativeAccuracy object and a floating point value. More... | |
template<typename A , typename T > | |
constexpr bool | blaze::operator> (const T &lhs, const NegativeAccuracy< A > &) |
Greater-than comparison between a floating point value and a NegativeAccuracy object. More... | |
Accuracy operators | |
template<typename T > | |
constexpr bool | blaze::operator== (const Accuracy &, const T &rhs) |
Equality comparison between an Accuracy object and a floating point value. More... | |
template<typename T > | |
constexpr bool | blaze::operator== (const T &lhs, const Accuracy &) |
Equality comparison between a floating point value and an Accuracy object. More... | |
template<typename T > | |
constexpr bool | blaze::operator!= (const Accuracy &, const T &rhs) |
Inequality comparison between an Accuracy object and a floating point value. More... | |
template<typename T > | |
constexpr bool | blaze::operator!= (const T &lhs, const Accuracy &) |
Inequality comparison between a floating point value and an Accuracy object. More... | |
template<typename T > | |
constexpr bool | blaze::operator< (const Accuracy &, const T &rhs) |
Less-than comparison between an Accuracy object and a floating point value. More... | |
template<typename T > | |
constexpr bool | blaze::operator< (const T &lhs, const Accuracy &) |
Less-than comparison between a floating point value and an Accuracy object. More... | |
template<typename T > | |
constexpr bool | blaze::operator> (const Accuracy &, const T &rhs) |
Greater-than comparison between an Accuracy object and a floating point value. More... | |
template<typename T > | |
constexpr bool | blaze::operator> (const T &lhs, const Accuracy &) |
Greater-than comparison between a floating point value and an Accuracy object. More... | |
template<typename T > | |
constexpr bool | blaze::operator<= (const Accuracy &, const T &rhs) |
Less-or-equal-than comparison between an Accuracy object and a floating point value. More... | |
template<typename T > | |
constexpr bool | blaze::operator<= (const T &lhs, const Accuracy &) |
Less-or-equal-than comparison between a floating point value and an Accuracy object. More... | |
template<typename T > | |
constexpr bool | blaze::operator>= (const Accuracy &, const T &rhs) |
Greater-or-equal-than comparison between an Accuracy object and a floating point value. More... | |
template<typename T > | |
constexpr bool | blaze::operator>= (const T &lhs, const Accuracy &) |
Less-or-equal-than comparison between a floating point value and an Accuracy object. More... | |
NegativeEpsilon operators | |
template<typename E , typename T > | |
constexpr bool | blaze::operator== (const NegativeEpsilon< E > &, const T &rhs) |
Equality comparison between a NegativeEpsilon object and a floating point value. More... | |
template<typename E , typename T > | |
constexpr bool | blaze::operator== (const T &lhs, const NegativeEpsilon< E > &) |
Equality comparison between a floating point value and a NegativeEpsilon object. More... | |
template<typename E , typename T > | |
constexpr bool | blaze::operator!= (const NegativeEpsilon< E > &, const T &rhs) |
Inequality comparison between a NegativeEpsilon object and a floating point value. More... | |
template<typename E , typename T > | |
constexpr bool | blaze::operator!= (const T &lhs, const NegativeEpsilon< E > &) |
Inequality comparison between a floating point value and a NegativeEpsilon object. More... | |
template<typename E , typename T > | |
constexpr bool | blaze::operator< (const NegativeEpsilon< E > &, const T &rhs) |
Less-than comparison between a NegativeEpsilon object and a floating point value. More... | |
template<typename E , typename T > | |
constexpr bool | blaze::operator< (const T &lhs, const NegativeEpsilon< E > &) |
Less-than comparison between a floating point value and a NegativeEpsilon object. More... | |
template<typename E , typename T > | |
constexpr bool | blaze::operator> (const NegativeEpsilon< E > &, const T &rhs) |
Greater-than comparison between a NegativeEpsilon object and a floating point value. More... | |
template<typename E , typename T > | |
constexpr bool | blaze::operator> (const T &lhs, const NegativeEpsilon< E > &) |
Greater-than comparison between a floating point value and a NegativeEpsilon object. More... | |
Epsilon operators | |
template<typename T > | |
constexpr bool | blaze::operator== (const Epsilon &, const T &rhs) |
Equality comparison between an Epsilon object and a floating point value. More... | |
template<typename T > | |
constexpr bool | blaze::operator== (const T &lhs, const Epsilon &) |
Equality comparison between a floating point value and an Epsilon object. More... | |
template<typename T > | |
constexpr bool | blaze::operator!= (const Epsilon &, const T &rhs) |
Inequality comparison between an Epsilon object and a floating point value. More... | |
template<typename T > | |
constexpr bool | blaze::operator!= (const T &lhs, const Epsilon &) |
Inequality comparison between a floating point value and an Epsilon object. More... | |
template<typename T > | |
constexpr bool | blaze::operator< (const Epsilon &, const T &rhs) |
Less-than comparison between an Epsilon object and a floating point value. More... | |
template<typename T > | |
constexpr bool | blaze::operator< (const T &lhs, const Epsilon &) |
Less-than comparison between a floating point value and an Epsilon object. More... | |
template<typename T > | |
constexpr bool | blaze::operator> (const Epsilon &, const T &rhs) |
Greater-than comparison between an Epsilon object and a floating point value. More... | |
template<typename T > | |
constexpr bool | blaze::operator> (const T &lhs, const Epsilon &) |
Greater-than comparison between a floating point value and an Epsilon object. More... | |
template<typename T > | |
constexpr bool | blaze::operator<= (const Epsilon &, const T &rhs) |
Less-or-equal-than comparison between an Epsilon object and a floating point value. More... | |
template<typename T > | |
constexpr bool | blaze::operator<= (const T &lhs, const Epsilon &) |
Less-or-equal-than comparison between a floating point value and an Epsilon object. More... | |
template<typename T > | |
constexpr bool | blaze::operator>= (const Epsilon &, const T &rhs) |
Greater-or-equal-than comparison between an Epsilon object and a floating point value. More... | |
template<typename T > | |
constexpr bool | blaze::operator>= (const T &lhs, const Epsilon &) |
Less-or-equal-than comparison between a floating point value and an Epsilon object. More... | |
NegativeInfinity operators | |
template<typename I1 , typename I2 > | |
constexpr bool | blaze::operator== (const NegativeInfinity< I1 > &, const NegativeInfinity< I2 > &) |
Equality comparison between two NegativeInfinity objects. More... | |
template<typename I , typename T > | |
constexpr bool | blaze::operator== (const NegativeInfinity< I > &lhs, const T &rhs) |
Equality comparison between an NegativeInfinity object and a built-in data type. More... | |
template<typename I , typename T > | |
constexpr bool | blaze::operator== (const T &lhs, const NegativeInfinity< I > &rhs) |
Equality comparison between a built-in data type and an NegativeInfinity object. More... | |
template<typename I1 , typename I2 > | |
constexpr bool | blaze::operator!= (const NegativeInfinity< I1 > &, const NegativeInfinity< I2 > &) |
Inequality comparison between two NegativeInfinity objects. More... | |
template<typename I , typename T > | |
constexpr bool | blaze::operator!= (const NegativeInfinity< I > &lhs, const T &rhs) |
Inequality comparison between an NegativeInfinity object and a built-in data type. More... | |
template<typename I , typename T > | |
constexpr bool | blaze::operator!= (const T &lhs, const NegativeInfinity< I > &rhs) |
Inequality comparison between a built-in data type and an NegativeInfinity object. More... | |
Infinity operators | |
constexpr bool | blaze::operator== (const Infinity &, const Infinity &) |
Equality comparison between two Infinity objects. More... | |
template<typename I > | |
constexpr bool | blaze::operator== (const Infinity &, const NegativeInfinity< I > &) |
Equality comparison between an Infinity object and a NegativeInfinity object. More... | |
template<typename I > | |
constexpr bool | blaze::operator== (const NegativeInfinity< I > &, const Infinity &) |
Equality comparison between a NegativeInfinity object and an Infinity object. More... | |
template<typename T > | |
constexpr bool | blaze::operator== (const Infinity &lhs, const T &rhs) |
Equality comparison between an Infinity object and a built-in data type. More... | |
template<typename T > | |
constexpr bool | blaze::operator== (const T &lhs, const Infinity &rhs) |
Equality comparison between a built-in data type and an Infinity object. More... | |
constexpr bool | blaze::operator!= (const Infinity &, const Infinity &) |
Inequality comparison between two Infinity objects. More... | |
template<typename I > | |
constexpr bool | blaze::operator!= (const Infinity &, const NegativeInfinity< I > &) |
Inequality comparison between an Infinity object and a NegativeInfinity object. More... | |
template<typename I > | |
constexpr bool | blaze::operator!= (const NegativeInfinity< I > &, const Infinity &) |
Inequality comparison between a NegativeInfinity object and an Infinity object. More... | |
template<typename T > | |
constexpr bool | blaze::operator!= (const Infinity &lhs, const T &rhs) |
Inequality comparison between an Infinity object and a built-in data type. More... | |
template<typename T > | |
constexpr bool | blaze::operator!= (const T &lhs, const Infinity &rhs) |
Inequality comparison between a built-in data type and an Infinity object. More... | |
Proxy operators | |
template<typename PT1 , typename RT1 , typename PT2 , typename RT2 > | |
decltype(auto) | blaze::operator+ (const Proxy< PT1, RT1 > &lhs, const Proxy< PT2, RT2 > &rhs) |
Addition between two Proxy objects. More... | |
template<typename PT , typename RT , typename T , typename = DisableIf_t< IsProxy_v<T> >> | |
decltype(auto) | blaze::operator+ (const Proxy< PT, RT > &lhs, const T &rhs) |
Addition between a Proxy object and an object of different type. More... | |
template<typename T , typename PT , typename RT , typename = DisableIf_t< IsProxy_v<T> >> | |
decltype(auto) | blaze::operator+ (const T &lhs, const Proxy< PT, RT > &rhs) |
Addition between an object of different type and a Proxy object. More... | |
template<typename PT1 , typename RT1 , typename PT2 , typename RT2 > | |
decltype(auto) | blaze::operator- (const Proxy< PT1, RT1 > &lhs, const Proxy< PT2, RT2 > &rhs) |
Subtraction between two Proxy objects. More... | |
template<typename PT , typename RT , typename T , typename = DisableIf_t< IsProxy_v<T> >> | |
decltype(auto) | blaze::operator- (const Proxy< PT, RT > &lhs, const T &rhs) |
Subtraction between a Proxy object and an object of different type. More... | |
template<typename T , typename PT , typename RT , typename = DisableIf_t< IsProxy_v<T> >> | |
decltype(auto) | blaze::operator- (const T &lhs, const Proxy< PT, RT > &rhs) |
Subtraction between an object of different type and a Proxy object. More... | |
template<typename PT1 , typename RT1 , typename PT2 , typename RT2 > | |
decltype(auto) | blaze::operator* (const Proxy< PT1, RT1 > &lhs, const Proxy< PT2, RT2 > &rhs) |
Multiplication between two Proxy objects. More... | |
template<typename PT , typename RT , typename T , typename = DisableIf_t< IsProxy_v<T> >> | |
decltype(auto) | blaze::operator* (const Proxy< PT, RT > &lhs, const T &rhs) |
Multiplication between a Proxy object and an object of different type. More... | |
template<typename T , typename PT , typename RT , typename = DisableIf_t< IsProxy_v<T> >> | |
decltype(auto) | blaze::operator* (const T &lhs, const Proxy< PT, RT > &rhs) |
Multiplication between an object of different type and a Proxy object. More... | |
template<typename PT1 , typename RT1 , typename PT2 , typename RT2 > | |
decltype(auto) | blaze::operator/ (const Proxy< PT1, RT1 > &lhs, const Proxy< PT2, RT2 > &rhs) |
Division between two Proxy objects. More... | |
template<typename PT , typename RT , typename T , typename = DisableIf_t< IsProxy_v<T> >> | |
decltype(auto) | blaze::operator/ (const Proxy< PT, RT > &lhs, const T &rhs) |
Division between a Proxy object and an object of different type. More... | |
template<typename T , typename PT , typename RT , typename = DisableIf_t< IsProxy_v<T> >> | |
decltype(auto) | blaze::operator/ (const T &lhs, const Proxy< PT, RT > &rhs) |
Division between an object of different type and a Proxy object. More... | |
template<typename PT1 , typename RT1 , typename PT2 , typename RT2 > | |
bool | blaze::operator== (const Proxy< PT1, RT1 > &lhs, const Proxy< PT2, RT2 > &rhs) |
Equality comparison between two Proxy objects. More... | |
template<typename PT , typename RT , typename T , typename = DisableIf_t< IsProxy_v<T> >> | |
bool | blaze::operator== (const Proxy< PT, RT > &lhs, const T &rhs) |
Equality comparison between a Proxy object and an object of different type. More... | |
template<typename T , typename PT , typename RT , typename = DisableIf_t< IsProxy_v<T> >> | |
bool | blaze::operator== (const T &lhs, const Proxy< PT, RT > &rhs) |
Equality comparison between an object of different type and a Proxy object. More... | |
template<typename PT1 , typename RT1 , typename PT2 , typename RT2 > | |
bool | blaze::operator!= (const Proxy< PT1, RT1 > &lhs, const Proxy< PT2, RT2 > &rhs) |
Inequality comparison between two Proxy objects. More... | |
template<typename PT , typename RT , typename T , typename = DisableIf_t< IsProxy_v<T> >> | |
bool | blaze::operator!= (const Proxy< PT, RT > &lhs, const T &rhs) |
Inequality comparison between a Proxy object and an object of different type. More... | |
template<typename T , typename PT , typename RT , typename = DisableIf_t< IsProxy_v<T> >> | |
bool | blaze::operator!= (const T &lhs, const Proxy< PT, RT > &rhs) |
Inquality comparison between an object of different type and a Proxy object. More... | |
template<typename PT1 , typename RT1 , typename PT2 , typename RT2 > | |
bool | blaze::operator< (const Proxy< PT1, RT1 > &lhs, const Proxy< PT2, RT2 > &rhs) |
Less-than comparison between two Proxy objects. More... | |
template<typename PT , typename RT , typename T , typename = DisableIf_t< IsProxy_v<T> >> | |
bool | blaze::operator< (const Proxy< PT, RT > &lhs, const T &rhs) |
Less-than comparison between a Proxy object and an object of different type. More... | |
template<typename T , typename PT , typename RT , typename = DisableIf_t< IsProxy_v<T> >> | |
bool | blaze::operator< (const T &lhs, const Proxy< PT, RT > &rhs) |
Less-than comparison between an object of different type and a Proxy object. More... | |
template<typename PT1 , typename RT1 , typename PT2 , typename RT2 > | |
bool | blaze::operator> (const Proxy< PT1, RT1 > &lhs, const Proxy< PT2, RT2 > &rhs) |
Greater-than comparison between two Proxy objects. More... | |
template<typename PT , typename RT , typename T , typename = DisableIf_t< IsProxy_v<T> >> | |
bool | blaze::operator> (const Proxy< PT, RT > &lhs, const T &rhs) |
Greater-than comparison between a Proxy object and an object of different type. More... | |
template<typename T , typename PT , typename RT , typename = DisableIf_t< IsProxy_v<T> >> | |
bool | blaze::operator> (const T &lhs, const Proxy< PT, RT > &rhs) |
Greater-than comparison between an object of different type and a Proxy object. More... | |
template<typename PT1 , typename RT1 , typename PT2 , typename RT2 > | |
bool | blaze::operator<= (const Proxy< PT1, RT1 > &lhs, const Proxy< PT2, RT2 > &rhs) |
Less-or-equal-than comparison between two Proxy objects. More... | |
template<typename PT , typename RT , typename T , typename = DisableIf_t< IsProxy_v<T> >> | |
bool | blaze::operator<= (const Proxy< PT, RT > &lhs, const T &rhs) |
Less-or-equal-than comparison between a Proxy object and an object of different type. More... | |
template<typename T , typename PT , typename RT , typename = DisableIf_t< IsProxy_v<T> >> | |
bool | blaze::operator<= (const T &lhs, const Proxy< PT, RT > &rhs) |
Less-or-equal-than comparison between an object of different type and a Proxy object. More... | |
template<typename PT1 , typename RT1 , typename PT2 , typename RT2 > | |
bool | blaze::operator>= (const Proxy< PT1, RT1 > &lhs, const Proxy< PT2, RT2 > &rhs) |
Greater-or-equal-than comparison between two Proxy objects. More... | |
template<typename PT , typename RT , typename T , typename = DisableIf_t< IsProxy_v<T> >> | |
bool | blaze::operator>= (const Proxy< PT, RT > &lhs, const T &rhs) |
Greater-or-equal-than comparison between a Proxy object and an object of different type. More... | |
template<typename T , typename PT , typename RT , typename = DisableIf_t< IsProxy_v<T> >> | |
bool | blaze::operator>= (const T &lhs, const Proxy< PT, RT > &rhs) |
Greater-or-equal-than comparison between an object of different type and a Proxy object. More... | |
template<typename PT , typename RT > | |
std::ostream & | blaze::operator<< (std::ostream &os, const Proxy< PT, RT > &proxy) |
Global output operator for the Proxy class template. More... | |
Proxy global functions | |
template<typename PT , typename RT > | |
decltype(auto) | blaze::abs (const Proxy< PT, RT > &proxy) |
Computing the absolute value of the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | blaze::sign (const Proxy< PT, RT > &proxy) |
Evaluating the sign of the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | blaze::floor (const Proxy< PT, RT > &proxy) |
Computes the largest integral value that is not greater than the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | blaze::ceil (const Proxy< PT, RT > &proxy) |
Computes the smallest integral value that is not less than the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | blaze::trunc (const Proxy< PT, RT > &proxy) |
Computes the nearest integral value that is not greater than the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | blaze::round (const Proxy< PT, RT > &proxy) |
Computes the nearest integral value to the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | blaze::conj (const Proxy< PT, RT > &proxy) |
Computing the complex conjugate of the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | blaze::trans (const Proxy< PT, RT > &proxy) |
Computing the transpose of the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | blaze::ctrans (const Proxy< PT, RT > &proxy) |
Computing the conjugate transpose of the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | blaze::real (const Proxy< PT, RT > &proxy) |
Computing the real part of the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | blaze::imag (const Proxy< PT, RT > &proxy) |
Computing the imaginary part of the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | blaze::sqrt (const Proxy< PT, RT > &proxy) |
Computing the square root of the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | blaze::invsqrt (const Proxy< PT, RT > &proxy) |
Computing the inverse square root of the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | blaze::cbrt (const Proxy< PT, RT > &proxy) |
Computing the cubic root of the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | blaze::invcbrt (const Proxy< PT, RT > &proxy) |
Computing the inverse cubic root of the represented element. More... | |
template<typename PT1 , typename RT1 , typename PT2 , typename RT2 > | |
decltype(auto) | blaze::hypot (const Proxy< PT1, RT1 > &lhs, const Proxy< PT2, RT2 > &rhs) |
Computes the hypotenous of the two Proxy objects. More... | |
template<typename PT , typename RT , typename T , typename = DisableIf_t< IsProxy_v<T> >> | |
decltype(auto) | blaze::hypot (const Proxy< PT, RT > &lhs, const T &rhs) |
Computes the hypotenous of a Proxy object and an object of different type. More... | |
template<typename T , typename PT , typename RT , typename = DisableIf_t< IsProxy_v<T> >> | |
decltype(auto) | blaze::hypot (const T &lhs, const Proxy< PT, RT > &rhs) |
Computes the hypotenous of an object of different type and a Proxy object. More... | |
template<typename PT , typename RT , typename ET > | |
decltype(auto) | blaze::pow (const Proxy< PT, RT > &proxy, const ET &exp) |
Computing the exponential value of the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | blaze::exp (const Proxy< PT, RT > &proxy) |
Computing the base-e exponential of the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | blaze::exp2 (const Proxy< PT, RT > &proxy) |
Computing the base-2 exponential of the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | blaze::exp10 (const Proxy< PT, RT > &proxy) |
Computing the base-10 exponential of the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | blaze::log (const Proxy< PT, RT > &proxy) |
Computing the natural logarithm of the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | blaze::log2 (const Proxy< PT, RT > &proxy) |
Computing the binary logarithm of the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | blaze::log10 (const Proxy< PT, RT > &proxy) |
Computing the common logarithm of the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | blaze::sin (const Proxy< PT, RT > &proxy) |
Computing the sine of the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | blaze::asin (const Proxy< PT, RT > &proxy) |
Computing the inverse sine of the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | blaze::sinh (const Proxy< PT, RT > &proxy) |
Computing the hyperbolic sine of the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | blaze::asinh (const Proxy< PT, RT > &proxy) |
Computing the inverse hyperbolic sine of the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | blaze::cos (const Proxy< PT, RT > &proxy) |
Computing the cosine of the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | blaze::acos (const Proxy< PT, RT > &proxy) |
Computing the inverse cosine of the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | blaze::cosh (const Proxy< PT, RT > &proxy) |
Computing the hyperbolic cosine of the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | blaze::acosh (const Proxy< PT, RT > &proxy) |
Computing the inverse hyperbolic cosine of the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | blaze::tan (const Proxy< PT, RT > &proxy) |
Computing the tangent of the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | blaze::atan (const Proxy< PT, RT > &proxy) |
Computing the inverse tangent of the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | blaze::tanh (const Proxy< PT, RT > &proxy) |
Computing the hyperbolic tangent of the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | blaze::atanh (const Proxy< PT, RT > &proxy) |
Computing the inverse hyperbolic tangent of the represented element. More... | |
template<typename PT1 , typename RT1 , typename PT2 , typename RT2 > | |
decltype(auto) | blaze::atan2 (const Proxy< PT1, RT1 > &lhs, const Proxy< PT2, RT2 > &rhs) |
Computes the multi-valued inverse tangent of two Proxy objects. More... | |
template<typename PT , typename RT , typename T , typename = DisableIf_t< IsProxy_v<T> >> | |
decltype(auto) | blaze::atan2 (const Proxy< PT, RT > &lhs, const T &rhs) |
Computes the multi-valued inverse tangent of a Proxy object and an object of different type. More... | |
template<typename T , typename PT , typename RT , typename = DisableIf_t< IsProxy_v<T> >> | |
decltype(auto) | blaze::atan2 (const T &lhs, const Proxy< PT, RT > &rhs) |
Computes the multi-valued inverse tangent of an object of different type and a Proxy object. More... | |
template<typename PT , typename RT > | |
decltype(auto) | blaze::erf (const Proxy< PT, RT > &proxy) |
Computing the error function of the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | blaze::erfc (const Proxy< PT, RT > &proxy) |
Computing the complementary error function of the represented element. More... | |
template<typename PT1 , typename RT1 , typename PT2 , typename RT2 > | |
decltype(auto) | blaze::min (const Proxy< PT1, RT1 > &lhs, const Proxy< PT2, RT2 > &rhs) |
Minimum of two Proxy objects. More... | |
template<typename PT , typename RT , typename T , typename = DisableIf_t< IsProxy_v<T> >> | |
decltype(auto) | blaze::min (const Proxy< PT, RT > &lhs, const T &rhs) |
Minimum of a Proxy object and an object of different type. More... | |
template<typename T , typename PT , typename RT , typename = DisableIf_t< IsProxy_v<T> >> | |
decltype(auto) | blaze::min (const T &lhs, const Proxy< PT, RT > &rhs) |
Minimum of an object of different type and a Proxy object. More... | |
template<typename PT1 , typename RT1 , typename PT2 , typename RT2 > | |
decltype(auto) | blaze::max (const Proxy< PT1, RT1 > &lhs, const Proxy< PT2, RT2 > &rhs) |
Maximum of two Proxy objects. More... | |
template<typename PT , typename RT , typename T , typename = DisableIf_t< IsProxy_v<T> >> | |
decltype(auto) | blaze::max (const Proxy< PT, RT > &lhs, const T &rhs) |
Maximum of a Proxy object and an object of different type. More... | |
template<typename T , typename PT , typename RT , typename = DisableIf_t< IsProxy_v<T> >> | |
decltype(auto) | blaze::max (const T &lhs, const Proxy< PT, RT > &rhs) |
Maximum of an object of different type and a Proxy object. 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<bool RF, typename PT , typename RT > | |
bool | blaze::isReal (const Proxy< PT, RT > &proxy) |
Returns whether the element represents a real number. More... | |
template<bool RF, typename PT , typename RT > | |
bool | blaze::isZero (const Proxy< PT, RT > &proxy) |
Returns whether the represented element is 0. More... | |
template<bool RF, typename PT , typename RT > | |
bool | blaze::isOne (const Proxy< PT, RT > &proxy) |
Returns whether the represented element is 1. More... | |
template<typename PT , typename RT > | |
bool | blaze::isnan (const Proxy< PT, RT > &proxy) |
Returns whether the represented element is not a number. More... | |
template<bool RF, typename PT1 , typename RT1 , typename PT2 , typename RT2 > | |
bool | blaze::equal (const Proxy< PT1, RT1 > &lhs, const Proxy< PT2, RT2 > &rhs) |
Equality comparison between two Proxy objects. More... | |
template<bool RF, typename PT , typename RT , typename T , typename = DisableIf_t< IsProxy_v<T> >> | |
bool | blaze::equal (const Proxy< PT, RT > &lhs, const T &rhs) |
Equality comparison between a Proxy object and an object of different type. More... | |
template<bool RF, typename T , typename PT , typename RT , typename = DisableIf_t< IsProxy_v<T> >> | |
bool | blaze::equal (const T &lhs, const Proxy< PT, RT > &rhs) |
Equality comparison between an object of different type and a Proxy object. More... | |
template<typename PT , typename RT > | |
decltype(auto) | blaze::pow2 (const Proxy< PT, RT > &proxy) |
Computing the square value of the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | blaze::pow3 (const Proxy< PT, RT > &proxy) |
Computing the cube value of the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | blaze::pow4 (const Proxy< PT, RT > &proxy) |
Computing the quadruple value of the represented element. More... | |
#define BLAZE_THROW_DIVISION_BY_ZERO | ( | MESSAGE | ) | BLAZE_THROW_RUNTIME_ERROR( MESSAGE ) |
Macro for the emission of an exception on detection of a division by zero.This macro encapsulates the default way of Blaze to throw an exception on detection of a division by zero. Also, since it may be desirable to replace the type of exception by a custom exception type this macro provides an opportunity to customize the behavior.
The macro excepts a single argument, which specifies the message of the exception:
In order to customize the type of exception all that needs to be done is to define the macro prior to including any Blaze header file. This will override the Blaze default behavior. The following example demonstrates this by replacing std::runtime_error by a custom exception type:
#define BLAZE_THROW_LAPACK_ERROR | ( | MESSAGE | ) | BLAZE_THROW_RUNTIME_ERROR( MESSAGE ) |
Macro for the emission of an exception on detection of a LAPACK error.This macro encapsulates the default way of Blaze to throw an exception when encountering a LAPACK error (for instance when trying to invert a singular matrix). Also, since it may be desirable to replace the type of exception by a custom exception type this macro provides an opportunity to customize the behavior.
The macro excepts a single argument, which specifies the message of the exception:
In order to customize the type of exception all that needs to be done is to define the macro prior to including any Blaze header file. This will override the Blaze default behavior. The following example demonstrates this by replacing std::runtime_error by a custom exception type:
using blaze::make_shifted_index_sequence = typedef decltype( shift<Offset>( make_index_sequence<N>() ) ) |
Auxiliary alias declaration for the setup of shifted index sequences.The make_shifted_index_sequence alias template provides a convenient way to create index sequences with specific initial index and a specific number of indices. The following code example demonstrates the use of make_shifted_index_sequence:
using blaze::make_shifted_index_subsequence = typedef decltype( subsequence<Is...>( shift<Offset>( make_index_sequence<N>() ) ) ) |
Auxiliary alias declaration for the setup of shifted index subsequences.The make_shifted_index_subsequence alias template provides a convenient way to create a subsequence of an index sequences with specific initial index and a specific number of indices. The following code example demonstrates the use of make_shifted_index_subsequence:
enum blaze::AlignmentFlag : bool |
Alignment flag for (un-)aligned vectors and matrices.Via these flags it is possible to specify subvectors, submatrices, custom vectors and matrices as unaligned or aligned. The following example demonstrates the setup of an unaligned subvector:
Enumerator | |
---|---|
unaligned | Flag for unaligned vectors and matrices. |
aligned | Flag for aligned vectors and matrices. |
enum blaze::InversionFlag |
Inversion flag.The InversionFlag type enumeration represents the different types of matrix inversion algorithms that are available within the Blaze library. The following flags are available:
byLU:
The default inversion algorithm for general square matrices. It uses the LU algorithm to decompose a matrix into a lower unitriangular matrix L
, an upper triangular matrix U
, and a permutation matrix P
( P
is the identity matrix.byLDLT:
The Bunch-Kaufman inversion algorithm for symmetric indefinite matrices. It decomposes the given matrix into either U
(or L
) is a product of permutation and unit upper (lower) triangular matrices, and D
is symmetric and block diagonal with 1-by-1 and 2-by-2 diagonal blocks.byLDLH:
The Bunch-Kaufman inversion algorithm for Hermitian indefinite matrices. It decomposes the given matrix into either U
(or L
) is a product of permutation and unit upper (lower) triangular matrices, and D
is Hermitian and block diagonal with 1-by-1 and 2-by-2 diagonal blocks.byLLH:
The Cholesky inversion algorithm for Hermitian positive definite matrices. It decomposes a given matrix into either L
is a lower triangular matrix, or U
is an upper triangular matrix.Alternatively, the type of the matrix can be specified, leaving it to the Blaze library to select the appropriate matrix inversion algorithm. The following flags are available:
asGeneral:
This flag selects the best suited inversion algorithm for general square matrices. In case no further compile time information is available, this will imply the use of the LU decomposition algorithm (see the byLU
flag).asSymmetric:
This flag selects the most suited inversion algorithm for symmetric matrices. In case no further compile time information is available, the Bunch-Kaufman matrix decomposition algorithm will be used (see the byLDLT
flag).asHermitian:
This flag selects the most suited inversion algorithm for Hermitian matrices. In case no further compile time information is available, the Bunch-Kaufman matrix decomposition algorithm will be used (see the byLDLH
flag).asLower:
This flag selects the most suited inversion algorithm for lower triangular matrices. In case no further compile time information is available, the inversion will be performed by a forward substitution. No matrix decomposition will be performed.asUniLower:
This flag selects the most suited inversion algorithm for lower unitriangular matrices. In case no further compile time information is available, the inversion will be performed by a forward substitution. No matrix decomposition will be performed.asUpper:
This flag selects the most suited inversion algorithm for upper triangular matrices. In case no further compile time information is available, the inversion will be performed by a back substitution. No matrix decomposition will be performed.asUniUpper:
This flag selects the most suited inversion algorithm for upper unitriangular matrices. In case no further compile time information is available, the inversion will be performed by a back substitution. No matrix decomposition will be performed.asDiagonal:
This flag selects the most suited inversion algorithm for diagonal matrices. In case no further compile time information is available, the inversion will be performed by directly computing the reciprocal of each diagonal element. No matrix decomposition will be performed. decltype(auto) blaze::abs | ( | const Proxy< PT, RT > & | proxy | ) |
Computing the absolute value of the represented element.
proxy | The given proxy instance. |
This function computes the absolute value of the element represented by the proxy. In case the proxy represents a vector- or matrix-like data structure the function returns an expression representing the absolute values of the elements of the vector/matrix.
decltype(auto) blaze::acos | ( | const Proxy< PT, RT > & | proxy | ) |
Computing the inverse cosine of the represented element.
proxy | The given proxy instance. |
This function computes the inverse cosine of the element represented by the proxy. In case the proxy represents a vector- or matrix-like data structure the function returns an expression representing the inverse cosines of the elements of the vector/matrix.
decltype(auto) blaze::acosh | ( | const Proxy< PT, RT > & | proxy | ) |
Computing the inverse hyperbolic cosine of the represented element.
proxy | The given proxy instance. |
This function computes the inverse hyperbolic cosine of the element represented by the proxy. In case the proxy represents a vector- or matrix-like data structure the function returns an expression representing the inverse hyperbolic cosines of the elements of the vector/matrix.
decltype(auto) blaze::asin | ( | const Proxy< PT, RT > & | proxy | ) |
Computing the inverse sine of the represented element.
proxy | The given proxy instance. |
This function computes the inverse sine of the element represented by the proxy. In case the proxy represents a vector- or matrix-like data structure the function returns an expression representing the inverse sines of the elements of the vector/matrix.
decltype(auto) blaze::asinh | ( | const Proxy< PT, RT > & | proxy | ) |
Computing the inverse hyperbolic sine of the represented element.
proxy | The given proxy instance. |
This function computes the inverse hyperbolic sine of the element represented by the proxy. In case the proxy represents a vector- or matrix-like data structure the function returns an expression representing the inverse hyperbolic sines of the elements of the vector/matrix.
decltype(auto) blaze::atan | ( | const Proxy< PT, RT > & | proxy | ) |
Computing the inverse tangent of the represented element.
proxy | The given proxy instance. |
This function computes the inverse tangent of the element represented by the proxy. In case the proxy represents a vector- or matrix-like data structure the function returns an expression representing the inverse tangents of the elements of the vector/matrix.
decltype(auto) blaze::atan2 | ( | const Proxy< PT1, RT1 > & | lhs, |
const Proxy< PT2, RT2 > & | rhs | ||
) |
Computes the multi-valued inverse tangent of two Proxy objects.
This function computes the multi-valued inverse tangent of the elements represented by the two proxies lhs and rhs. In case the objects represent vector- or matrix-like data structures the function returns an expression representing the multi-valued inverse tangent of the elements of the vectors/matrices.
decltype(auto) blaze::atan2 | ( | const Proxy< PT, RT > & | lhs, |
const T & | rhs | ||
) |
Computes the multi-valued inverse tangent of a Proxy object and an object of different type.
lhs | The left-hand side Proxy object. |
rhs | The right-hand side object of other type. |
This function computes the multi-valued inverse tangent of the element represented by the proxy lhs and the object rhs. In case the objects represent vector- or matrix-like data structures the function returns an expression representing the multi-valued inverse tangent of the elements of the vectors/matrices.
decltype(auto) blaze::atan2 | ( | const T & | lhs, |
const Proxy< PT, RT > & | rhs | ||
) |
Computes the multi-valued inverse tangent of an object of different type and a Proxy object.
lhs | The left-hand side object of other type. |
rhs | The right-hand side Proxy object. |
This function computes the multi-valued inverse tangent of the element represented by the object lhs and the proxy rhs. In case the objects represent vector- or matrix-like data structures the function returns an expression representing the multi-valued inverse tangent of the elements of the vectors/matrices.
decltype(auto) blaze::atanh | ( | const Proxy< PT, RT > & | proxy | ) |
Computing the inverse hyperbolic tangent of the represented element.
proxy | The given proxy instance. |
This function computes the inverse hyperbolic tangent of the element represented by the proxy. In case the proxy represents a vector- or matrix-like data structure the function returns an expression representing the inverse hyperbolic tangents of the elements of the vector/matrix.
BLAZE_ALWAYS_INLINE DenseVectorProxy<PT,VT>::Iterator blaze::begin | ( | const DenseVectorProxy< PT, VT > & | proxy | ) |
Returns an iterator to the first element of the represented vector.
proxy | The given access proxy. |
BLAZE_ALWAYS_INLINE DenseMatrixProxy<PT,MT>::Iterator blaze::begin | ( | const DenseMatrixProxy< PT, MT > & | proxy, |
size_t | i | ||
) |
Returns an iterator to the first element of row/column i of the represented matrix.
proxy | The given access proxy. |
i | The row/column index. |
This function returns a row/column iterator to the first element of row/column i. In case the given matrix is a row-major matrix the function returns an iterator to the first element of row i, in case it is a column-major matrix the function returns an iterator to the first element of column i.
BLAZE_ALWAYS_INLINE SparseVectorProxy<PT,VT>::Iterator blaze::begin | ( | const SparseVectorProxy< PT, VT > & | proxy | ) |
Returns an iterator to the first element of the represented vector.
proxy | The given access proxy. |
BLAZE_ALWAYS_INLINE SparseMatrixProxy<PT,MT>::Iterator blaze::begin | ( | const SparseMatrixProxy< PT, MT > & | proxy, |
size_t | i | ||
) |
Returns an iterator to the first element of row/column i of the represented matrix.
proxy | The given access proxy. |
i | The row/column index. |
This function returns a row/column iterator to the first element of row/column i. In case the given matrix is a row-major matrix the function returns an iterator to the first element of row i, in case it is a column-major matrix the function returns an iterator to the first element of column i.
BLAZE_ALWAYS_INLINE size_t blaze::capacity | ( | const DenseVectorProxy< PT, VT > & | proxy | ) |
Returns the maximum capacity of the represented vector.
proxy | The given access proxy. |
BLAZE_ALWAYS_INLINE size_t blaze::capacity | ( | const DenseMatrixProxy< PT, MT > & | proxy | ) |
Returns the maximum capacity of the represented matrix.
proxy | The given access proxy. |
BLAZE_ALWAYS_INLINE size_t blaze::capacity | ( | const SparseVectorProxy< PT, VT > & | proxy | ) |
Returns the maximum capacity of the represented vector.
proxy | The given access proxy. |
BLAZE_ALWAYS_INLINE size_t blaze::capacity | ( | const DenseMatrixProxy< PT, MT > & | proxy, |
size_t | i | ||
) |
Returns the current capacity of the specified row/column of the represented matrix.
proxy | The given access proxy. |
i | The index of the row/column. |
This function returns the current capacity of the specified row/column. In case the storage order is set to rowMajor the function returns the capacity of row i, in case the storage flag is set to columnMajor the function returns the capacity of column i.
BLAZE_ALWAYS_INLINE size_t blaze::capacity | ( | const SparseMatrixProxy< PT, MT > & | proxy | ) |
Returns the maximum capacity of the represented matrix.
proxy | The given access proxy. |
BLAZE_ALWAYS_INLINE size_t blaze::capacity | ( | const SparseMatrixProxy< PT, MT > & | proxy, |
size_t | i | ||
) |
Returns the current capacity of the specified row/column of the represented matrix.
proxy | The given access proxy. |
i | The index of the row/column. |
This function returns the current capacity of the specified row/column. In case the storage order is set to rowMajor the function returns the capacity of row i, in case the storage flag is set to columnMajor the function returns the capacity of column i.
BLAZE_ALWAYS_INLINE DenseVectorProxy<PT,VT>::ConstIterator blaze::cbegin | ( | const DenseVectorProxy< PT, VT > & | proxy | ) |
Returns an iterator to the first element of the represented vector.
proxy | The given access proxy. |
BLAZE_ALWAYS_INLINE DenseMatrixProxy<PT,MT>::ConstIterator blaze::cbegin | ( | const DenseMatrixProxy< PT, MT > & | proxy, |
size_t | i | ||
) |
Returns an iterator to the first element of row/column i of the represented matrix.
proxy | The given access proxy. |
i | The row/column index. |
This function returns a row/column iterator to the first element of row/column i. In case the given matrix is a row-major matrix the function returns an iterator to the first element of row i, in case it is a column-major matrix the function returns an iterator to the first element of column i.
BLAZE_ALWAYS_INLINE SparseVectorProxy<PT,VT>::ConstIterator blaze::cbegin | ( | const SparseVectorProxy< PT, VT > & | proxy | ) |
Returns an iterator to the first element of the represented vector.
proxy | The given access proxy. |
BLAZE_ALWAYS_INLINE SparseMatrixProxy<PT,MT>::ConstIterator blaze::cbegin | ( | const SparseMatrixProxy< PT, MT > & | proxy, |
size_t | i | ||
) |
Returns an iterator to the first element of row/column i of the represented matrix.
proxy | The given access proxy. |
i | The row/column index. |
This function returns a row/column iterator to the first element of row/column i. In case the given matrix is a row-major matrix the function returns an iterator to the first element of row i, in case it is a column-major matrix the function returns an iterator to the first element of column i.
decltype(auto) blaze::cbrt | ( | const Proxy< PT, RT > & | proxy | ) |
Computing the cubic root of the represented element.
proxy | The given proxy instance. |
This function computes the cubic root of the element represented by the proxy. In case the proxy represents a vector- or matrix-like data structure the function returns an expression representing the cubic roots of the elements of the vector/matrix.
decltype(auto) blaze::ceil | ( | const Proxy< PT, RT > & | proxy | ) |
Computes the smallest integral value that is not less than the represented element.
proxy | The given proxy instance. |
This function computes the smallest integral value that is not less than the element represented by the proxy. In case the proxy represents a vector- or matrix-like data structure the function returns an expression representing the operation.
BLAZE_ALWAYS_INLINE DenseVectorProxy<PT,VT>::ConstIterator blaze::cend | ( | const DenseVectorProxy< PT, VT > & | proxy | ) |
Returns an iterator just past the last element of the represented vector.
proxy | The given access proxy. |
BLAZE_ALWAYS_INLINE DenseMatrixProxy<PT,MT>::ConstIterator blaze::cend | ( | const DenseMatrixProxy< PT, MT > & | proxy, |
size_t | i | ||
) |
Returns an iterator just past the last element of row/column i of the represented matrix.
proxy | The given access proxy. |
i | The row/column index. |
In case the access proxy represents a matrix-like data structure that provides a cend() function, this function returns an iterator just past the last element of row/column i of the matrix. In case the given matrix is a row-major matrix the function returns an iterator just past the last element of row i, in case it is a column-major matrix the function returns an iterator just past the last element of column i.
BLAZE_ALWAYS_INLINE SparseVectorProxy<PT,VT>::ConstIterator blaze::cend | ( | const SparseVectorProxy< PT, VT > & | proxy | ) |
Returns an iterator just past the last element of the represented vector.
proxy | The given access proxy. |
BLAZE_ALWAYS_INLINE SparseMatrixProxy<PT,MT>::ConstIterator blaze::cend | ( | const SparseMatrixProxy< PT, MT > & | proxy, |
size_t | i | ||
) |
Returns an iterator just past the last element of row/column i of the represented matrix.
proxy | The given access proxy. |
i | The row/column index. |
In case the access proxy represents a matrix-like data structure that provides a cend() function, this function returns an iterator just past the last element of row/column i of the matrix. In case the given matrix is a row-major matrix the function returns an iterator just past the last element of row i, in case it is a column-major matrix the function returns an iterator just past the last element of column i.
BLAZE_ALWAYS_INLINE void blaze::clear | ( | const DenseVectorProxy< PT, VT > & | proxy | ) |
Clearing the represented vector.
proxy | The given access proxy. |
This function clears the vector to its default initial state.
BLAZE_ALWAYS_INLINE void blaze::clear | ( | const SparseVectorProxy< PT, VT > & | proxy | ) |
Clearing the represented element.
proxy | The given access proxy. |
This function clears the vector to its default initial state.
BLAZE_ALWAYS_INLINE void blaze::clear | ( | const DenseMatrixProxy< PT, MT > & | proxy | ) |
Clearing the represented matrix.
proxy | The given access proxy. |
This function clears the matrix to its default initial state.
BLAZE_ALWAYS_INLINE void blaze::clear | ( | const SparseMatrixProxy< PT, MT > & | proxy | ) |
Clearing the represented matrix.
proxy | The given access proxy. |
This function clears the matrix to its default initial state.
BLAZE_ALWAYS_INLINE size_t blaze::columns | ( | const DenseMatrixProxy< PT, MT > & | proxy | ) |
Returns the current number of columns of the represented matrix.
proxy | The given access proxy. |
BLAZE_ALWAYS_INLINE size_t blaze::columns | ( | const SparseMatrixProxy< PT, MT > & | proxy | ) |
Returns the current number of columns of the represented matrix.
proxy | The given access proxy. |
decltype(auto) blaze::conj | ( | const Proxy< PT, RT > & | proxy | ) |
Computing the complex conjugate of the represented element.
proxy | The given proxy instance. |
This function computes the complex conjugate of the element represented by the proxy. In case the proxy represents a vector- or matrix-like data structure the function returns an expression representing the complex conjugate of the vector/matrix.
decltype(auto) blaze::cos | ( | const Proxy< PT, RT > & | proxy | ) |
Computing the cosine of the represented element.
proxy | The given proxy instance. |
This function computes the cosine of the element represented by the proxy. In case the proxy represents a vector- or matrix-like data structure the function returns an expression representing the cosines of the elements of the vector/matrix.
decltype(auto) blaze::cosh | ( | const Proxy< PT, RT > & | proxy | ) |
Computing the hyperbolic cosine of the represented element.
proxy | The given proxy instance. |
This function computes the hyperbolic cosine of the element represented by the proxy. In case the proxy represents a vector- or matrix-like data structure the function returns an expression representing the hyperbolic cosines of the elements of the vector/matrix.
decltype(auto) blaze::ctrans | ( | const Proxy< PT, RT > & | proxy | ) |
Computing the conjugate transpose of the represented element.
proxy | The given proxy instance. |
This function returns an expression representing the conjugate transpose of the element represented by the proxy.
|
inline |
In-place conjugate transpose of the represented matrix element.
proxy | The given proxy instance. |
std::invalid_argument | Invalid access to restricted element. |
std::logic_error | Matrix cannot be transposed. |
This function transposes the represented matrix in-place. The transpose operation fails if ...
In all failure cases a std::logic_error exception is thrown. Additionally, in case the represented matrix cannot be modified, a std::invalid_argument exception is thrown.
|
inlinenoexcept |
Determines the maximum number of columns specified by the given initializer list.
list | The given initializer list |
BLAZE_ALWAYS_INLINE DenseVectorProxy<PT,VT>::Iterator blaze::end | ( | const DenseVectorProxy< PT, VT > & | proxy | ) |
Returns an iterator just past the last element of the represented vector.
proxy | The given access proxy. |
BLAZE_ALWAYS_INLINE DenseMatrixProxy<PT,MT>::Iterator blaze::end | ( | const DenseMatrixProxy< PT, MT > & | proxy, |
size_t | i | ||
) |
Returns an iterator just past the last element of row/column i of the represented matrix.
proxy | The given access proxy. |
i | The row/column index. |
In case the access proxy represents a matrix-like data structure that provides an end() function, this function returns an iterator just past the last element of row/column i of the matrix. In case the given matrix is a row-major matrix the function returns an iterator just past the last element of row i, in case it is a column-major matrix the function returns an iterator just past the last element of column i.
BLAZE_ALWAYS_INLINE SparseVectorProxy<PT,VT>::Iterator blaze::end | ( | const SparseVectorProxy< PT, VT > & | proxy | ) |
Returns an iterator just past the last element of the represented vector.
proxy | The given access proxy. |
BLAZE_ALWAYS_INLINE SparseMatrixProxy<PT,MT>::Iterator blaze::end | ( | const SparseMatrixProxy< PT, MT > & | proxy, |
size_t | i | ||
) |
Returns an iterator just past the last element of row/column i of the represented matrix.
proxy | The given access proxy. |
i | The row/column index. |
In case the access proxy represents a matrix-like data structure that provides an end() function, this function returns an iterator just past the last element of row/column i of the matrix. In case the given matrix is a row-major matrix the function returns an iterator just past the last element of row i, in case it is a column-major matrix the function returns an iterator just past the last element of column i.
|
inline |
|
inline |
decltype(auto) blaze::erf | ( | const Proxy< PT, RT > & | proxy | ) |
Computing the error function of the represented element.
proxy | The given proxy instance. |
This function computes the error function of the element represented by the proxy. In case the proxy represents a vector- or matrix-like data structure the function returns an expression representing the error functions of the elements of the vector/matrix.
decltype(auto) blaze::erfc | ( | const Proxy< PT, RT > & | proxy | ) |
Computing the complementary error function of the represented element.
proxy | The given proxy instance. |
This function computes the complementary error function of the element represented by the proxy. In case the proxy represents a vector- or matrix-like data structure the function returns an expression representing the complementary error functions of the elements of the vector/matrix.
decltype(auto) blaze::exp | ( | const Proxy< PT, RT > & | proxy | ) |
Computing the base-e exponential of the represented element.
proxy | The given proxy instance. |
This function computes the base-e exponential of the element represented by the proxy. In case the proxy represents a vector- or matrix-like data structure the function returns an expression representing the base-e exponentials of the elements of the vector/matrix.
decltype(auto) blaze::exp10 | ( | const Proxy< PT, RT > & | proxy | ) |
Computing the base-10 exponential of the represented element.
proxy | The given proxy instance. |
This function computes the base-10 exponential of the element represented by the proxy. In case the proxy represents a vector- or matrix-like data structure the function returns an expression representing the base-10 exponentials of the elements of the vector/matrix.
decltype(auto) blaze::exp2 | ( | const Proxy< PT, RT > & | proxy | ) |
Computing the base-2 exponential of the represented element.
proxy | The given proxy instance. |
This function computes the base-2 exponential of the element represented by the proxy. In case the proxy represents a vector- or matrix-like data structure the function returns an expression representing the base-2 exponentials of the elements of the vector/matrix.
decltype(auto) blaze::floor | ( | const Proxy< PT, RT > & | proxy | ) |
Computes the largest integral value that is not greater than the represented element.
proxy | The given proxy instance. |
This function computes the largest integral value that is not greater than the element represented by the proxy. In case the proxy represents a vector- or matrix-like data structure the function returns an expression representing the operation.
decltype(auto) blaze::hypot | ( | const Proxy< PT1, RT1 > & | lhs, |
const Proxy< PT2, RT2 > & | rhs | ||
) |
Computes the hypotenous of the two Proxy objects.
This function computes the hypotenous of the elements represented by the two proxies lhs and rhs. In case the objects represent vector- or matrix-like data structures the function returns an expression representing the hypotenous of the elements of the vectors/matrices.
decltype(auto) blaze::hypot | ( | const Proxy< PT, RT > & | lhs, |
const T & | rhs | ||
) |
Computes the hypotenous of a Proxy object and an object of different type.
lhs | The left-hand side Proxy object. |
rhs | The right-hand side object of other type. |
This function computes the hypotenous of the element represented by the proxy lhs and the object rhs. In case the objects represent vector- or matrix-like data structures the function returns an expression representing the hypotenous of the elements of the vectors/matrices.
decltype(auto) blaze::hypot | ( | const T & | lhs, |
const Proxy< PT, RT > & | rhs | ||
) |
Computes the hypotenous of an object of different type and a Proxy object.
lhs | The left-hand side object of other type. |
rhs | The right-hand side Proxy object. |
This function computes the hypotenous of the element represented by the object lhs and the proxy rhs. In case the objects represent vector- or matrix-like data structures the function returns an expression representing the hypotenous of the elements of the vectors/matrices.
decltype(auto) blaze::imag | ( | const Proxy< PT, RT > & | proxy | ) |
Computing the imaginary part of the represented element.
proxy | The given proxy instance. |
This function returns the imaginary part of the element represented by the proxy. In case the proxy represents a vector- or matrix-like data structure the function returns an expression representing the real part of each each element of the vector/matrix.
decltype(auto) blaze::invcbrt | ( | const Proxy< PT, RT > & | proxy | ) |
Computing the inverse cubic root of the represented element.
proxy | The given proxy instance. |
This function computes the inverse cubic root of the element represented by the proxy. In case the proxy represents a vector- or matrix-like data structure the function returns an expression representing the inverse cubic roots of the elements of the vector/matrix.
|
inline |
In-place inversion of the represented element.
proxy | The given proxy instance. |
std::invalid_argument | Invalid access to restricted element. |
std::invalid_argument | Inversion of singular matrix failed. |
std::invalid_argument | Invalid non-square matrix provided. |
This function inverts the represented scalar or dense matrix element. The inversion fails if the represented element is a dense matrix, which ...
In all failure cases either a compilation error is created if the failure can be predicted at compile time or a std::invalid_argument exception is thrown. Additionally, in case the represented scalar or matrix cannot be modified, a std::invalid_argument exception is thrown.
|
inline |
In-place inversion of the represented element.
proxy | The given proxy instance. |
std::invalid_argument | Invalid access to restricted element. |
std::invalid_argument | Inversion of singular matrix failed. |
std::invalid_argument | Invalid non-square matrix provided. |
This function inverts the represented dense matrix element by means of the specified matrix inversion algorithm IF:
The inversion fails if the represented dense matrix element ...
In all failure cases either a compilation error is created if the failure can be predicted at compile time or a std::invalid_argument exception is thrown. Additionally, in case the represented scalar or matrix cannot be modified, a std::invalid_argument exception is thrown.
decltype(auto) blaze::invsqrt | ( | const Proxy< PT, RT > & | proxy | ) |
Computing the inverse square root of the represented element.
proxy | The given proxy instance. |
This function computes the inverse square root of the element represented by the proxy. In case the proxy represents a vector- or matrix-like data structure the function returns an expression representing the inverse square roots of the elements of the vector/matrix.
|
inline |
Returns whether the represented element is not a number.
proxy | The given proxy instance. |
This function checks whether the element represented by the proxy is not a number (NaN). In case it is not a number, the function returns true, otherwise it returns false.
|
inline |
Returns whether the represented element is 1.
proxy | The given proxy instance. |
This function checks whether the element represented by the proxy represents the numeric value 1. In case it is 1, the function returns true, otherwise it returns false.
|
inline |
Returns whether the element represents a real number.
proxy | The given proxy instance. |
This function checks whether the element represented by the proxy represents the a real number. In case the element is of built-in type, the function returns true. In case the element is of complex type, the function returns true if the imaginary part is equal to 0. Otherwise it returns false.
|
inline |
Returns whether the represented element is 0.
proxy | The given proxy instance. |
This function checks whether the element represented by the proxy represents the numeric value 0. In case it is 0, the function returns true, otherwise it returns false.
decltype(auto) blaze::log | ( | const Proxy< PT, RT > & | proxy | ) |
Computing the natural logarithm of the represented element.
proxy | The given proxy instance. |
This function computes the natural logarithm of the element represented by the proxy. In case the proxy represents a vector- or matrix-like data structure the function returns an expression representing the natural logarithm of the elements of the vector/matrix.
decltype(auto) blaze::log10 | ( | const Proxy< PT, RT > & | proxy | ) |
Computing the common logarithm of the represented element.
proxy | The given proxy instance. |
This function computes the common logarithm of the element represented by the proxy. In case the proxy represents a vector- or matrix-like data structure the function returns an expression representing the common logarithm of the elements of the vector/matrix.
decltype(auto) blaze::log2 | ( | const Proxy< PT, RT > & | proxy | ) |
Computing the binary logarithm of the represented element.
proxy | The given proxy instance. |
This function computes the binary logarithm of the element represented by the proxy. In case the proxy represents a vector- or matrix-like data structure the function returns an expression representing the binary logarithm of the elements of the vector/matrix.
decltype(auto) blaze::max | ( | const Proxy< PT, RT > & | lhs, |
const T & | rhs | ||
) |
decltype(auto) blaze::max | ( | const T & | lhs, |
const Proxy< PT, RT > & | rhs | ||
) |
decltype(auto) blaze::min | ( | const Proxy< PT, RT > & | lhs, |
const T & | rhs | ||
) |
decltype(auto) blaze::min | ( | const T & | lhs, |
const Proxy< PT, RT > & | rhs | ||
) |
|
noexcept |
Rounds up an integral value to the next multiple of a given factor.
value | The integral value to be rounded up ![]() |
factor | The factor of the multiple ![]() |
This function rounds up the given integral value to the next multiple of the given integral factor. In case the integral value is already a multiple of the given factor, the value itself is returned. Note that the attempt to use the function with non-integral types results in a compilation error!
|
inlinenoexcept |
Determines the number of non-zero elements contained in the given initializer list.
list | The given initializer list |
|
inlinenoexcept |
Determines the number of non-zero elements contained in the given initializer list.
list | The given initializer list |
BLAZE_ALWAYS_INLINE size_t blaze::nonZeros | ( | const DenseVectorProxy< PT, VT > & | proxy | ) |
Returns the number of non-zero elements in the represented vector.
proxy | The given access proxy. |
Note that the number of non-zero elements is always less than or equal to the current size of the vector.
BLAZE_ALWAYS_INLINE size_t blaze::nonZeros | ( | const DenseMatrixProxy< PT, MT > & | proxy | ) |
Returns the number of non-zero elements in the represented matrix.
proxy | The given access proxy. |
BLAZE_ALWAYS_INLINE size_t blaze::nonZeros | ( | const SparseVectorProxy< PT, VT > & | proxy | ) |
Returns the number of non-zero elements in the represented vector.
proxy | The given access proxy. |
Note that the number of non-zero elements is always less than or equal to the current size of the vector.
BLAZE_ALWAYS_INLINE size_t blaze::nonZeros | ( | const DenseMatrixProxy< PT, MT > & | proxy, |
size_t | i | ||
) |
Returns the number of non-zero elements in the specified row/column of the represented matrix.
proxy | The given access proxy. |
i | The index of the row/column. |
This function returns the current number of non-zero elements in the specified row/column. In case the storage order is set to rowMajor the function returns the number of non-zero elements in row i, in case the storage flag is set to columnMajor the function returns the number of non-zero elements in column i.
BLAZE_ALWAYS_INLINE size_t blaze::nonZeros | ( | const SparseMatrixProxy< PT, MT > & | proxy | ) |
Returns the number of non-zero elements in the represented matrix.
proxy | The given access proxy. |
BLAZE_ALWAYS_INLINE size_t blaze::nonZeros | ( | const SparseMatrixProxy< PT, MT > & | proxy, |
size_t | i | ||
) |
Returns the number of non-zero elements in the specified row/column of the represented matrix.
proxy | The given access proxy. |
i | The index of the row/column. |
This function returns the current number of non-zero elements in the specified row/column. In case the storage order is set to rowMajor the function returns the number of non-zero elements in row i, in case the storage flag is set to columnMajor the function returns the number of non-zero elements in column i.
|
noexcept |
Inequality operator for the comparison of two index sequences.
lhs | The left-hand side index sequence for the comparison. |
rhs | The right-hand side index sequence for the comparison. |
|
inline |
Inequality comparison between a NegativeEpsilon object and a floating point value.
rhs | The right-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Inequality comparison between a NegativeAccuracy object and a floating point value.
rhs | The right-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Inequality comparison between a floating point value and a NegativeEpsilon object.
lhs | The left-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Inequality comparison between a floating point value and a NegativeAccuracy object.
lhs | The left-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
|
inline |
|
inline |
Inequality comparison between two NegativeInfinity objects.
|
inline |
Inequality comparison between an NegativeInfinity object and a built-in data type.
lhs | The left-hand side NegativeInfinity object. |
rhs | The right-hand side built-in data value. |
This operator works only for built-in data types. The attempt to compare user-defined class types will result in a compile time error.
|
inline |
Inequality comparison between a built-in data type and an NegativeInfinity object.
lhs | The left-hand side built-in data value. |
rhs | The right-hand side NegativeInfinity object. |
This operator works only for built-in data types. The attempt to compare user-defined class types will result in a compile time error.
|
inline |
Inequality comparison between an Epsilon object and a floating point value.
rhs | The right-hand side floating point value. |
This operator works only for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Inequality comparison between an Accuracy object and a floating point value.
rhs | The right-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Inequality comparison between a floating point value and an Epsilon object.
lhs | The left-hand side floating point value. |
This operator works only for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Inequality comparison between a floating point value and an Accuracy object.
lhs | The left-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
Inequality comparison between two Infinity objects.
|
inline |
Inequality comparison between an Infinity object and a NegativeInfinity object.
|
inline |
Inequality comparison between a NegativeInfinity object and an Infinity object.
|
inline |
Inequality comparison between an Infinity object and a built-in data type.
lhs | The left-hand side Infinity object. |
rhs | The right-hand side built-in data value. |
This operator works only for built-in data types. The attempt to compare user-defined class types will result in a compile time error.
|
inline |
Inequality comparison between a built-in data type and an Infinity object.
lhs | The left-hand side built-in data value. |
rhs | The right-hand side Infinity object. |
This operator works only for built-in data types. The attempt to compare user-defined class types will result in a compile time error.
decltype(auto) blaze::operator* | ( | const Proxy< PT, RT > & | lhs, |
const T & | rhs | ||
) |
decltype(auto) blaze::operator* | ( | const T & | lhs, |
const Proxy< PT, RT > & | rhs | ||
) |
decltype(auto) blaze::operator+ | ( | const Proxy< PT, RT > & | lhs, |
const T & | rhs | ||
) |
decltype(auto) blaze::operator+ | ( | const T & | lhs, |
const Proxy< PT, RT > & | rhs | ||
) |
decltype(auto) blaze::operator- | ( | const Proxy< PT, RT > & | lhs, |
const T & | rhs | ||
) |
decltype(auto) blaze::operator- | ( | const T & | lhs, |
const Proxy< PT, RT > & | rhs | ||
) |
decltype(auto) blaze::operator/ | ( | const Proxy< PT, RT > & | lhs, |
const T & | rhs | ||
) |
decltype(auto) blaze::operator/ | ( | const T & | lhs, |
const Proxy< PT, RT > & | rhs | ||
) |
|
inline |
Less-than comparison between a NegativeEpsilon object and a floating point value.
rhs | The right-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Less-than comparison between a NegativeAccuracy object and a floating point value.
rhs | The right-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Less-than comparison between a floating point value and a NegativeEpsilon object.
lhs | The left-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Less-than comparison between a floating point value and a NegativeAccuracy object.
lhs | The left-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
|
inline |
|
inline |
Less-than comparison between an Epsilon object and a floating point value.
rhs | The right-hand side floating point value. |
This operator works only for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Less-than comparison between an Accuracy object and a floating point value.
rhs | The right-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Less-than comparison between a floating point value and an Epsilon object.
lhs | The left-hand side floating point value. |
This operator works only for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Less-than comparison between a floating point value and an Accuracy object.
lhs | The left-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Global output operator for the Proxy class template.
os | Reference to the output stream. |
proxy | Reference to a constant proxy object. |
|
inline |
|
inline |
|
inline |
Less-or-equal-than comparison between an Epsilon object and a floating point value.
rhs | The right-hand side floating point value. |
This operator works only for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Less-or-equal-than comparison between an Accuracy object and a floating point value.
rhs | The right-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Less-or-equal-than comparison between a floating point value and an Epsilon object.
lhs | The left-hand side floating point value. |
This operator works only for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Less-or-equal-than comparison between a floating point value and an Accuracy object.
lhs | The left-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
noexcept |
Equality operator for the comparison of two index sequences.
lhs | The left-hand side index sequence for the comparison. |
rhs | The right-hand side index sequence for the comparison. |
|
inline |
Equality comparison between a NegativeEpsilon object and a floating point value.
rhs | The right-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Equality comparison between a NegativeAccuracy object and a floating point value.
rhs | The right-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
|
inline |
Equality comparison between a floating point value and a NegativeEpsilon object.
lhs | The left-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Equality comparison between a floating point value and a NegativeAccuracy object.
lhs | The left-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
|
inline |
Equality comparison between two NegativeInfinity objects.
|
inline |
Equality comparison between an NegativeInfinity object and a built-in data type.
lhs | The left-hand side NegativeInfinity object. |
rhs | The right-hand side built-in data value. |
This operator works only for built-in data types. The attempt to compare user-defined class types will result in a compile time error.
|
inline |
Equality comparison between a built-in data type and an NegativeInfinity object.
lhs | The left-hand side built-in data value. |
rhs | The right-hand side NegativeInfinity object. |
This operator works only for built-in data types. The attempt to compare user-defined class types will result in a compile time error.
|
inline |
Equality comparison between an Epsilon object and a floating point value.
rhs | The right-hand side floating point value. |
This operator works only for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Equality comparison between an Accuracy object and a floating point value.
rhs | The right-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Equality comparison between a floating point value and an Epsilon object.
lhs | The left-hand side floating point value. |
This operator works only for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Equality comparison between a floating point value and an Accuracy object.
lhs | The left-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
Equality comparison between two Infinity objects.
|
inline |
Equality comparison between an Infinity object and a NegativeInfinity object.
|
inline |
Equality comparison between a NegativeInfinity object and an Infinity object.
|
inline |
Equality comparison between an Infinity object and a built-in data type.
lhs | The left-hand side Infinity object. |
rhs | The right-hand side built-in data value. |
This operator works only for built-in data types. The attempt to compare user-defined class types will result in a compile time error.
|
inline |
Equality comparison between a built-in data type and an Infinity object.
lhs | The left-hand side built-in data value. |
rhs | The right-hand side Infinity object. |
This operator works only for built-in data types. The attempt to compare user-defined class types will result in a compile time error.
|
inline |
Greater-than comparison between a NegativeEpsilon object and a floating point value.
rhs | The right-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Greater-than comparison between a NegativeAccuracy object and a floating point value.
rhs | The right-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Greater-than comparison between a floating point value and a NegativeEpsilon object.
lhs | The left-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Greater-than comparison between a floating point value and a NegativeAccuracy object.
lhs | The left-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
|
inline |
|
inline |
Greater-than comparison between an Epsilon object and a floating point value.
rhs | The right-hand side floating point value. |
This operator works only for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Greater-than comparison between an Accuracy object and a floating point value.
rhs | The right-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Greater-than comparison between a floating point value and an Epsilon object.
lhs | The left-hand side floating point value. |
This operator works only for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Greater-than comparison between a floating point value and an Accuracy object.
lhs | The left-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
|
inline |
|
inline |
Greater-or-equal-than comparison between an Epsilon object and a floating point value.
rhs | The right-hand side floating point value. |
This operator works only for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Greater-or-equal-than comparison between an Accuracy object and a floating point value.
rhs | The right-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Less-or-equal-than comparison between a floating point value and an Epsilon object.
lhs | The left-hand side floating point value. |
This operator works only for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Less-or-equal-than comparison between a floating point value and an Accuracy object.
lhs | The left-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
decltype(auto) blaze::pow | ( | const Proxy< PT, RT > & | proxy, |
const ET & | exp | ||
) |
Computing the exponential value of the represented element.
proxy | The given proxy instance. |
exp | The exponent. |
This function computes the exponential value of the element represented by the proxy. In case the proxy represents a vector- or matrix-like data structure the function returns an expression representing the exponential value of the elements of the vector/matrix.
|
inline |
Computing the square value of the represented element.
proxy | The given proxy instance. |
This function squares the element represented by the proxy. In case the proxy represents a vector- or matrix-like data structure the function returns an expression representing the squared value of the elements of the vector/matrix.
|
inline |
Computing the square value of the represented element.
proxy | The given proxy instance. |
This function squares the element represented by the proxy. In case the proxy represents a vector- or matrix-like data structure the function returns an expression representing the squared value of the elements of the vector/matrix.
|
inline |
Computing the cube value of the represented element.
proxy | The given proxy instance. |
This function cubes the element represented by the proxy. In case the proxy represents a vector- or matrix-like data structure the function returns an expression representing the cubed value of the elements of the vector/matrix.
|
inline |
Computing the cube value of the represented element.
proxy | The given proxy instance. |
This function cubes the element represented by the proxy. In case the proxy represents a vector- or matrix-like data structure the function returns an expression representing the cubed value of the elements of the vector/matrix.
|
inline |
Computing the quadruple value of the represented element.
proxy | The given proxy instance. |
This function quadruples the element represented by the proxy. In case the proxy represents a vector- or matrix-like data structure the function returns an expression representing the quadrupled value of the elements of the vector/matrix.
|
inline |
Computing the quadruple value of the represented element.
proxy | The given proxy instance. |
This function quadruples the element represented by the proxy. In case the proxy represents a vector- or matrix-like data structure the function returns an expression representing the quadrupled value of the elements of the vector/matrix.
decltype(auto) blaze::real | ( | const Proxy< PT, RT > & | proxy | ) |
Computing the real part of the represented element.
proxy | The given proxy instance. |
This function returns the real part of the element represented by the proxy. In case the proxy represents a vector- or matrix-like data structure the function returns an expression representing the real part of each each element of the vector/matrix.
BLAZE_ALWAYS_INLINE void blaze::reset | ( | const DenseVectorProxy< PT, VT > & | proxy | ) |
Resetting the represented vector to the default initial values.
proxy | The given access proxy. |
This function resets all elements of the vector to the default initial values.
BLAZE_ALWAYS_INLINE void blaze::reset | ( | const SparseVectorProxy< PT, VT > & | proxy | ) |
Resetting the represented element to the default initial values.
proxy | The given access proxy. |
This function resets all elements of the vector to the default initial values.
BLAZE_ALWAYS_INLINE void blaze::reset | ( | const DenseMatrixProxy< PT, MT > & | proxy | ) |
Resetting the represented element to the default initial values.
proxy | The given access proxy. |
This function resets all elements of the matrix to the default initial values.
BLAZE_ALWAYS_INLINE void blaze::reset | ( | const DenseMatrixProxy< PT, MT > & | proxy, |
size_t | i | ||
) |
Reset the specified row/column of the represented matrix.
proxy | The given access proxy. |
i | The index of the row/column to be resetted. |
This function resets all elements in the specified row/column of the given matrix to their default value. In case the given matrix is a rowMajor matrix the function resets the values in row i, if it is a columnMajor matrix the function resets the values in column i. Note that the capacity of the row/column remains unchanged.
BLAZE_ALWAYS_INLINE void blaze::reset | ( | const SparseMatrixProxy< PT, MT > & | proxy | ) |
Resetting the represented element to the default initial values.
proxy | The given access proxy. |
This function resets all elements of the matrix to the default initial values.
BLAZE_ALWAYS_INLINE void blaze::reset | ( | const SparseMatrixProxy< PT, MT > & | proxy, |
size_t | i | ||
) |
Reset the specified row/column of the represented matrix.
proxy | The given access proxy. |
i | The index of the row/column to be resetted. |
This function resets all elements in the specified row/column of the given matrix to their default value. In case the given matrix is a rowMajor matrix the function resets the values in row i, if it is a columnMajor matrix the function resets the values in column i. Note that the capacity of the row/column remains unchanged.
BLAZE_ALWAYS_INLINE void blaze::resize | ( | const DenseVectorProxy< PT, VT > & | proxy, |
size_t | n, | ||
bool | preserve | ||
) |
Changing the size of the represented vector.
proxy | The given access proxy. |
n | The new size of the vector. |
preserve | true if the old values of the vector should be preserved, false if not. |
std::invalid_argument | Vector cannot be resized. |
This function resizes the represented vector to the specified size. Note that in contrast to the resize()
member function, which is only available on resizable vector types, this function can be used on both resizable and non-resizable vectors. In case the type VT of the represented vector is resizable (i.e. provides a resize()
function), the type-specific resize()
member function is called. Depending on the type VT, this may result in the allocation of new dynamic memory and the invalidation of existing views (subvectors, ...). In case VT is non-resizable (i.e. does not provide a resize()
function) and if the specified size is not identical to the current size of the vector, a std::invalid_argument exception is thrown.
BLAZE_ALWAYS_INLINE void blaze::resize | ( | const SparseVectorProxy< PT, VT > & | proxy, |
size_t | n, | ||
bool | preserve | ||
) |
Changing the size of the represented vector.
proxy | The given access proxy. |
n | The new size of the vector. |
preserve | true if the old values of the vector should be preserved, false if not. |
This function resizes the represented vector to the specified size.
BLAZE_ALWAYS_INLINE void blaze::resize | ( | const DenseMatrixProxy< PT, MT > & | proxy, |
size_t | m, | ||
size_t | n, | ||
bool | preserve | ||
) |
Changing the size of the represented matrix.
proxy | The given access proxy. |
m | The new number of rows of the matrix. |
n | The new number of columns of the matrix. |
preserve | true if the old values of the matrix should be preserved, false if not. |
std::invalid_argument | Invalid resize arguments for square matrix. |
std::invalid_argument | Matrix cannot be resized. |
This function resizes the represented matrix to the specified dimensions. In contrast to the resize()
member function, which is only available on resizable matrix types, this function can be used on both resizable and non-resizable matrices. In case the given matrix of type MT is resizable (i.e. provides a resize
function) the type-specific resize()
member function is called. Depending on the type MT, this may result in the allocation of new dynamic memory and the invalidation of existing views (submatrices, rows, columns, ...). Note that in case the matrix is a compile time square matrix (as for instance the blaze::SymmetricMatrix adaptor, ...) the specified number of rows must be identical to the number of columns. Otherwise a std::invalid_argument exception is thrown. If the matrix type MT is non-resizable (i.e. does not provide a resize()
function) and if the specified number of rows and columns is not identical to the current number of rows and columns of the matrix, a std::invalid_argument exception is thrown.
BLAZE_ALWAYS_INLINE void blaze::resize | ( | const SparseMatrixProxy< PT, MT > & | proxy, |
size_t | m, | ||
size_t | n, | ||
bool | preserve | ||
) |
Changing the size of the represented matrix.
proxy | The given access proxy. |
m | The new number of rows of the matrix. |
n | The new number of columns of the matrix. |
preserve | true if the old values of the matrix should be preserved, false if not. |
std::invalid_argument | Invalid resize arguments for square matrix. |
This function resizes the represented matrix to the specified dimensions. Note that in case the matrix is a compile time square matrix (as for instance the blaze::SymmetricMatrix adaptor, ...) the specified number of rows must be identical to the number of columns. Otherwise a std::invalid_argument exception is thrown.
decltype(auto) blaze::round | ( | const Proxy< PT, RT > & | proxy | ) |
Computes the nearest integral value to the represented element.
proxy | The given proxy instance. |
This function computes the nearest integral value to the element represented by the proxy. In case the proxy represents a vector- or matrix-like data structure the function returns an expression representing the operation.
BLAZE_ALWAYS_INLINE size_t blaze::rows | ( | const DenseMatrixProxy< PT, MT > & | proxy | ) |
Returns the current number of rows of the represented matrix.
proxy | The given access proxy. |
BLAZE_ALWAYS_INLINE size_t blaze::rows | ( | const SparseMatrixProxy< PT, MT > & | proxy | ) |
Returns the current number of rows of the represented matrix.
proxy | The given access proxy. |
decltype(auto) blaze::sign | ( | const Proxy< PT, RT > & | proxy | ) |
Evaluating the sign of the represented element.
proxy | The given proxy instance. |
This function evaluates the sign of the element represented by the proxy. In case the proxy represents a vector- or matrix-like data structure the function returns an expression representing the operation.
decltype(auto) blaze::sin | ( | const Proxy< PT, RT > & | proxy | ) |
Computing the sine of the represented element.
proxy | The given proxy instance. |
This function computes the sine of the element represented by the proxy. In case the proxy represents a vector- or matrix-like data structure the function returns an expression representing the sines of the elements of the vector/matrix.
decltype(auto) blaze::sinh | ( | const Proxy< PT, RT > & | proxy | ) |
Computing the hyperbolic sine of the represented element.
proxy | The given proxy instance. |
This function computes the hyperbolic sine of the element represented by the proxy. In case the proxy represents a vector- or matrix-like data structure the function returns an expression representing the hyperbolic sines of the elements of the vector/matrix.
BLAZE_ALWAYS_INLINE size_t blaze::size | ( | const DenseVectorProxy< PT, VT > & | proxy | ) |
Returns the current size/dimension of the represented vector.
proxy | The given access proxy. |
BLAZE_ALWAYS_INLINE size_t blaze::size | ( | const SparseVectorProxy< PT, VT > & | proxy | ) |
Returns the current size/dimension of the represented vector.
proxy | The given access proxy. |
decltype(auto) blaze::sqrt | ( | const Proxy< PT, RT > & | proxy | ) |
Computing the square root of the represented element.
proxy | The given proxy instance. |
This function computes the square root of the element represented by the proxy. In case the proxy represents a vector- or matrix-like data structure the function returns an expression representing the square roots of the elements of the vector/matrix.
decltype(auto) blaze::tan | ( | const Proxy< PT, RT > & | proxy | ) |
Computing the tangent of the represented element.
proxy | The given proxy instance. |
This function computes the tangent of the element represented by the proxy. In case the proxy represents a vector- or matrix-like data structure the function returns an expression representing the tangents of the elements of the vector/matrix.
decltype(auto) blaze::tanh | ( | const Proxy< PT, RT > & | proxy | ) |
Computing the hyperbolic tangent of the represented element.
proxy | The given proxy instance. |
This function computes the hyperbolic tangent of the element represented by the proxy. In case the proxy represents a vector- or matrix-like data structure the function returns an expression representing the hyperbolic tangents of the elements of the vector/matrix.
decltype(auto) blaze::trans | ( | const Proxy< PT, RT > & | proxy | ) |
Computing the transpose of the represented element.
proxy | The given proxy instance. |
This function returns an expression representing the transpose of the element represented by the proxy.
|
inline |
In-place transpose of the represented matrix element.
proxy | The given proxy instance. |
std::invalid_argument | Invalid access to restricted element. |
std::logic_error | Matrix cannot be transposed. |
This function transposes the represented matrix in-place. The transpose operation fails if ...
In all failure cases a std::logic_error exception is thrown. Additionally, in case the represented matrix cannot be modified, a std::invalid_argument exception is thrown.
decltype(auto) blaze::trunc | ( | const Proxy< PT, RT > & | proxy | ) |
Computes the nearest integral value that is not greater than the represented element.
proxy | The given proxy instance. |
This function computes the nearest integral value that is not greater than the element represented by the proxy. In case the proxy represents a vector- or matrix-like data structure the function returns an expression representing the operation.
constexpr Checked blaze::checked |
Global Checked instance.The blaze::checked instance is an optional token for the creation of views. It can be used used to enforce runtime checks during the creation of a view (subvectors, submatrices, rows, columns, bands, ...). The following example demonstrates the setup of a checked subvector:
constexpr 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 column vector of size 7:
constexpr Unchecked blaze::unchecked |
Global Unchecked instance.The blaze::unchecked instance is an optional token for the creation of views. It can be used to skip all runtime checks during the creation of a view (subvectors, submatrices, rows, columns, bands, ...). The following example demonstrates the setup of an unchecked subvector:
constexpr 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 column vector of size 7: