![]() |
Blaze
3.6
|
Namespace of the Blaze C++ math library. More...
Namespaces | |
threadpool | |
Namespace for the threadpool module. | |
timing | |
Namespace for the time measurement module. | |
Classes | |
struct | Abs |
Generic wrapper for the abs() function. More... | |
class | 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... | |
struct | Acos |
Generic wrapper for the acos() function. More... | |
struct | Acosh |
Generic wrapper for the acosh() function. More... | |
struct | Add |
Generic wrapper for the addition operator. More... | |
struct | AddAssign |
Generic wrapper for addition assignment. More... | |
struct | AddConst |
Addition of a top level 'const' qualifier.The AddConst type trait adds a top level 'const' qualifier to the given type T. More... | |
struct | AddCV |
Addition of a top level 'const' and 'volatile' qualifier.The AddCV type trait adds both a top level 'const' and 'volatile' qualifier to the given type T. More... | |
struct | AddExpr |
Base class for all addition expression templates.The AddExpr class serves as a tag for all expression templates that implement mathematical additions. All classes, that represent a mathematical addition (vector additions and matrix additions) and that are used within the expression template environment of the Blaze library have to derive 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 | AddPointer |
Addition of a top level pointer.The AddPointer type trait adds a top level pointer to the given type T. It has the same effect as blaze::RemovePointer<T>::Type* . More... | |
struct | AddReference |
Addition of a top level reference.In case the given type T is not a reference type, the AddReference type trait adds a top level reference to the given type T. Else the resulting type Type is T. More... | |
struct | AddTrait |
Base template for the AddTrait class. More... | |
struct | AddVolatile |
Addition of a top level 'volatile' qualifier.The AddVolatile type trait adds a top level 'volatile' qualifier to the given type T. More... | |
class | AlignedAllocator |
Allocator for type-specific aligned memory.The AlignedAllocator class template represents an implementation of the allocator concept of the standard library for the allocation of type-specific, aligned, uninitialized memory. The allocator performs its allocation via the blaze::allocate() and blaze::deallocate() functions to guarantee properly aligned memory based on the alignment restrictions of the specified type Type. For instance, in case the given type is a fundamental, built-in data type and in case SSE vectorization is possible, the returned memory is guaranteed to be at least 16-byte aligned. In case AVX is active, the memory is even guaranteed to be at least 32-byte aligned. More... | |
class | AlignedArray |
Implementation of a static array with a fixed alignment.The AlignedArray class template represents a static array with a guaranteed, fixed alignment. The type of the array elements, the number of elements and the alignment of the array can be specified via the three template parameters: More... | |
struct | AlignmentOf |
Evaluation of the required alignment of the given data type.The AlignmentOf type trait template evaluates the required alignment for the given data type. For instance, for fundamental data types that can be vectorized via SSE or AVX instructions, the proper alignment is 16 or 32 bytes, respectively. For all other data types, a multiple of the alignment chosen by the compiler is returned. The evaluated alignment can be queried via the nested value member. More... | |
struct | All |
Compile time type check.This type trait determines whether the given type trait TypeTrait evaluates to true for all given types Ts. If the expression. More... | |
struct | AlwaysFalse |
Type dependent compile time false.This type trait represents a type dependent compile time false. For all possible types, the value member constant is set to false, the nested type definition Type is FalseType, and the class derives from FalseType. More... | |
struct | AlwaysTrue |
Type dependent compile time true.This type trait represents a type dependent compile time true. For all possible types, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. More... | |
struct | And |
Generic wrapper for the logical AND operator. More... | |
struct | AndAssign |
Generic wrapper for bitwise AND assignment. More... | |
struct | Any |
Compile time type check.This type trait determines whether the given type trait TypeTrait evaluates to true for at least one of the given types Ts. If the expression. More... | |
struct | Append |
Appending a type to a type list.The Append class can be used to append the data type T to a type list TL. In order to append a data type, the Append class has to be instantiated for a particular type list and another type. The following example gives an impression of the use of the Append class: More... | |
class | Archive |
Binary archive for the portable serialization of data.The Archive class implements the functionality to create platform independent, portable, representations of arbitrary C++ data structures. The resulting binary data structures can be used to reconstitute the data structures in a different context, on another platform, etc. More... | |
struct | ArrayDelete |
Array-delete policy class.The ArrayDelete policy functor class applies an array delete operation to the given argument. Note that the array delete operation is NOT permitted for inclomplete types (i.e. declared but undefined data types). The attempt to apply an ArrayDelete functor to a pointer to an array of objects of incomplete type results in a compile time error! More... | |
struct | Asin |
Generic wrapper for the asin() function. More... | |
struct | Asinh |
Generic wrapper for the asinh() function. More... | |
struct | Assign |
Generic wrapper for plain assignment. More... | |
struct | Atan |
Generic wrapper for the atan() function. More... | |
struct | Atan2 |
Generic wrapper for the atan2() function. More... | |
struct | Atanh |
Generic wrapper for the atanh() function. More... | |
class | BandData |
Auxiliary class template for the data members of the Band class.The auxiliary BandData class template represents an abstraction of the data members of the Band class template. The necessary set of data member is selected depending on the number of compile time band arguments. More... | |
struct | BandTrait |
Base template for the BandTrait class. More... | |
struct | BinaryMapExpr |
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 | Bind1st |
Generic wrapper for a binary operation with fixed 1st argument. More... | |
struct | Bind2nd |
Generic wrapper for a binary operation with fixed 2nd argument. More... | |
struct | Bitand |
Generic wrapper for the bitwise AND ('&') operator. More... | |
struct | Bitor |
Generic wrapper for the bitwise OR ('|') operator. More... | |
struct | Bitxor |
Generic wrapper for the bitwise XOR ('^') operator. More... | |
struct | Bools |
Auxiliary tool for unwrapping a pack of variadic boolean values.The Bools class template represents an auxiliary tool for unwrapping a pack of variadic boolean values. More... | |
struct | Cbrt |
Generic wrapper for the cbrt() function. More... | |
struct | Ceil |
Generic wrapper for the ceil() function. More... | |
struct | Check |
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... | |
struct | Clamp |
Generic wrapper for the clamp() function. More... | |
struct | Clear |
Generic wrapper for the clear() function. More... | |
class | ColumnData |
Auxiliary class template for the data members of the Column class.The auxiliary ColumnData class template represents an abstraction of the data members of the Column class template. The necessary set of data members is selected depending on the number of compile time column arguments. More... | |
struct | ColumnsTrait |
Base template for the ColumnsTrait class. More... | |
struct | ColumnTrait |
Base template for the ColumnTrait class. More... | |
struct | CommonType |
Deduction of a type common to several types.The CommonType type trait deduces the result type of a mixed-mode arithmetic expression between all types T..., that is the type all T... can be implicitly converted to. Note that cv and reference qualifiers are generally ignored. More... | |
class | complex |
Complex data type of the Blaze library. More... | |
class | ComplexProxy |
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 | CompressedMatrix |
Efficient implementation of a ![]() ![]() | |
class | CompressedVector |
Efficient implementation of an arbitrary sized sparse vector.The CompressedVector class is the representation of an arbitrarily sized sparse vector, which stores only non-zero elements of arbitrary type. The type of the elements and the transpose flag of the vector can be specified via the two template parameters: More... | |
struct | 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 | Conj |
Generic wrapper for the conj() function. More... | |
struct | Contains |
Searching a type list.The Contains class can be used to search the type list for a particular type Type. In contrast to the IndexOf class, the Contains class does not evaluate the index of the type but only checks whether or not the type is contained in the type list. Additionally, in contrast to the ContainsRelated class, the Contains class strictly searches for the given type Type and not for a related data type. In case the type is contained in the type list, the value member enumeration is set to true, else it is set to false. In order to check whether a type is part of a type list, the Contains class has to be instantiated for a particular type list and another type. The following example gives an impression of the use of the Contains class: More... | |
struct | ContainsRelated |
Searching a type list.The ContainsRelated class can be used to search the type list for a type related to Type. In contrast to the Contains class, the ContainsRelated class only searches for a type the given data type Type can be converted to. In case a related type is found in the type list, the value member enumeration is set to true, else it is set to false. In order to check whether a related type is contained in the type list, the ContainsRelated class has to be instantiated for a particular type list and another type. The following example gives an impression of the use of the ContainsRelated class: More... | |
struct | Cos |
Generic wrapper for the cos() function. More... | |
struct | Cosh |
Generic wrapper for the cosh() function. More... | |
struct | CrossExpr |
Base class for all cross product expression templates.The CrossExpr class serves as a tag for all expression templates that implement mathematical cross products. All classes, that represent a mathematical cross product and that are used within the expression template environment of the Blaze library have to derive 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 | CrossTrait |
Base template for the CrossTrait class. More... | |
struct | CTrans |
Generic wrapper for the ctrans() function. More... | |
class | CustomMatrix |
Efficient implementation of a customizable matrix.The CustomMatrix class template provides the functionality to represent an external array of elements of arbitrary type and a fixed size as a native Blaze dense matrix data structure. Thus in contrast to all other dense matrix types a custom matrix does not perform any kind of memory allocation by itself, but it is provided with an existing array of element during construction. A custom matrix can therefore be considered an alias to the existing array. More... | |
class | CustomVector |
Efficient implementation of a customizable vector. More... | |
struct | Deallocate |
Deallocate policy class.The Deallocate deletion policy is the according deletion policy for arrays allocated via the blaze::allocate function. It uses deallocate to free the resource. Note that the delete operation is NOT permitted for inclomplete types (i.e. declared but undefined data types). The attempt to apply a PtrDelete functor to a pointer to an object of incomplete type results in a compile time error! More... | |
struct | Decay |
Applies the type conversions for by-value function arguments.This type trait applies the type conversions that are used for by-value function arguments. This conversions include lvalue-to-rvalue, array-to-pointer, and function-to-pointer implicit conversions to the type T , and the removal of top level cv-qualifiers. More... | |
struct | Declaration |
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 | DeclDiag |
Generic wrapper for the decldiag() function. More... | |
struct | DeclDiagExpr |
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 | DeclDiagTrait |
Base template for the DeclDiagTrait class. More... | |
struct | DeclExpr |
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 | DeclHerm |
Generic wrapper for the declherm() function. More... | |
struct | DeclHermExpr |
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 | DeclHermTrait |
Base template for the DeclHermTrait class. More... | |
struct | DeclId |
Generic wrapper for the declid() function. More... | |
struct | DeclIdTrait |
Base template for the DeclIdTrait class. More... | |
struct | DeclLow |
Generic wrapper for the decllow() function. More... | |
struct | DeclLowExpr |
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 | DeclLowTrait |
Base template for the DeclLowTrait class. More... | |
struct | DeclSym |
Generic wrapper for the declsym() function. More... | |
struct | DeclSymExpr |
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 | DeclSymTrait |
Base template for the DeclSymTrait class. More... | |
struct | DeclUpp |
Generic wrapper for the declupp() function. More... | |
struct | DeclUppExpr |
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 | DeclUppTrait |
Base template for the DeclUppTrait class. More... | |
struct | DeclZero |
Generic wrapper for the declzero() function. More... | |
struct | DeclZeroTrait |
Base template for the DeclZeroTrait class. More... | |
struct | DefaultDelete |
Default C++ deletion policy class.The DefaultDelete deletion policy is the standard delete for resources allocated via the new operator. It uses delete or array delete (depending on the template argument) to free the resource: More... | |
class | DefaultProxy |
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 | DenseIterator |
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... | |
struct | DenseMatrix |
Base class for dense matrices.The DenseMatrix class is a base class for all dense matrix classes. It provides an abstraction from the actual type of the dense matrix, but enables a conversion back to this type via the Matrix base class. More... | |
class | DenseMatrixProxy |
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... | |
struct | DenseVector |
Base class for N-dimensional dense vectors.The DenseVector class is a base class for all arbitrarily sized (N-dimensional) dense vectors. It provides an abstraction from the actual type of the dense vector, but enables a conversion back to this type via the Vector base class. More... | |
class | DenseVectorProxy |
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 | Dependency |
Lifetime dependency on a singleton object.The Dependency template class represents a lifetime dependency on a singleton object based on the Blaze Singleton functionality. By use of the Dependency template, any class can by either public or non-public inheritance or composition define a single or multiple lifetime dependencies on one or several singletons, which guarantees that the singleton instance(s) will be destroyed after the dependent object. The following example demonstrates both the inheritance as well as the composition approach: More... | |
struct | DerestrictTrait |
Evaluation of the return type of the derestrict function.Via this type trait it is possible to evaluate the resulting return type of the derestrict function. Given the non-const vector or matrix type T, the nested type Type corresponds to the resulting return type. In case T is neither a dense or sparse vector or matrix type, the resulting Type is set to INVALID_TYPE. More... | |
class | DiagonalMatrix |
Matrix adapter for diagonal ![]() | |
class | DiagonalProxy |
Access proxy for diagonal matrices.The DiagonalProxy provides controlled access to the elements of a non-const diagonal matrix. It guarantees that the diagonal matrix invariant is not violated, i.e. that elements in the lower and upper part of the matrix remain default values. The following example illustrates this by means of a ![]() | |
struct | DisableIf |
Substitution Failure Is Not An Error (SFINAE) class.The DisableIf class template is an auxiliary tool for an intentional application of the Substitution Failure Is Not An Error (SFINAE) principle. It allows a function template or a class template specialization to include or exclude itself from a set of matching functions or specializations based on properties of its template arguments. For instance, it can be used to restrict the selection of a function template to specific data types. The following example illustrates this in more detail. More... | |
struct | Div |
Generic wrapper for the division operator. More... | |
struct | DivAssign |
Generic wrapper for division assignment. More... | |
struct | DivExpr |
Base class for all division expression templates.The DivExpr class serves as a tag for all expression templates that implement mathematical divisions. All classes, that represent a mathematical division (vector/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 | DivTrait |
Base template for the DivTrait class. More... | |
class | DMatDeclDiagExpr |
Expression object for the explicit diagonal declaration of dense matrices.The DMatDeclDiagExpr class represents the compile time expression for the explicit diagonal declaration of a dense matrix. More... | |
class | DMatDeclHermExpr |
Expression object for the explicit Hermitian declaration of dense matrices.The DMatDeclHermExpr class represents the compile time expression for the explicit Hermitian declaration of a dense matrix. More... | |
class | DMatDeclLowExpr |
Expression object for the explicit lower declaration of dense matrices.The DMatDeclLowExpr class represents the compile time expression for the explicit lower declaration of a dense matrix. More... | |
class | DMatDeclSymExpr |
Expression object for the explicit symmetry declaration of dense matrices.The DMatDeclSymExpr class represents the compile time expression for the explicit symmetry declaration of a dense matrix. More... | |
class | DMatDeclUppExpr |
Expression object for the explicit upper declaration of dense matrices.The DMatDeclUppExpr class represents the compile time expression for the explicit upper declaration of a dense matrix. More... | |
class | DMatDMatAddExpr |
Expression object for dense matrix-dense matrix additions.The DMatDMatAddExpr class represents the compile time expression for additions between dense matrices with identical storage order. More... | |
class | DMatDMatKronExpr |
Expression object for dense matrix-dense matrix Kronecker products.The DMatDMatKronExpr class represents the compile time expression for Kronecker products between dense matrices of any storage order. More... | |
class | DMatDMatMapExpr |
Expression object for the dense matrix-dense matrix map() function.The DMatDMatMapExpr class represents the compile time expression for the pairwise evaluation of a binary custom operation on the elements of two dense matrices with identical storage order via the map() function. More... | |
class | DMatDMatMultExpr |
Expression object for dense matrix-dense matrix multiplications.The DMatDMatMultExpr class represents the compile time expression for multiplications between row-major dense matrices. More... | |
class | DMatDMatSchurExpr |
Expression object for dense matrix-dense matrix Schur products.The DMatDMatSchurExpr class represents the compile time expression for Schur products between dense matrices with identical storage order. More... | |
class | DMatDMatSubExpr |
Expression object for dense matrix-dense matrix subtractions.The DMatDMatSubExpr class represents the compile time expression for subtractions between dense matrices with identical storage order. More... | |
class | DMatDVecMultExpr |
Expression object for dense matrix-dense vector multiplications.The DMatDVecMultExpr class represents the compile time expression for multiplications between row-major dense matrices and dense vectors. More... | |
class | DMatEvalExpr |
Expression object for the forced evaluation of dense matrices.The DMatEvalExpr class represents the compile time expression for the forced evaluation of a dense matrix. More... | |
class | DMatExpExpr |
class | DMatInvExpr |
Expression object for dense matrix inversions.The DMatInvExpr class represents the compile time expression for inversions of dense matrices. More... | |
class | DMatMapExpr |
Expression object for the dense matrix map() function.The DMatMapExpr class represents the compile time expression for the evaluation of a custom operation on each element of a dense matrix via the map() function. More... | |
class | DMatReduceExpr |
Base template for row-major dense matrix partial reduction operations.The DMatReduceExpr class represents the compile time expression for partial reduction operations of row-major dense matrices. More... | |
class | DMatReduceExpr< MT, OP, columnwise > |
Expression object for column-wise row-major dense matrix reduction operations.This specialization of the DMatReduceExpr class template represents the compile time expression for column-wise reduction operations of row-major dense matrices. More... | |
class | DMatReduceExpr< MT, OP, rowwise > |
Expression object for row-wise row-major dense matrix reduction operations.This specialization of the DMatReduceExpr class template represents the compile time expression for row-wise reduction operations of row-major dense matrices. More... | |
class | DMatScalarDivExpr |
Expression object for divisions of a dense matrix by a scalar.The DMatScalarDivExpr class represents the compile time expression for divisions of dense matrices and by scalar values. More... | |
class | DMatScalarMultExpr |
Expression object for dense matrix-scalar multiplications.The DMatScalarMultExpr class represents the compile time expression for multiplications between a dense matrix and a scalar value. More... | |
class | DMatSerialExpr |
Expression object for the forced serial evaluation of dense matrices.The DMatSerialExpr class represents the compile time expression for the forced serial evaluation of a dense matrix. More... | |
class | DMatSMatAddExpr |
Expression object for dense matrix-sparse matrix additions.The DMatSMatAddExpr class represents the compile time expression for additions between a dense matrix and a sparse matrix with identical storage order. More... | |
class | DMatSMatKronExpr |
Expression object for dense matrix-sparse matrix Kronecker product.The DMatSMatKronExpr class represents the compile time expression for Kronecker products between a dense matrix and a sparse matrix. More... | |
class | DMatSMatMultExpr |
Expression object for dense matrix-sparse matrix multiplications.The DMatSMatMultExpr class represents the compile time expression for multiplications between a row-major dense matrix and a row-major sparse matrix. More... | |
class | DMatSMatSchurExpr |
Expression object for dense matrix-sparse matrix Schur product.The DMatSMatSchurExpr class represents the compile time expression for Schur products between a dense matrix and a row-major sparse matrix. More... | |
class | DMatSMatSubExpr |
Expression object for dense matrix-sparse matrix subtractions.The DMatSMatSubExpr class represents the compile time expression for subtractions between a dense matrix and a sparse matrix with identical storage order. More... | |
class | DMatSVecMultExpr |
Expression object for dense matrix-sparse vector multiplications.The DMatSVecMultExpr class represents the compile time expression for multiplications between row-major dense matrices and sparse vectors. More... | |
class | DMatTDMatAddExpr |
Expression object for dense matrix-transpose dense matrix additions.The DMatTDMatAddExpr class represents the compile time expression for additions between a row-major dense matrix and column-major dense matrix. More... | |
class | DMatTDMatMapExpr |
Expression object for the dense matrix/tranpose dense matrix map() function.The DMatTDMatMapExpr class represents the compile time expression for the pairwise evaluation of a binary custom operation on the elements of a row-major dense matrix and a column-major matrix via the map() function. More... | |
class | DMatTDMatMultExpr |
Expression object for dense matrix-transpose dense matrix multiplications.The DMatTDMatMultExpr class represents the compile time expression for multiplications between a row-major dense matrix and a column-major dense matrix. More... | |
class | DMatTDMatSchurExpr |
Expression object for dense matrix-transpose dense matrix Schur product.The DMatTDMatSchurExpr class represents the compile time expression for Schur product between a row-major dense matrix and a column-major dense matrix. More... | |
class | DMatTDMatSubExpr |
Expression object for dense matrix-transpose dense matrix subtractions.The DMatTDMatSubExpr class represents the compile time expression for subtractions between a row-major dense matrix and a column-major dense matrix. More... | |
class | DMatTransExpr |
Expression object for dense matrix transpositions.The DMatTransExpr class represents the compile time expression for transpositions of dense matrices. More... | |
class | DMatTransposer |
Expression object for the transposition of a dense matrix.The DMatTransposer class is a wrapper object for the temporary transposition of a dense matrix. More... | |
class | DMatTSMatAddExpr |
Expression object for dense matrix-sparse matrix additions.The DMatTSMatAddExpr class represents the compile time expression for additions between a row-major dense matrix and a column-major sparse matrix. More... | |
class | DMatTSMatMultExpr |
Expression object for dense matrix-transpose sparse matrix multiplications.The DMatTSMatMultExpr class represents the compile time expression for multiplications between a row-major dense matrix and a column-major sparse matrix. More... | |
class | DMatTSMatSchurExpr |
Expression object for dense matrix-transpose sparse matrix Schur product.The DMatTSMatSchurExpr class represents the compile time expression for Schur products between a dense matrix and a column-major sparse matrix. More... | |
class | DMatTSMatSubExpr |
Expression object for dense matrix-transpose sparse matrix subtractions.The DMatTSMatSubExpr class represents the compile time expression for subtractions between a row-major dense matrix and a column-major sparse matrix. More... | |
class | DVecDVecAddExpr |
Expression object for dense vector-dense vector additions.The DVecDVecAddExpr class represents the compile time expression for additions between dense vectors. More... | |
class | DVecDVecCrossExpr |
Expression object for dense vector-dense vector cross products.The DVecDVecCrossExpr class represents the compile time expression for cross products between dense vectors. More... | |
class | DVecDVecDivExpr |
Expression object for dense vector-dense vector divisions.The DVecDVecDivExpr class represents the compile time expression for componentwise divisions between dense vectors. More... | |
class | DVecDVecKronExpr |
Expression object for dense vector-dense vector Kronecker product.The DVecDVecKronExpr class represents the compile time expression for Kronecker products between dense vectors. More... | |
class | DVecDVecMapExpr |
Expression object for the dense vector-dense vector map() function.The DVecDVecMapExpr class represents the compile time expression for the pairwise evaluation of a binary custom operation on the elements of two dense vectors via the map() function. More... | |
class | DVecDVecMultExpr |
Expression object for dense vector-dense vector multiplications.The DVecDVecMultExpr class represents the compile time expression for componentwise multiplications between dense vectors. More... | |
class | DVecDVecOuterExpr |
Expression object for outer products between two dense vectors.The DVecDVecOuterExpr class represents the compile time expression for outer products between dense vectors. More... | |
class | DVecDVecSubExpr |
Expression object for dense vector-dense vector subtractions.The DVecDVecSubExpr class represents the compile time expression for subtractions between dense vectors. More... | |
class | DVecEvalExpr |
Expression object for the forced evaluation of dense vectors.The DVecEvalExpr class represents the compile time expression for the forced evaluation of a dense vector. More... | |
class | DVecExpandExpr |
Expression object for dense vector expansion.The DVecExpandExpr class represents the compile time expression for expansions of dense vectors. More... | |
class | DVecMapExpr |
Expression object for the dense vector map() function.The DVecMapExpr class represents the compile time expression for the evaluation of a custom operation on each element of a dense vector via the map() function. More... | |
class | DVecScalarDivExpr |
Expression object for divisions of a dense vector by a scalar.The DVecScalarDivExpr class represents the compile time expression for divisions of dense vectors by scalar values. More... | |
class | DVecScalarMultExpr |
Expression object for dense vector-scalar multiplications.The DVecScalarMultExpr class represents the compile time expression for multiplications between a dense vector and a scalar value. More... | |
class | DVecSerialExpr |
Expression object for the forced serial evaluation of dense vectors.The DVecSerialExpr class represents the compile time expression for the forced serial evaluation of a dense vector. More... | |
class | DVecSVecAddExpr |
Expression object for dense vector-sparse vector additions.The DVecSVecAddExpr class represents the compile time expression for additions between a dense vector and a sparse vector. More... | |
class | DVecSVecCrossExpr |
Expression object for dense vector-sparse vector cross products.The DVecSVecCrossExpr class represents the compile time expression for cross products between a dense vector and a sparse vector. More... | |
class | DVecSVecKronExpr |
Expression object for dense vector-sparse vector Kronecker product.The DVecSVecKronExpr class represents the compile time expression for Kronecker products between a dense vector and a sparse vector. More... | |
class | DVecSVecMultExpr |
Expression object for dense vector-sparse vector multiplications.The DVecSVecMultExpr class represents the compile time expression for componentwise multiplications between a dense vector and a sparse vector. More... | |
class | DVecSVecOuterExpr |
Expression object for dense vector-sparse vector outer products.The DVecSVecOuterExpr class represents the compile time expression for dense vector-sparse vector outer products. More... | |
class | DVecSVecSubExpr |
Expression object for dense vector-sparse vector subtractions.The DVecSVecSubExpr class represents the compile time expression for subtractions between a dense vector and a sparse vector. More... | |
class | DVecTransExpr |
Expression object for dense vector transpositions.The DVecTransExpr class represents the compile time expression for transpositions of dense vectors. More... | |
class | DVecTransposer |
Expression object for the transposition of a dense vector.The DVecTransposer class is a wrapper object for the temporary transposition of a dense vector. More... | |
class | DynamicMatrix |
Efficient implementation of a dynamic ![]() ![]() | |
class | DynamicVector |
Efficient implementation of an arbitrary sized vector.The DynamicVector class template is the representation of an arbitrary sized vector with dynamically allocated elements of arbitrary type. The type of the elements and the transpose flag of the vector can be specified via the two template parameters: More... | |
struct | ElementsTrait |
Base template for the ElementsTrait class. More... | |
struct | EmptyType |
Empty data type for utility purposes. More... | |
struct | EnableIf |
Substitution Failure Is Not An Error (SFINAE) class.The EnableIf class template is an auxiliary tool for an intentional application of the Substitution Failure Is Not An Error (SFINAE) principle. It allows a function template or a class template specialization to include or exclude itself from a set of matching functions or specializations based on properties of its template arguments. For instance, it can be used to restrict the selection of a function template to specific data types. The following example illustrates this in more detail. More... | |
class | 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 | Erase |
Erasing the first occurrence of a type from a type list.The Erase class can be used to erase the first occurrence of data type T from a type list TL. In order to erase the first occurrence of a data type, the Erase class has to be instantiated for a particular type list and another type. The following example gives an impression of the use of the Erase class: More... | |
struct | EraseAll |
Erasing all occurrences of a type from a type list.The EraseAll class can be used to erase all occurrences of data type Type from a type list TList. In order to erase all occurrences of a data type, the EraseAll class has to be instantiated for a particular type list and another type. The following example gives an impression of the use of the EraseAll class: More... | |
struct | Erf |
Generic wrapper for the erf() function. More... | |
struct | Erfc |
Generic wrapper for the erfc() function. More... | |
struct | Eval |
Generic wrapper for the eval() function. More... | |
struct | EvalExpr |
Base class for all evaluation expression templates.The EvalExpr class serves as a tag for all expression templates that implement an evaluation operation. All classes, that represent an evaluation operation and that are used within the expression template environment of the Blaze library have to derive 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 | Exp |
Generic wrapper for the exp() function. More... | |
struct | Exp10 |
Generic wrapper for the exp10() function. More... | |
struct | Exp2 |
Generic wrapper for the exp2() function. More... | |
struct | ExpandExpr |
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 | ExpandExprData |
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 | ExpandTrait |
Base template for the ExpandTrait class. More... | |
struct | Expression |
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 | Extent |
Compile time check for the size of array bounds.Via this type trait it is possible to query at compile time for the size of a particular array extent. In case the given template argument is an array type with a rank greater than N, the value member constant is set to the number of elements of the N'th array dimension. In all other cases, and especially in case the N'th array dimension is incomplete, value is set to 0. More... | |
struct | Floor |
Generic wrapper for the floor() function. More... | |
class | FunctionTrace |
RAII object for function tracing.The FunctionTrace class is an auxiliary helper class for the tracing of function calls. It is implemented as a wrapper around std::cerr and is responsible for the atomicity of the output of trace information. More... | |
struct | Greater |
Generic wrapper for the greater-than relational operator. More... | |
struct | Has1Byte |
Compile time size check.This type trait offers the possibility to test whether a given type has a size of exactly one byte. If the type T has one byte, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | Has2Bytes |
Compile time size check.This type trait offers the possibility to test whether a given type has a size of exactly two bytes. If the type T has two bytes, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | Has4Bytes |
Compile time size check.This type trait offers the possibility to test whether a given type has a size of exactly four bytes. If the type T has four bytes, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | Has8Bytes |
Compile time size check.This type trait offers the possibility to test whether a given type has a size of exactly four bytes. If the type T has four bytes, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives fromTrueType. Otherwise value is set to false, Type is FalseType, and the classderives from FalseType. More... | |
struct | HasAbs |
Availability of the abs() operation for the given data types.This type trait provides the information whether the abs() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | HasAcos |
Availability of the acos() operation for the given data types.This type trait provides the information whether the acos() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | HasAcosh |
Availability of the acosh() operation for the given data types.This type trait provides the information whether the acosh() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | HasAdd |
Availability of an addition operator for the given data types.This type trait provides the information whether an addition operator (i.e. operator+) exists for the two given data types T1 and T2 (taking the cv-qualifiers into account). In case the operator is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | HasAsin |
Availability of the asin() operation for the given data types.This type trait provides the information whether the asin() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | HasAsinh |
Availability of the asinh() operation for the given data types.This type trait provides the information whether the asinh() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | HasAtan |
Availability of the atan() operation for the given data types.This type trait provides the information whether the atan() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | HasAtan2 |
Availability of the atan2() operation for the given data types.This type trait provides the information whether the atan2() operation exists for the two given data types T1 and T2 (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | HasAtanh |
Availability of the atanh() operation for the given data types.This type trait provides the information whether the atanh() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | HasCbrt |
Availability of the cbrt() operation for the given data types.This type trait provides the information whether the cbrt() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | HasCeil |
Availability of the ceil() operation for the given data types.This type trait provides the information whether the ceil() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | HasClamp |
Availability of the clamp() operation for the given data types.This type trait provides the information whether the clamp() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | HasConj |
Availability of the conj() operation for the given data types.This type trait provides the information whether the conj() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | HasConstDataAccess |
Compile time check for low-level access to constant data.This type trait tests whether the given data type provides a low-level access to constant data via a const 'data' member function. In case the according member function is provided, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. Examples: More... | |
struct | HasCos |
Availability of the cos() operation for the given data types.This type trait provides the information whether the cos() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | HasCosh |
Availability of the cosh() operation for the given data types.This type trait provides the information whether the cosh() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | HasCyclicDependency |
struct | HasDiv |
Availability of a division operator for the given data types.This type trait provides the information whether a division operator (i.e. operator/) exists for the two given data types T1 and T2 (taking the cv-qualifiers into account). In case the operator is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | HasErf |
Availability of the erf() operation for the given data types.This type trait provides the information whether the erf() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | HasErfc |
Availability of the erfc() operation for the given data types.This type trait provides the information whether the erfc() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | HasExp |
Availability of the exp() operation for the given data types.This type trait provides the information whether the exp() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | HasExp10 |
Availability of the exp10() operation for the given data types.This type trait provides the information whether the exp10() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | HasExp2 |
Availability of the exp2() operation for the given data types.This type trait provides the information whether the exp2() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | HasFloor |
Availability of the floor() operation for the given data types.This type trait provides the information whether the floor() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | HasHypot |
Availability of the hypot() operation for the given data types.This type trait provides the information whether the hypot() operation exists for the two given data types T1 and T2 (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | HasImag |
Availability of the imag() operation for the given data types.This type trait provides the information whether the imag() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | HasInvCbrt |
Availability of the invcbrt() operation for the given data types.This type trait provides the information whether the invcbrt() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | HasInvSqrt |
Availability of the invsqrt() operation for the given data types.This type trait provides the information whether the invsqrt() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | HasLog |
Availability of the log() operation for the given data types.This type trait provides the information whether the log() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | HasLog10 |
Availability of the log10() operation for the given data types.This type trait provides the information whether the log10() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | HasLog2 |
Availability of the log2() operation for the given data types.This type trait provides the information whether the log2() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | HasMax |
Availability of a max() operation for the given data types.This type trait provides the information whether a binary max() operation exists for the two given data types T1 and T2 (taking the cv-qualifiers into account). In case a binary max() operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | HasMin |
Availability of a min() operation for the given data types.This type trait provides the information whether a binary min() operation exists for the two given data types T1 and T2 (taking the cv-qualifiers into account). In case a binary min() operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | HasMult |
Availability of a multiplication operator for the given data types.This type trait provides the information whether a multiplication operator (i.e. operator*) exists for the two given data types T1 and T2 (taking the cv-qualifiers into account). In case the operator is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | HasMutableDataAccess |
Compile time check for low-level access to mutable data.This type trait tests whether the given data type provides a low-level access to mutable data via a non-const 'data' member function. In case the according member function is provided, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. Examples: More... | |
struct | HasPow |
Availability of the pow() operation for the given data types.This type trait provides the information whether the pow() operation exists for the two given data types T1 and T2 (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | HasReal |
Availability of the real() operation for the given data types.This type trait provides the information whether the real() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | HasRound |
Availability of the round() operation for the given data types.This type trait provides the information whether the round() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | HasSign |
Availability of the sign() operation for the given data types.This type trait provides the information whether the sign() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | HasSIMDAbs |
Availability of a SIMD absolute value operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD absolute value operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that AVX is available: More... | |
struct | HasSIMDAcos |
Availability of a SIMD inverse cosine operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD inverse cosine operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that the Intel SVML is available: More... | |
struct | HasSIMDAcosh |
Availability of a SIMD inverse hyperbolic cosine operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD inverse hyperbolic cosine operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that the Intel SVML is available: More... | |
struct | HasSIMDAdd |
Availability of a SIMD addition for the given data types.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...), and the used compiler, this type trait provides the information whether a SIMD addition operation exists for the two given data types T1 and T2 (ignoring the cv-qualifiers). In case the SIMD addition is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that AVX is available: More... | |
struct | HasSIMDAsin |
Availability of a SIMD inverse sine operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD inverse sine operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that the Intel SVML is available: More... | |
struct | HasSIMDAsinh |
Availability of a SIMD inverse hyperbolic sine operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD hyperbolic inverse sine operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that the Intel SVML is available: More... | |
struct | HasSIMDAtan |
Availability of a SIMD inverse tangent operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD inverse tangent operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that the Intel SVML is available: More... | |
struct | HasSIMDAtan2 |
Availability of a SIMD inverse tangent operation for the given data types.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD multi-valued inverse tangent operation exists for the given data types T1 and T2 (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that the Intel SVML is available: More... | |
struct | HasSIMDAtanh |
Availability of a SIMD inverse hyperbolic tangent operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD inverse hyperbolic tangent operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that the Intel SVML is available: More... | |
struct | HasSIMDBitand |
Availability of a SIMD bitwise AND ('&') for the given data types.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...), and the used compiler, this type trait provides the information whether a SIMD bitwise AND ('&') operation exists for the two given data types T1 and T2 (ignoring the cv-qualifiers). In case the SIMD bitwise AND is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that AVX2 is available: More... | |
struct | HasSIMDBitor |
Availability of a SIMD bitwise OR ('|') for the given data types.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...), and the used compiler, this type trait provides the information whether a SIMD bitwise OR ('|') operation exists for the two given data types T1 and T2 (ignoring the cv-qualifiers). In case the SIMD bitwise OR is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that AVX2 is available: More... | |
struct | HasSIMDBitxor |
Availability of a SIMD bitwise XOR ('^') for the given data types.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...), and the used compiler, this type trait provides the information whether a SIMD bitwise XOR ('^') operation exists for the two given data types T1 and T2 (ignoring the cv-qualifiers). In case the SIMD bitwise XOR is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that AVX2 is available: More... | |
struct | HasSIMDCbrt |
Availability of a SIMD cubic root operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD cubic root operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that the Intel SVML is available: More... | |
struct | HasSIMDCeil |
Availability of a SIMD ceil operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD ceil operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that AVX is available: More... | |
struct | HasSIMDConj |
Availability of a SIMD conjugate operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD conjugate operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that AVX is available: More... | |
struct | HasSIMDCos |
Availability of a SIMD cosine operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD cosine operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that the Intel SVML is available: More... | |
struct | HasSIMDCosh |
Availability of a SIMD hyperbolic cosine operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD hyperbolic cosine operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that the Intel SVML is available: More... | |
struct | HasSIMDDiv |
Availability of a SIMD division for the given data types.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD division operation exists for the two given data types T1 and T2 (ignoring the cv-qualifiers). In case the SIMD division is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that AVX is available: More... | |
struct | HasSIMDEqual |
Availability of a SIMD equality comparison for the given data types.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...), and the used compiler, this type trait provides the information whether a SIMD equality comparison exists for the two given data types T1 and T2 (ignoring the cv-qualifiers). In case the SIMD equality comparison is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that AVX is available: More... | |
struct | HasSIMDErf |
Availability of a SIMD error function (erf ) operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD error function (erf ) operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that the Intel SVML is available: More... | |
struct | HasSIMDErfc |
Availability of a SIMD complementary error function (erfc ) operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD complementary error function (erfc ) operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that the Intel SVML is available: More... | |
struct | HasSIMDExp |
Availability of a SIMD exp() operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD exp() operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that the Intel SVML is available: More... | |
struct | HasSIMDExp10 |
Availability of a SIMD exp10() operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD exp10() operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that the Intel SVML is available: More... | |
struct | HasSIMDExp2 |
Availability of a SIMD exp2() operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD exp2() operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that the Intel SVML is available: More... | |
struct | HasSIMDFloor |
Availability of a SIMD floor operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD floor operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that AVX is available: More... | |
struct | HasSIMDHypot |
Availability of a SIMD hypotenous operation for the given data types.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD hypotenous operation exists for the given data types T1 and T2 (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that the Intel SVML is available: More... | |
struct | HasSIMDInvCbrt |
Availability of a SIMD inverse cubic root operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD inverse cubic root operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that the Intel SVML is available: More... | |
struct | HasSIMDInvSqrt |
Availability of a SIMD inverse square root operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD inverse square root operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that the Intel SVML is available: More... | |
struct | HasSIMDLog |
Availability of a SIMD natural logarithm operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD natural logarithm operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that the Intel SVML is available: More... | |
struct | HasSIMDLog10 |
Availability of a SIMD common logarithm operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD common logarithm operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that the Intel SVML is available: More... | |
struct | HasSIMDLog2 |
Availability of a SIMD binary logarithm operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD binary logarithm operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that the Intel SVML is available: More... | |
struct | HasSIMDMax |
Availability of a SIMD max operation for the given data types.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...), and the used compiler, this type trait provides the information whether a SIMD max operation exists for the two given data types T1 and T2 (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that AVX is available: More... | |
struct | HasSIMDMin |
Availability of a SIMD min operation for the given data types.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...), and the used compiler, this type trait provides the information whether a SIMD min operation exists for the two given data types T1 and T2 (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that AVX is available: More... | |
struct | HasSIMDMult |
Availability of a SIMD multiplication for the given data types.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD multiplication operation exists for the two given data types T1 and T2 (ignoring the cv-qualifiers). In case the SIMD multiplication is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that AVX is available: More... | |
struct | HasSIMDPow |
Availability of a SIMD power operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD power operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that the Intel SVML is available: More... | |
struct | HasSIMDRound |
Availability of a SIMD round operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD round operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that AVX is available: More... | |
struct | HasSIMDShiftLI |
Availability of a SIMD uniform left-shift for the given data types.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...), and the used compiler, this type trait provides the information whether a SIMD uniform left-shift operation exists for the two given data types T1 and T2 (ignoring the cv-qualifiers). In case the SIMD uniform left-shift is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that AVX2 is available: More... | |
struct | HasSIMDShiftLV |
Availability of an SIMD elementwise left-shift for the given data types.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...), and the used compiler, this type trait provides the information whether an SIMD elementwise left-shift operation exists for the two given data types T1 and T2 (ignoring the cv-qualifiers). In case the SIMD elementwise left-shift is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that AVX2 is available: More... | |
struct | HasSIMDShiftRI |
Availability of a SIMD uniform right-shift for the given data types.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...), and the used compiler, this type trait provides the information whether a SIMD uniform right-shift operation exists for the two given data types T1 and T2 (ignoring the cv-qualifiers). In case the SIMD uniform right-shift is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that AVX2 is available: More... | |
struct | HasSIMDShiftRV |
Availability of a SIMD elementwise right-shift for the given data types.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...), and the used compiler, this type trait provides the information whether an SIMD elementwise right-shift operation exists for the two given data types T1 and T2 (ignoring the cv-qualifiers). In case the SIMD elementwise right-shift is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that AVX2 is available: More... | |
struct | HasSIMDSign |
Availability of a SIMD sign operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD sign operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that AVX is available: More... | |
struct | HasSIMDSin |
Availability of a SIMD sine operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD sine operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that the Intel SVML is available: More... | |
struct | HasSIMDSinh |
Availability of a SIMD hyperbolic sine operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD hyperbolic sine operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that the Intel SVML is available: More... | |
struct | HasSIMDSqrt |
Availability of a SIMD square root operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD square root operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that AVX is available: More... | |
struct | HasSIMDSub |
Availability of a SIMD subtraction for the given data types.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD subtraction operation exists for the two given data types T1 and T2 (ignoring the cv-qualifiers). In case the SIMD subtraction is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that AVX is available: More... | |
struct | HasSIMDTan |
Availability of a SIMD tangent operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD tangent operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that the Intel SVML is available: More... | |
struct | HasSIMDTanh |
Availability of a SIMD hyperbolic tangent operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD hyperbolic tangent operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that the Intel SVML is available: More... | |
struct | HasSIMDTrunc |
Availability of a SIMD trunc operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD trunc operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that the Intel SVML is available: More... | |
struct | HasSin |
Availability of the sin() operation for the given data types.This type trait provides the information whether the sin() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | HasSinh |
Availability of the sinh() operation for the given data types.This type trait provides the information whether the sinh() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | HasSize |
Compile time size check.This class offers the possibility to test the size of a type at compile time. If the type T is exactly S bytes large, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | HasSqrt |
Availability of the sqrt() operation for the given data types.This type trait provides the information whether the sqrt() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | HasSub |
Availability of a subtraction operator for the given data types.This type trait provides the information whether a subtraction operator (i.e. operator+) exists for the two given data types T1 and T2 (taking the cv-qualifiers into account). In case the operator is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | HasTan |
Availability of the tan() operation for the given data types.This type trait provides the information whether the tan() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | HasTanh |
Availability of the tanh() operation for the given data types.This type trait provides the information whether the tanh() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | HasTrunc |
Availability of the trunc() operation for the given data types.This type trait provides the information whether the trunc() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
class | HaveSameSize |
Compile time size check.This class offers the possibility to test the size of two types at compile time. If an object of type T1 has the same size as an object of type T2, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
class | HermitianElement |
Representation of two synchronized elements within the sparse Hermitian matrix.The HermitianElement class represents two synchronized elements (i.e. two value/index pairs) within a sparse Hermitian matrix. It guarantees that a modification of element ![]() ![]() ![]() | |
class | HermitianMatrix |
Matrix adapter for Hermitian ![]() | |
class | HermitianProxy |
Access proxy for Hermitian matrices.The HermitianProxy provides controlled access to the elements of a non-const Hermitian matrix. It guarantees that a modification of element ![]() ![]() ![]() | |
class | HermitianValue |
Representation of two synchronized values within a sparse Hermitian matrix.The HermitianValue class represents two synchronized values within a sparse Hermitian matrix. It guarantees that a modification of value ![]() ![]() ![]() | |
struct | HighType |
Base template for the HighType type trait. More... | |
class | HybridMatrix |
Efficient implementation of a dynamically sized matrix with static memory.The HybridMatrix class template combines the flexibility of a dynamically sized matrix with the efficiency and performance of a fixed-size matrix. It is implemented as a crossing between the blaze::StaticMatrix and the blaze::DynamicMatrix class templates: Similar to the static matrix it uses static stack memory instead of dynamically allocated memory and similar to the dynamic matrix it can be resized (within the extend of the static memory). The type of the elements, the maximum number of rows and columns and the storage order of the matrix can be specified via the four template parameters: More... | |
class | HybridVector |
Efficient implementation of a dynamically sized vector with static memory.The HybridVector class template combines the flexibility of a dynamically sized vector with the efficiency and performance of a fixed-size vector. It is implemented as a crossing between the blaze::StaticVector and the blaze::DynamicVector class templates: Similar to the static vector it uses static stack memory instead of dynamically allocated memory and similar to the dynamic vector it can be resized (within the extend of the static memory). The type of the elements, the maximum number of elements and the transpose flag of the vector can be specified via the three template parameters: More... | |
struct | Hypot |
Generic wrapper for the hypot() function. More... | |
class | IdentityMatrix |
Efficient implementation of an ![]() ![]() | |
struct | If |
Compile time type selection.The If class template selects one of the two given types T1 and T2 depending on the Condition template argument. In case the Condition compile time constant expression evaluates to true, the member type definition Type is set to T1. In case Condition evaluates to false, Type is set to T2. More... | |
struct | Imag |
Generic wrapper for the imag() function. More... | |
class | index_sequence |
Index sequence type of the Blaze library. More... | |
struct | IndexOf |
Searching a type list.The IndexOf class can be used to search the type list for a particular type Type. In contrast to the Contains and the ContainsRelated classes, the IndexOf class evaluates the index of the given type in the type list. In case the type is contained in the type list, the value member represents the index of the queried type. Otherwise the value member is set to the length of the type list. In order to search for a type, the IndexOf class has to be instantiated for a particular type list and a search type. The following example gives an impression of the use of the IndexOf class: More... | |
class | Indices |
Auxiliary class for the generation of random indices. More... | |
class | 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 | initializer_list |
Initializer list type of the Blaze library. More... | |
class | InitializerIterator |
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 | InitializerMatrix |
Dense matrix representation of an initializer list.The InitializerMatrix class template is a dense matrix representation of an (extended) initializer list of arbitrary type. The type of the elements of the matrix can be specified via the single template parameters: More... | |
class | InitializerVector |
Dense vector representation of an initializer list.The InitializerVector class template is a dense vector representation of an (extended) initializer list of arbitrary type. The type of the elements and the transpose flag of the vector can be specified via the two template parameters: More... | |
class | int16_t |
16-bit signed integer type of the Blaze library. More... | |
class | int32_t |
32-bit signed integer type of the Blaze library. More... | |
class | int64_t |
64-bit signed integer type of the Blaze library. More... | |
class | int8_t |
8-bit signed integer type of the Blaze library. More... | |
class | integer_sequence |
Integer sequence type of the Blaze library. More... | |
struct | IntegralConstant |
Generic wrapper for a compile time constant integral value.The IntegralConstant class template represents a generic wrapper for a compile time constant integral value. The value of an IntegralConstant can be accessed via the nested value (which is guaranteed to be of type T), the type can be accessed via the nested type definition ValueType. More... | |
struct | Inv |
Generic wrapper for the inv() function. More... | |
struct | InvAdd |
Generic wrapper for the inverted addition operator. More... | |
struct | InvCbrt |
Generic wrapper for the invcbrt() function. More... | |
struct | InvSqrt |
Generic wrapper for the invsqrt() function. More... | |
struct | IsAdaptor |
Compile time check for adaptors.This type trait tests whether the given template parameter is an adaptor type (for instance LowerMatrix, UpperMatrix, or SymmetricMatrix). In case the type is an adaptor type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example demonstrates this by means of the mentioned matrix adaptors: More... | |
struct | IsAddExpr |
Compile time check whether the given type is an addition expression template.This type trait class tests whether or not the given type Type is an addition expression template (i.e. an expression representing a vector addition or a matrix addition). In order to qualify as a valid addition expression template, the given type has to derive publicly from the AddExpr base class. In case the given type is a valid addition expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsAligned |
Compile time check for the alignment of data types.This type trait tests whether the given data type guarantees to provide aligned data values with respect to the requirements of the available instruction set. For instance, vectorizable data types such as built-in and complex data types are required to be 16-bit aligned for SSE, 32-bit aligned for AVX, and 64-bit aligned for MIC. In case the data type is properly aligned, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. Examples: More... | |
struct | IsArithmetic |
Compile time check for arithmetic data types.This type trait tests whether or not the given template parameter is a (possibly cv-qualified) arithmetic (integral or floating point) data type. In case the type is an arithmetic type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType and the class derives from FalseType. More... | |
struct | IsArray |
Compile time type check.The IsArray type trait tests whether or not the given template parameter is an array type. In case the given data type is an array type, the value member constant is set to true, the nested type definition Type is set to TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType and the class derives from FalseType. More... | |
struct | IsAssignable |
Compile time type check.The IsAssignable type trait tests whether the expression. More... | |
struct | IsBand |
Compile time check for bands.This type trait tests whether or not the given template parameter is a band (i.e. dense or sparse band). In case the type is a band, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
class | IsBaseOf |
Compile time analysis of an inheritance relationship.This type trait tests for an inheritance relationship between the two types Base and Derived. If Derived is a type derived from Base or the same type as Base the value member contant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsBinaryMapExpr |
Compile time check whether the given type is a binary map expression template.This type trait class tests whether or not the given type Type is a binary map expression template. In order to qualify as a valid binary map expression template, the given type has to derive publicly from the BinaryMapExpr base class. In case the given type is a valid binary map expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsBLASCompatible |
Compile time check for data types.This type trait tests whether or not the given template parameter is a data type compatible to the BLAS standard. The BLAS standard supports float , double , complex<float> and complex<double> values. If the type is BLAS compatible, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsBoolean |
Compile time check for boolean types.This type trait tests whether or not the given template parameter is of boolean type. In case the type is a boolean (ignoring the cv-qualifiers), the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsBuiltin |
Compile time check for built-in data types.This type trait tests whether or not the given template parameter is a built-in/fundamental data type. In case the type is a built-in type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsCharacter |
Compile time check for character types.This type trait tests whether or not the given template parameter is a character type (i.e., either char, signed char, unsigned char, or wchar_t, possibly cv-qualified). In case the type is a character type (ignoring the cv-qualifiers), the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsClass |
Compile time type check.The IsClass type trait tests whether or not the given template parameter is a (possibly cv-qualified) class type. In case the given data type is a class type, the value member constant is set to true, the nested type definition Type is set to TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType and the class derives from FalseType. More... | |
struct | IsColumn |
Compile time check for columns.This type trait tests whether or not the given template parameter is a column (i.e. dense or sparse column). In case the type is a column, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsColumnMajorMatrix |
Compile time check for column-major matrix types.This type trait tests whether or not the given template argument is a column-major dense or sparse matrix type (i.e., a matrix whose storage order is set to true). In case the type is a column-major matrix type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsColumns |
Compile time check for column selections.This type trait tests whether or not the given template parameter is a column selection (i.e. a view on columns of a dense or sparse matrix). In case the type is a column selection, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsColumnVector |
Compile time check for column vector types.This type trait tests whether or not the given template argument is a column dense or sparse vector type (i.e. a vector whose transposition flag is set to blaze::columnVector). In case the type is a column vector type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsCommutative |
Compile time check for the commutativity of data types.This type trait tests whether or not the two given data types T1 and T2 are commutative with respect to mathematical operations. If the types are commutative, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsComplex |
Compile time check for complex types.This type trait tests whether or not the given template parameter is a complex data type. In case the type is a complex data type (ignoring the cv-qualifiers), the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsComplexDouble |
Compile time check for single precision complex types.This type trait tests whether or not the given template parameter is of type complex<double> . In case the type is complex<double> (ignoring the cv-qualifiers), the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsComplexFloat |
Compile time check for single precision complex types.This type trait tests whether or not the given template parameter is of type complex<float> . In case the type is complex<float> (ignoring the cv-qualifiers), the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsComputation |
Compile time check whether the given type is a computational expression template.This type trait class tests whether or not the given type Type is a computational expression template (i.e. a mathematical operation such as an addition, a subtraction, a multiplication, a division, an absolute value calculation, ...). In order to qualify as a valid computational expression template, the given type has to derive (publicly or privately) from the Computation base class. In case the given type is a valid computational expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsConst |
Compile time check for constant data types.The IsConst type trait tests whether or not the given template parameter is a (top level) const-qualified data type. In case the given data type is const-qualified, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsConstructible |
Compile time type check.The IsConstructible type trait tests whether the expression. More... | |
struct | IsContiguous |
Compile time check for the memory layout of data types.This type trait tests whether the given data type is array-like and all its elements lie contiguous in memory. In case the data type has contiguous elements, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. Examples: More... | |
struct | IsConvertible |
Compile time pointer relationship constraint.This type traits tests whether the first given template argument can be converted to the second template argument via copy construction. If the first argument can be converted to the second argument, the value member constnt is set to true, the nested type definition type is TrueType, and the class derives from TrueType. Otherwise value is set to false, type is FalseType, and the class derives from FalseType. More... | |
struct | IsCopyAssignable |
Compile time type check.The IsCopyAssignable type trait tests whether the expression. More... | |
struct | IsCopyConstructible |
Compile time type check.The IsCopyConstructible type trait tests whether the expression. More... | |
struct | IsCrossExpr |
Compile time check whether the given type is a cross product expression template.This type trait class tests whether or not the given type Type is a cross product expression template. In order to qualify as a valid cross product expression template, the given type has to derive publicly from the CrossExpr base class. In case the given type is a valid cross product expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsCUDAAssignable |
Compile time check for data types.This type trait tests whether or not the given template parameter is an CUDA-assignable data type (i.e. if it is a data type that can possibly and efficiently be assigned by several threads). In this context, built-in data types as well as complex numbers are not considered CUDA-assignable, whereas several vector and matrix types (as for instance DynamicVector and DynamicMatrix) can be CUDA-assignable. If the type is CUDA-assignable, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsCustom |
Compile time check for custom data types.This type trait tests whether the given data type is a custom data type, i.e. a custom vector or a custom matrix. In case the data type a custom data type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. Examples: More... | |
struct | IsDeclaration |
Compile time check whether the given type is a declaration expression template.This type trait class tests whether the given type Type is a declaration expression template. In order to qualify as a valid declaration expression template, the given type has to derive publicly from the Declaration base class. In case the given type is a valid declaration expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsDeclDiagExpr |
Compile time check whether the given type is a decldiag expression template.This type trait class tests whether or not the given type Type is a decldiag expression template. In order to qualify as a valid decldiag expression template, the given type has to derive publicly from the DeclDiagExpr base class. In case the given type is a valid decldiag expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsDeclExpr |
Compile time check whether the given type is a declaration expression template.This type trait class tests whether or not the given type Type is a declaration expression template. In order to qualify as a valid declaration expression template, the given type has to derive publicly from the DeclExpr base class. In case the given type is a valid declaration expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsDeclHermExpr |
Compile time check whether the given type is a declherm expression template.This type trait class tests whether or not the given type Type is a declherm expression template. In order to qualify as a valid declherm expression template, the given type has to derive publicly from the DeclHermExpr base class. In case the given type is a valid declherm expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsDeclLowExpr |
Compile time check whether the given type is a decllow expression template.This type trait class tests whether or not the given type Type is a decllow expression template. In order to qualify as a valid decllow expression template, the given type has to derive publicly from the DeclLowExpr base class. In case the given type is a valid decllow expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsDeclSymExpr |
Compile time check whether the given type is a declsym expression template.This type trait class tests whether or not the given type Type is a declsym expression template. In order to qualify as a valid declsym expression template, the given type has to derive publicly from the DeclSymExpr base class. In case the given type is a valid declsym expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsDeclUppExpr |
Compile time check whether the given type is a declupp expression template.This type trait class tests whether or not the given type Type is a declupp expression template. In order to qualify as a valid declupp expression template, the given type has to derive publicly from the DeclUppExpr base class. In case the given type is a valid declupp expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsDefaultConstructible |
Compile time type check.The IsDefaultConstructible type trait tests whether the expression. More... | |
struct | IsDenseMatrix |
Compile time check for dense matrix types.This type trait tests whether or not the given template parameter is a dense, N-dimensional matrix type. In case the type is a dense matrix type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise yes is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsDenseVector |
Compile time check for dense vector types.This type trait tests whether or not the given template parameter is a dense, N-dimensional vector type. In case the type is a dense vector type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsDestructible |
Compile time type check.The IsDestructible type trait tests whether the expression. More... | |
struct | IsDiagonal |
Compile time check for diagonal matrices.This type trait tests whether or not the given template parameter is a diagonal matrix type (i.e. a matrix type that is guaranteed to be diagonal at compile time). In case the type is a diagonal matrix type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsDivExpr |
Compile time check whether the given type is a division expression template.This type trait class tests whether or not the given type Type is a division expression template (i.e. an expression representing a vector/scalar division or a matrix/scalar division). In order to qualify as a valid division expression template, the given type has to derive publicly from the DivExpr base class. In case the given type is a valid division expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsDouble |
Compile time check for double precision floating point types.This type trait tests whether or not the given template parameter is of double type. In case the type is double (ignoring the cv-qualifiers), the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsElements |
Compile time check for element selections.This type trait tests whether or not the given template parameter is an element selection (i.e. a view on elements of a dense or sparse vector). In case the type is an element selection, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsEmpty |
Compile time type check.This class tests whether the given template parameter is an empty class type, i.e. a type without member data and virtual functions. If it is an empty class type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsEnum |
Compile time check for complete enumeration types.This type trait tests whether or not the given template parameter is an enumeration type. In case the type is an enumeration type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsEvalExpr |
Compile time check whether the given type is an evaluation expression template.This type trait class tests whether or not the given type Type is an evaluation expression template. In order to qualify as a valid evaluation expression template, the given type has to derive publicly from the EvalExpr base class. In case the given type is a valid evaluation expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsEven |
Compile time check whether a compile time constant expression is even.This value trait tests whether the given integral value N is an even value. In case the value is even, the value member enumeration is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsExpandExpr |
Compile time check whether the given type is an expansion expression template.This type trait class tests whether or not the given type Type is an expansion expression template. In order to qualify as a valid expansion expression template, the given type has to derive publicly from the ExpandExpr base class. In case the given type is a valid expansion expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsExpression |
Compile time check whether the given type is an expression template.This type trait class tests whether or not the given type Type is a Blaze expression template. In order to qualify as a valid expression template, the given type has to derive publicly from the Expression base class. In case the given type is a valid expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsFloat |
Compile time check for single precision floating point types.This type trait tests whether or not the given template parameter is of float type. In case the type is float (ignoring the cv-qualifiers), the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsFloatingPoint |
Compile time check for floating point data types.This type trait tests whether or not the given template parameter is a floating point data type (ignoring the cv-qualifiers). In case the type is a floating point data type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsGeneral |
Compile time check for general matrices.This type trait tests whether or not the given template parameter is a general matrix type (i.e. a matrix type that is neither symmetric, Hermitian, lower triangular or upper triangular at compile time). In case the type is a general matrix type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsHermitian |
Compile time check for Hermitian matrices.This type trait tests whether or not the given template parameter is an Hermitian matrix type (i.e. a matrix type that is guaranteed to be Hermitian at compile time). In case the type is a Hermitian matrix type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsIdentity |
Compile time check for identity matrices.This type trait tests whether or not the given template parameter is an identity matrix type (i.e. a matrix type that is guaranteed to be an identity matrix at compile time). In case the type is an identity matrix type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsInitializer |
Compile time check for custom data types.This type trait tests whether the given data type represents an initializer list, i.e. is an initializer vector or an initializer matrix. In case the data type represents an initializer list, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. Examples: More... | |
struct | IsInteger |
Compile time check for integer types.This type trait tests whether or not the given template parameter is an integer type (i.e., either (signed) int or unsigned int, possibly cv-qualified). In case the type is an integer type (ignoring the cv-qualifiers), the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsIntegral |
Compile time check for integral data types.This type trait tests whether or not the given template parameter is an integral data type. In case the type is an integral data type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsInvertible |
Compile time check for data types.This type trait tests whether or not the given template parameter is invertible. The type is considered to be invertible if it is either BLAS compatible (i.e. float , double , complex<float> , or complex<double> ), long double , complex<long double> or any dense matrix type with a BLAS compatible element type. If the given type is invertible, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsKronExpr |
Compile time check whether the given type is a Kronecker product expression template.This type trait class tests whether or not the given type Type is a Kronecker product expression template. In order to qualify as a valid Kronecker product expression template, the given type has to derive publicly from the KronExpr base class. In case the given type is a valid Kronecker product expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsLong |
Compile time check for long integer types.This type trait tests whether or not the given template parameter is a long integer type (i.e., either (signed) long or unsigned long, possibly cv-qualified). In case the type is a long integer type (ignoring the cv-qualifiers), the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsLongDouble |
Compile time check for extended precision floating point types.This type trait tests whether or not the given template parameter is of long double type. In case the type is long double (ignoring the cv-qualifiers), the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsLower |
Compile time check for lower triangular matrices.This type trait tests whether or not the given template parameter is a lower triangular matrix type (i.e. a matrix type that is guaranteed to be lower triangular at compile time). This also includes lower unitriangular and strictly lower triangular matrices. In case the type is a lower triangular matrix type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsLValueReference |
Compile time type check.This class tests whether the given template parameter T is an lvalue reference type. If it is an lvalue reference type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsMatEvalExpr |
Compile time check whether the given type is a matrix evaluation expression template.This type trait class tests whether or not the given type Type is a matrix evaluation expression template. In order to qualify as a valid matrix evaluation expression template, the given type has to derive publicly from the MatEvalExpr base class. In case the given type is a valid matrix evaluation expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsMatInvExpr |
Compile time check whether the given type is a matrix inversion expression template.This type trait class tests whether or not the given type Type is a matrix inversion expression template. In order to qualify as a valid matrix inversion expression template, the given type has to derive publicly from the MatInvExpr base class. In case the given type is a valid matrix inversion expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsMatMapExpr |
Compile time check whether the given type is a unary matrix map expression template.This type trait class tests whether or not the given type Type is a unary matrix map expression template. In order to qualify as a valid unary matrix map expression template, the given type has to derive publicly from the MatMapExpr base class. In case the given type is a valid unary matrix map expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsMatMatAddExpr |
Compile time check whether the given type is a matrix/matrix addition expression template.This type trait class tests whether or not the given type Type is a matrix/matrix addition expression template. In order to qualify as a valid matrix addition expression template, the given type has to derive publicly from the MatMatAddExpr base class. In case the given type is a valid matrix addition expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsMatMatKronExpr |
Compile time check whether the given type is a matrix/matrix Kronecker product expression template.This type trait class tests whether or not the given type Type is a matrix/matrix Kronecker product expression template. In order to qualify as a valid matrix Kronecker product expression template, the given type has to derive publicly from the MatMatKronExpr base class. In case the given type is a valid matrix Kronecker product expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsMatMatMapExpr |
Compile time check whether the given type is a binary matrix map expression template.This type trait class tests whether or not the given type Type is a binary matrix map expression template. In order to qualify as a valid binary matrix map expression template, the given type has to derive publicly from the MatMatMapExpr base class. In case the given type is a valid binary matrix map expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsMatMatMultExpr |
Compile time check whether the given type is a matrix/matrix multiplication expression template.This type trait class tests whether or not the given type Type is a matrix/matrix multiplication expression template. In order to qualify as a valid matrix multiplication expression template, the given type has to derive publicly from the MatMatMultExpr base class. In case the given type is a valid matrix multiplication expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsMatMatSubExpr |
Compile time check whether the given type is a matrix/matrix subtraction expression template.This type trait class tests whether or not the given type Type is a matrix/matrix subtraction expression template. In order to qualify as a valid matrix subtraction expression template, the given type has to derive publicly from the MatMatSubExpr base class. In case the given type is a valid matrix subtraction expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsMatReduceExpr |
Compile time check whether the given type is a reduction expression template.This type trait class tests whether or not the given type Type is a matrix reduction expression template. In order to qualify as a valid matrix reduction expression template, the given type has to derive publicly from the MatReduceExpr base class. In case the given type is a valid reduction expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsMatrix |
Compile time check for matrix types.This type trait tests whether or not the given template parameter is a N-dimensional dense or sparse matrix type. In case the type is a matrix type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise yes is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsMatScalarDivExpr |
Compile time check whether the given type is a matrix/scalar division expression template.This type trait class tests whether or not the given type Type is a matrix/scalar division expression template. In order to qualify as a valid matrix/scalar division expression template, the given type has to derive publicly from the MatScalarDivExpr base class. In case the given type is a valid matrix/scalar division expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsMatScalarMultExpr |
Compile time check whether the given type is a matrix/scalar multiplication expression template.This type trait class tests whether or not the given type Type is a matrix/scalar multiplication expression template. In order to qualify as a valid matrix/scalar multiplication expression template, the given type has to derive publicly from the MatScalarMultExpr base class. In case the given type is a valid matrix/scalar multiplication expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsMatSerialExpr |
Compile time check whether the given type is a matrix serial evaluation expression template.This type trait class tests whether or not the given type Type is a matrix serial evaluation expression template. In order to qualify as a valid matrix serial evaluation expression template, the given type has to derive publicly from the MatSerialExpr base class. In case the given type is a valid matrix serial evaluation expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsMatTransExpr |
Compile time check whether the given type is a matrix transposition expression template.This type trait class tests whether or not the given type Type is a matrix transposition expression template. In order to qualify as a valid matrix transposition expression template, the given type has to derive publicly from the MatTransExpr base class. In case the given type is a valid matrix transposition expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsMatVecMultExpr |
Compile time check whether the given type is a matrix/vector multiplication expression template.This type trait class tests whether or not the given type Type is a matrix/vector multiplication expression template. In order to qualify as a valid matrix/vector multiplication expression template, the given type has to derive publicly from the MatVecMultExpr base class. In case the given type is a valid matrix/vector multiplication expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsMoveAssignable |
Compile time type check.The IsMoveAssignable type trait tests whether the expression. More... | |
struct | IsMoveConstructible |
Compile time type check.The IsMoveConstructible type trait tests whether the expression. More... | |
struct | IsMultExpr |
Compile time check whether the given type is a multiplication expression template.This type trait class tests whether or not the given type Type is a multiplication expression template (i.e. an expression representing an element-wise vector multiplication, a matrix/vector multiplication, a vector/matrix multiplication, or a matrix multiplication). In order to qualify as a valid multiplication expression template, the given type has to derive publicly from the MultExpr base class. In case the given type is a valid multiplication expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsMultipleOf |
Compile time check for a multiplicative relationship of two integral values.This value trait tests whether the first given integral value M is a multiple of the second integral value N (i.e. if ![]() ![]() | |
struct | IsNothrowAssignable |
Compile time type check.The IsNothrowAssignable type trait tests whether the expression. More... | |
struct | IsNothrowConstructible |
Compile time type check.The IsNothrowConstructible type trait tests whether the expression. More... | |
struct | IsNothrowCopyAssignable |
Compile time type check.The IsNothrowCopyAssignable type trait tests whether the expression. More... | |
struct | IsNothrowCopyConstructible |
Compile time type check.The IsNothrowCopyConstructible type trait tests whether the expression. More... | |
struct | IsNothrowDefaultConstructible |
Compile time type check.The IsNothrowDefaultConstructible type trait tests whether the expression. More... | |
struct | IsNothrowDestructible |
Compile time type check.The IsDestructible type trait tests whether the expression. More... | |
struct | IsNothrowMoveAssignable |
Compile time type check.The IsNothrowMoveAssignable type trait tests whether the expression. More... | |
struct | IsNothrowMoveConstructible |
Compile time type check.The IsNothrowMoveConstructible type trait tests whether the expression. More... | |
struct | IsNumeric |
Compile time check for numeric types.This type trait tests whether or not the given template parameter is a numeric data type. Blaze considers all integral (except bool), floating point, and complex data types as numeric data types. In case the type is a numeric type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsNumericMatrix |
Compile time check for numeric matrix types.This type trait tests whether or not the given template parameter is a numeric matrix type, i.e. a matrix with numeric element type. In case the type is a numeric matrix type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise yes is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsNumericVector |
Compile time check for numeric vector types.This type trait tests whether or not the given template parameter is a numeric vector type, i.e. a vector with numeric element type. In case the type is a numeric vector type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise yes is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsObject |
Compile time type check.This class tests whether the given template parameter T is an object type. All types are considered object types except references, void, and function types. If T is an object type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsOdd |
Compile time check whether a compile time constant expression is odd.This value trait tests whether the given integral value N is an odd value. In case the value is odd, the value member enumeration is set to 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to 0, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsOperation |
Compile time check whether the given type is an operational expression template.This type trait class tests whether or not the given type Type is either a transformation or a computational expression template. In order to qualify as a valid operational expression template, the given type has to derive (publicly or privately) from the Operation base class. In case the given type is a valid operational expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsOpposedView |
Compile time check for resizable data types.This type trait tests whether the given data type is an opposed view, i.e. a view that is opposed to the natural storage order of its underlying type. In case the data type is an opposed view, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. Examples: More... | |
struct | IsPadded |
Compile time check for data types with padding.This type trait tests whether the given data type employs or simulates padding such that no special treatment of remainder elements is necessary for vectorized operations on the type. In case the data type is padded, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. Examples: More... | |
struct | IsPaddingEnabled |
Compile time check for data types.This type trait queries the nested paddingEnabled member of the given data type T, which indicates whether the type provides support for padding (i.e. can properly deal with zeros). If the type is supporting padding, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. Examples: More... | |
struct | IsPod |
Compile time check for pod data types.This type trait tests whether or not the given template parameter is a POD (Plain Old Data). In case the type is a POD, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsPointer |
Compile time type check.This class tests whether the given template parameter is a pointer type (including function pointers, but excluding pointers to members) or not. If it is a pointer type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsPowerOf |
Compile time check for a power relationship of integral values to a given base.This value trait tests whether the given integral value N is a power of the base B according to the equation ![]() ![]() | |
struct | IsProxy |
Compile time check for proxy types.This type trait tests whether or not the given template parameter is a proxy type (i.e. publicly derived from the blaze::Proxy class template). In case the type is a proxy, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsReduceExpr |
Compile time check whether the given type is a reduction expression template.This type trait class tests whether or not the given type Type is a reduction expression template. In order to qualify as a valid reduction expression template, the given type has to derive publicly from the ReduceExpr base class. In case the given type is a valid reduction expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsReference |
Compile time type check.This class tests whether the given template parameter T is a reference type (including references to functions). If it is a reference type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsResizable |
Compile time check for resizable data types.This type trait tests whether the given data type is a resizable data type. In case the data type can be resized (via the resize() function), the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. Examples: More... | |
struct | IsRestricted |
Compile time check for data types with restricted data access.This type trait tests whether the given data type has a restricted data access. Examples are the LowerMatrix and UpperMatrix adaptors that don't allow write access to the elements in the upper or lower part of the matrix, respectively. In case the data type has a restricted data access, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. Examples: More... | |
struct | IsRow |
Compile time check for rows.This type trait tests whether or not the given template parameter is a row (i.e. a view on a row of a dense or sparse matrix). In case the type is a row, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsRowMajorMatrix |
Compile time check for row-major matrix types.This type trait tests whether or not the given template argument is a row-major dense or sparse matrix type (i.e., a matrix whose storage order is set to true). In case the type is a row-major matrix type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsRows |
Compile time check for row selections.This type trait tests whether or not the given template parameter is a row selection (i.e. a view on rows of a dense or sparse matrix). In case the type is a row selection, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsRowVector |
Compile time check for row vector types.This type trait tests whether or not the given template argument is a row dense or sparse vector type (i.e. a vector whose transposition flag is set to blaze::rowVector). In case the type is a row vector type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsRValueReference |
Compile time type check.This class tests whether the given template parameter T is an rvalue reference type. If it is an rvalue reference type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsSame |
Type relationship analysis.This class tests if the two data types A and B are equal. For this type comparison, the cv-qualifiers of both data types are ignored. If A and B are the same data type (ignoring the cv-qualifiers), then the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsSchurExpr |
Compile time check whether the given type is a Schur product expression template.This type trait class tests whether or not the given type Type is a Schur product expression template. In order to qualify as a valid Schur product expression template, the given type has to derive publicly from the SchurExpr base class. In case the given type is a valid Schur product expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsSerialExpr |
Compile time check whether the given type is a serial evaluation expression template.This type trait class tests whether or not the given type Type is a serial evaluation expression template. In order to qualify as a valid serial evaluation expression template, the given type has to derive publicly from the SerialExpr base class. In case the given type is a valid serial evaluation expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsShort |
Compile time check for short integer types.This type trait tests whether or not the given template parameter is a short integer type (i.e., either (signed) short or unsigned short, possibly cv-qualified). In case the type is a short integer type (ignoring the cv-qualifiers), the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsShrinkable |
Compile time check for shrinkable data types.This type trait tests whether the given data type is a shrinkable data type. In case the data type can be shrunk (via the shrinkToFit() function), the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. Examples: More... | |
struct | IsSigned |
Compile time check for signed data types.This type trait tests whether or not the given template parameter is a signed integral or a floating point data type. In case the type is a signed (possibly cv-qualified) data type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsSIMDCombinable |
Compile time check for data types.This type trait tests whether or not the given types can be combined in the context of SIMD operations. By default, all numeric data types are considered combinable to themselves. Also, different integral types of the same size can be combined. If the types are determined to be SIMD combinable, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsSIMDEnabled |
Compile time check for data types.This type trait tests whether or not the given data type T is a SIMD-enabled data type (i.e. provides the according SIMD-related member functions, such as load() , store(), etc). If the type is SIMD-enabled, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsSIMDPack |
Compile time check for SIMD data types.This type trait tests whether the given data type is a Blaze SIMD packed data type. The following types are considered valid SIMD packed types: More... | |
struct | IsSMPAssignable |
Compile time check for data types.This type trait tests whether or not the given template parameter is an SMP-assignable data type (i.e. if it is a data type that can possibly and efficiently be assigned by several threads). In this context, built-in data types as well as complex numbers are non-SMP-assignable, whereas several vector and matrix types (as for instance DynamicVector and DynamicMatrix) can be SMP-assignable. If the type is SMP-assignable, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsSparseElement |
Compile time check whether the given type is a sparse element type.This type trait class tests whether or not the given type Type is a Blaze sparse element type, i.e. if the type implements the sparse element concept by providing a value() and an index() member function. In order to qualify as a valid sparse element type, the given type has to derive (publicly or privately) from the SparseElement base class. In case the given type is a valid sparse element, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsSparseMatrix |
Compile time check for sparse matrix types.This type trait tests whether or not the given template parameter is a sparse, N-dimensional matrix type. In case the type is a sparse matrix type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsSparseVector |
Compile time check for sparse vector types.This type trait tests whether or not the given template parameter is a sparse, N-dimensional vector type. In case the type is a sparse vector type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsSquare |
Compile time check for square matrices.This type trait tests whether or not the given template parameter is a square matrix type (i.e. a matrix type that is guaranteed to be square at compile time). In case the type is a square matrix type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsStatic |
Compile time check for static data types.This type trait tests whether the given data type is a static data type, i.e. a vector or matrix with dimensions fixed at compile time. In case the data type a static data type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. Examples: More... | |
struct | IsStrictlyLower |
Compile time check for strictly lower triangular matrices.This type trait tests whether or not the given template parameter is a strictly lower triangular matrix type (i.e. a matrix type that is guaranteed to be strictly lower triangular at compile time). In case the type is a strictly lower triangular matrix type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsStrictlySame |
Compile time type relationship analysis.This class tests if the two data types A and B are equal. For this type comparison, the cv-qualifiers of both data types are not ignored. If A and B are the same data type, then the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsStrictlyTriangular |
Compile time check for strictly triangular matrix types.This type trait tests whether or not the given template parameter is a strictly lower or upper triangular matrix type. In case the type is a triangular matrix type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise yes is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsStrictlyUpper |
Compile time check for strictly upper triangular matrices.This type trait tests whether or not the given template parameter is a strictly upper triangular matrix type (i.e. a matrix type that is guaranteed to be strictly upper triangular at compile time). In case the type is a strictly upper triangular matrix type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsSubExpr |
Compile time check whether the given type is a subtraction expression template.This type trait class tests whether or not the given type Type is a subtraction expression template (i.e. an expression representing a vector subtraction or a matrix subtraction). In order to qualify as a valid subtraction expression template, the given type has to derive publicly from the SubExpr base class. In case the given type is a valid subtraction expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsSubmatrix |
Compile time check for submatrices.This type trait tests whether or not the given template parameter is a submatrix (i.e. a view on the part of a dense or sparse matrix). In case the type is a submatrix, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsSubvector |
Compile time check for subvectors.This type trait tests whether or not the given template parameter is a subvector (i.e. a view on the part of a dense or sparse vector). In case the type is a subvector, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsSymmetric |
Compile time check for symmetric matrices.This type trait tests whether or not the given template parameter is a symmetric matrix type (i.e. a matrix type that is guaranteed to be symmetric at compile time). In case the type is a symmetric matrix type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsTemporary |
Compile time check whether the given type is a temporary vector or matrix type.This type trait class tests whether the given type is a temporary vector or matrix type, i.e. can be used for a temporary vector or matrix. In case the given type can be used as temporary, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsTransExpr |
Compile time check whether the given type is a transposition expression template.This type trait class tests whether or not the given type Type is a transposition expression template (i.e. an expression representing a vector transposition or a matrix transposition). In order to qualify as a valid transposition expression template, the given type has to derive publicly from the TransExpr base class. In case the given type is a valid transposition expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsTransformation |
Compile time check whether the given type is a transformation expression template.This type trait class tests whether the given type Type is a transformation expression template (e.g. a transpose operation). In order to qualify as a valid transformation expression template, the given type has to derive (publicly or privately) from the Transformation base class. In case the given type is a valid transformation expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsTriangular |
Compile time check for triangular matrix types.This type trait tests whether or not the given template parameter is a lower or upper triangular matrix type. In case the type is a triangular matrix type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise yes is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsTVecMatMultExpr |
Compile time check whether the given type is a vector/matrix multiplication expression template.This type trait class tests whether or not the given type Type is a vector/matrix multiplication expression template. In order to qualify as a valid vector/matrix multiplication expression template, the given type has to derive publicly from the TVecMatMultExpr base class. In case the given type is a valid vector/matrix multiplication expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsUnaryMapExpr |
Compile time check whether the given type is a unary map expression template.This type trait class tests whether or not the given type Type is a unary map expression template. In order to qualify as a valid unary map expression template, the given type has to derive publicly from the UnaryMapExpr base class. In case the given type is a valid unary map expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsUniform |
Compile time check for uniform vectors and matrices.This type trait tests whether or not the given template parameter is a uniform vector or matrix type (i.e. a data type that is guaranteed to be a uniform vector or matrix at compile time). In case the type is a uniform vector or matrix type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsUniLower |
Compile time check for lower unitriangular matrices.This type trait tests whether or not the given template parameter is a lower unitriangular matrix type (i.e. a matrix type that is guaranteed to be lower unitriangular at compile time). In case the type is a lower unitriangular matrix type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsUnion |
Compile time check for union data types.This type trait tests whether or not the given template parameter is a union data type. In case the type is a union, the value member constant is set o true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsUniTriangular |
Compile time check for unitriangular matrix types.This type trait tests whether or not the given template parameter is a lower or upper unitriangular matrix type. In case the type is an unitriangular matrix type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise yes is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsUniUpper |
Compile time check for upper unitriangular matrices.This type trait tests whether or not the given template parameter is an upper unitriangular matrix type (i.e. a matrix type that is guaranteed to be upper unitriangular at compile time). In case the type is an upper unitriangular matrix type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsUnsigned |
Compile time check for unsigned data types.This type trait tests whether or not the given template parameter is an unsigned, integral data type. In case the type is an unsigned (possibly cv-qualified) data type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsUpper |
Compile time check for upper triangular matrices.This type trait tests whether or not the given template parameter is an upper triangular matrix type (i.e. a matrix type that is guaranteed to be upper triangular at compile time). This also includes upper unitriangular and strictly upper triangular matrices. In case the type is an upper triangular matrix type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsValid |
Compile time type check.This class tests whether the given template parameter is a valid or invalid data type (i.e. if the type is the INVALID_TYPE). If T is not the INVALID_TYPE class type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsVecEvalExpr |
Compile time check whether the given type is a vector evaluation expression template.This type trait class tests whether or not the given type Type is a vector evaluation expression template. In order to qualify as a valid vector evaluation expression template, the given type has to derive publicly from the VecEvalExpr base class. In case the given type is a valid vector evaluation expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsVecExpandExpr |
Compile time check whether the given type is a vector expansion expression template.This type trait class tests whether or not the given type Type is a vector expansion expression template. In order to qualify as a valid vector expansion expression template, the given type has to derive publicly from the VecExpandExpr base class. In case the given type is a valid expansion expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsVecMapExpr |
Compile time check whether the given type is a unary vector map expression template.This type trait class tests whether or not the given type Type is a unary vector map expression template. In order to qualify as a valid unary vector map expression template, the given type has to derive publicly from the VecMapExpr base class. In case the given type is a valid unary vector map expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsVecScalarDivExpr |
Compile time check whether the given type is a vector/scalar division expression template.This type trait class tests whether or not the given type Type is a vector/scalar division expression template. In order to qualify as a valid vector/scalar division expression template, the given type has to derive publicly from the VecScalarDivExpr base class. In case the given type is a valid vector/scalar division expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsVecScalarMultExpr |
Compile time check whether the given type is a vector/scalar multiplication expression template.This type trait class tests whether or not the given type Type is a vector/scalar multiplication expression template. In order to qualify as a valid vector/scalar multiplication expression template, the given type has to derive publicly from the VecScalarMultExpr base class. In case the given type is a valid vector/scalar multiplication expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsVecSerialExpr |
Compile time check whether the given type is a vector serial evaluation expression template.This type trait class tests whether or not the given type Type is a vector serial evaluation expression template. In order to qualify as a valid vector serial evaluation expression template, the given type has to derive publicly from the VecSerialExpr base class. In case the given type is a valid vector serial evaluation expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsVector |
Compile time check for vector types.This type trait tests whether or not the given template parameter is a N-dimensional dense or sparse vector type (i.e. whether T is derived from the Vector base class). In case the type is a vector type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsVectorizable |
Compile time check for vectorizable types.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...), this type trait tests whether or not the given template parameter is a vectorizable type, i.e. a type for which intrinsic vector operations and optimizations can be used. Currently, all built-in data types except bool and the according complex numbers are considered to be vectorizable types. In case the type is vectorizable, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsVecTransExpr |
Compile time check whether the given type is a vector transposition expression template.This type trait class tests whether or not the given type Type is a vector transposition expression template. In order to qualify as a valid vector transposition expression template, the given type has to derive publicly from the VecTransExpr base class. In case the given type is a valid vector transposition expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsVecTVecMultExpr |
Compile time check whether the given type is an outer product expression template.This type trait class tests whether or not the given type Type is an outer product expression template (i.e. an expression representing the multiplication between a column vector and a row vector). In order to qualify as a valid outer product expression template, the given type has to derive publicly from the VecTVecMultExpr base class. In case the given type is a valid outer product expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsVecVecAddExpr |
Compile time check whether the given type is a vector/vector addition expression template.This type trait class tests whether or not the given type Type is a vector/vector addition expression template. In order to qualify as a valid vector addition expression template, the given type has to derive publicly from the VecVecAddExpr base class. In case the given type is a valid vector addition expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsVecVecDivExpr |
Compile time check whether the given type is a vector/vector division expression template.This type trait class tests whether or not the given type Type is a vector/vector division expression template. In order to qualify as a valid vector division expression template, the given type has to derive publicly from the VecVecDivExpr base class. In case the given type is a valid vector division expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsVecVecKronExpr |
Compile time check whether the given type is a vector/vector Kronecker product expression template.This type trait class tests whether or not the given type Type is a vector/vector Kronecker product expression template. In order to qualify as a valid vector Kronecker product expression template, the given type has to derive publicly from the VecVecKronExpr base class. In case the given type is a valid vector Kronecker product expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsVecVecMapExpr |
Compile time check whether the given type is a binary vector map expression template.This type trait class tests whether or not the given type Type is a binary vector map expression template. In order to qualify as a valid binary vector map expression template, the given type has to derive publicly from the VecVecMapExpr base class. In case the given type is a valid binary vector map expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsVecVecMultExpr |
Compile time check whether the given type is a vector/vector multiplication expression template.This type trait class tests whether or not the given type Type is a vector/vector multiplication expression template. In order to qualify as a valid vector multiplication expression template, the given type has to derive publicly from the VecVecMultExpr base class. In case the given type is a valid vector multiplication expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsVecVecSubExpr |
Compile time check whether the given type is a vector/vector subtraction expression template.This type trait class tests whether or not the given type Type is a vector/vector subtraction expression template. In order to qualify as a valid vector subtraction expression template, the given type has to derive publicly from the VecVecSubExpr base class. In case the given type is a valid vector subtraction expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsView |
Compile time check for views.This type trait tests whether or not the given template parameter is a view (i.e. subvector, submatrix, row, column, ...). In case the type is a view, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsVoid |
Compile time check for the void data type.This type trait tests whether or not the given template parameter is of type void (ignoring the cv-qualifiers). In case the type is of type void, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsVolatile |
Compile time check for volatile data types.The IsVolatile type trait tests whether or not the given template parameter is a (top level) volatile-qualified data type. In case the given data type is volatile, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | IsZero |
Compile time check for zero vectors or matrices.This type trait tests whether or not the given template parameter is a zero vector or matrix type (i.e. a vector or matrix type that is guaranteed to be zero at compile time). In case the type is a zero vector or matrix type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | Kron |
Generic wrapper for the Kronecker product. More... | |
struct | KronExpr |
Base class for all Kron product expression templates.The KronExpr class serves as a tag for all expression templates that implement mathematical Kronecker products. All classes, that represent a mathematical addition (Kronecker products between vectors or matrices) 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 Kronecker product expression template. Only in case a class is derived publicly from the KronExpr base class, the IsKronExpr type trait recognizes the class as valid Kronecker product expression template. More... | |
struct | KronTrait |
Base template for the KronTrait class. More... | |
struct | L1Norm |
Generic wrapper for the l1Norm() function. More... | |
struct | L2Norm |
Generic wrapper for the l2Norm() function. More... | |
struct | L3Norm |
Generic wrapper for the l3Norm() function. More... | |
struct | L4Norm |
Generic wrapper for the l4Norm() function. More... | |
struct | LeftShiftAssign |
Generic wrapper for bitwise left-shift assignment. More... | |
struct | Length |
Calculating the length of a type list.The Length class can be used to obtain the length of a type list (i.e. the number of contained types). In order to obtain the length of a type list, the Length class has to be instantiated for a particular type list. The length of the type list can be obtained using the member enumeration value. The following example gives an impression of the use of the Length class: More... | |
struct | Less |
Generic wrapper for the less-than relational operator. More... | |
struct | Limits |
Numerical limits of built-in data types.The Limits class provides numerical limits for the following built-in data types: More... | |
struct | Log |
Generic wrapper for the log() function. More... | |
struct | Log10 |
Generic wrapper for the log10() function. More... | |
struct | Log2 |
Generic wrapper for the log2() function. More... | |
class | LowerMatrix |
Matrix adapter for lower triangular ![]() | |
class | LowerProxy |
Access proxy for lower triangular matrices.The LowerProxy provides controlled access to the elements of a non-const lower triangular matrix. It guarantees that the lower matrix invariant is not violated, i.e. that elements in the upper part of the matrix remain default values. The following example illustrates this by means of a ![]() | |
struct | LowType |
Base template for the LowType type trait. More... | |
struct | LpNorm |
Generic wrapper for the lpNorm() function. More... | |
class | make_index_sequence |
Import of the std::make_index_sequence alias template into the Blaze namespace. More... | |
class | make_integer_sequence |
Import of the std::make_integer_sequence alias template into the Blaze namespace. More... | |
struct | MakeSigned |
Compile time type conversion into a signed integral type.This type trait provides the feature to convert the given integral or constant type T to the corresponding signed integral data type with the same size and with the same cv-qualifiers. Note that in case T is bool or a non-integral data type, a compilation error is created. More... | |
struct | MakeUnsigned |
Compile time type conversion into an unsigned integral type.This type trait provides the feature to convert the given integral or constant type T to the corresponding unsigned integral data type with the same size and with the same cv-qualifiers. Note that in case T is bool or a non-integral data type, a compilation error is created. More... | |
struct | MapTrait |
Base template for the MapTrait class. More... | |
struct | MatEvalExpr |
Base class for all matrix evaluation expression templates.The MatEvalExpr class serves as a tag for all expression templates that implement a matrix evaluation operation. All classes, that represent a matrix evaluation operation and that are used within the expression template environment of the Blaze library have to derive 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 | MatInvExpr |
Base class for all matrix inversion expression templates.The MatInvExpr class serves as a tag for all expression templates that implement a matrix inversion operation. All classes, that represent a matrix inversion operation and that are used within the expression template environment of the Blaze library have to derive 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 | MatMapExpr |
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 | MatMatAddExpr |
Base class for all matrix/matrix addition expression templates.The MatMatAddExpr class serves as a tag for all expression templates that implement a matrix/matrix addition. All classes, that represent a matrix addition and that are used within the expression template environment of the Blaze library have to derive 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 | MatMatKronExpr |
Base class for all matrix/matrix Kronecker expression templates.The MatMatKronExpr class serves as a tag for all expression templates that implement a matrix/matrix Kronecker product. All classes, that represent a matrix Kronecker 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 matrix Kronecker product expression template. Only in case a class is derived publicly from the MatMatKronExpr base class, the IsMatMatKronExpr type trait recognizes the class as valid matrix Kronecker product expression template. More... | |
struct | MatMatMapExpr |
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 | MatMatMultExpr |
Base class for all matrix/matrix multiplication expression templates.The MatMatMultExpr class serves as a tag for all expression templates that implement a matrix/matrix multiplication. All classes, that represent a matrix multiplication and that are used within the expression template environment of the Blaze library have to derive 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 | MatMatSubExpr |
Base class for all matrix/matrix subtraction expression templates.The MatMatSubExpr class serves as a tag for all expression templates that implement a matrix/matrix subtraction. All classes, that represent a matrix subtraction and that are used within the expression template environment of the Blaze library have to derive 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 | MatReduceExpr |
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 | Matrix |
Base class for matrices.The Matrix class is a base class for all dense and sparse matrix classes within the Blaze library. It provides an abstraction from the actual type of the matrix, but enables a conversion back to this type via the 'Curiously Recurring Template Pattern' (CRTP). More... | |
class | MatrixAccessProxy |
Access proxy for sparse, ![]() The proxied access to the elements of a sparse matrix is necessary since it may be possible that several insertion operations happen in the same statement. The following code illustrates this with two examples by means of the CompressedMatrix class: More... | |
class | MatrixSerializer |
Serializer for dense and sparse matrices.The MatrixSerializer implements the necessary logic to serialize dense and sparse matrices, i.e. to convert them into a portable, binary representation. The following example demonstrates the (de-)serialization process of matrices: More... | |
struct | MatScalarDivExpr |
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 | MatScalarMultExpr |
Base class for all matrix/scalar multiplication expression templates.The MatScalarMultExpr class serves as a tag for all expression templates that implement a matrix/scalar multiplication. All classes, that represent a matrix/scalar multiplication and that are used within the expression template environment of the Blaze library have to derive 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 | MatSerialExpr |
Base class for all matrix serial evaluation expression templates.The MatSerialExpr class serves as a tag for all expression templates that enforce a serial evaluation of a matrix. All classes, that represent a matrix serialization operation and that are used within the expression template environment of the Blaze library have to derive 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 | MatTransExpr |
Base class for all matrix transposition expression templates.The MatTransExpr class serves as a tag for all expression templates that implement a matrix transposition operation. All classes, that represent a matrix transposition operation and that are used within the expression template environment of the Blaze library have to derive 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 | MatVecMultExpr |
Base class for all matrix/vector multiplication expression templates.The MatVecMultExpr class serves as a tag for all expression templates that implement a matrix/vector multiplication. All classes, that represent a matrix/vector multiplication and that are used within the expression template environment of the Blaze library have to derive 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 | Max |
Generic wrapper for the max() function. More... | |
struct | MaxSize |
Compile time evaluation of the maximum size of vectors and matrices.The MaxSize type trait evaluates the maximum size of a particular dimension of the given vector or matrix type at compile time. In case the given type T is a vector or matrix type with a fixed maximum size (e.g. StaticVector, HybridVector, StaticMatrix, or HybridMatrix) and N is a valid dimension, the value member constant is set to the according size. In all other cases, value is set to -1. More... | |
struct | MaxSizeHelper1 |
struct | MaxSizeHelper2 |
class | MemoryPool |
Memory pool for small objects.The memory pool efficiently improves the performance of dynamic memory allocations for small objects. By allocating a large block of memory that can be dynamically assigned to small objects, the memory allocation is reduced from a few hundred cycles to only a few cycles. The memory pool is build from memory blocks of type Block, which hold the memory for a specified number of objects. The memory of these blocks is managed as a single free list. More... | |
struct | Min |
Generic wrapper for the min() function. More... | |
struct | ModuloAssign |
Generic wrapper for modulo assignment. More... | |
struct | Mult |
Generic wrapper for the multiplication operator. More... | |
struct | MultAssign |
Generic wrapper for multiplication assignment. More... | |
struct | MultExpr |
Base class for all multiplication expression templates.The MultExpr class serves as a tag for all expression templates that implement mathematical multiplications. All classes, that represent a mathematical multiplication (element-wise vector multiplications, matrix/vector multiplications, vector/matrix multiplications and matrix/matrix multiplications) and that are used within the expression template environment of the Blaze library have to derive 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 | MultTrait |
Base template for the MultTrait class. More... | |
class | NegativeAccuracy |
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 | NegativeEpsilon |
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 | NegativeInfinity |
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... | |
struct | NoDelete |
No-delete policy class. More... | |
class | NonCopyable |
Base class for non-copyable class instances.The NonCopyable class is intended to work as a base class for non-copyable classes. Both the copy constructor and the copy assignment operator are explicitly deleted in order to prohibit copy operations of the derived classes. . More... | |
class | NonCreatable |
Base class for non-creatable (static) classes.The NonCreatable class is intended to work as a base class for non-creatable classes, i.e. classes that cannot be instantiated and exclusively offer static functions/data. Both the standard as well as the copy constructor and the copy assignment operator are declared private and left undefinded in order to prohibit the instantiation of objects of derived classes. . More... | |
class | NonNumericProxy |
Access proxy for symmetric, square matrices with non-numeric element types.The NonNumericProxy provides controlled access to the elements of a non-const symmetric matrix with non-numeric element type (e.g. vectors or matrices). It guarantees that a modification of element ![]() ![]() ![]() | |
struct | Noop |
Generic wrapper for the null function. More... | |
struct | Not |
Generic wrapper for the logical NOT operator. More... | |
class | NullType |
Utility type for generic codes.The NullType class represents an invalid or terminating data type for generic codes. For instance, the TypeList class uses the NullType as terminating data type for the type list. More... | |
class | NumericProxy |
Access proxy for symmetric, square matrices with numeric element types.The NumericProxy provides controlled access to the elements of a non-const symmetric matrix with numeric element type (e.g. integral values, floating point values, and complex values). It guarantees that a modification of element ![]() ![]() ![]() | |
struct | 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 | Or |
Generic wrapper for the logical OR operator. More... | |
struct | OrAssign |
Generic wrapper for bitwise OR assignment. More... | |
class | ParallelSection |
Section for the debugging of the shared-memory parallelization.The ParallelSection class is an auxiliary helper class for the BLAZE_PARALLEL_SECTION macro. It provides the functionality to detected whether a parallel section has been started and with that serves as a utility for debugging the shared-memory parallelization. More... | |
struct | Pow |
Generic wrapper for the pow() function. More... | |
struct | Pow2 |
Generic wrapper for the pow2() function. More... | |
struct | Pow3 |
Generic wrapper for the pow3() function. More... | |
struct | Pow4 |
Generic wrapper for the pow4() function. More... | |
class | Proxy |
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... | |
struct | PtrDelete |
Pointer-delete policy class.The PtrDelete policy functor class applies a delete operation to the given argument. Note that the delete operation is NOT permitted for inclomplete types (i.e. declared but undefined data types). The attempt to apply a PtrDelete functor to a pointer to an object of incomplete type results in a compile time error! More... | |
class | ptrdiff_t |
Pointer difference type of the Blaze library. More... | |
struct | Qdrt |
Generic wrapper for the qdrt() function. More... | |
class | Rand |
Default implementation of the Rand class for integral data types.This default implementation of the Rand class creates random, integral numbers in the range ![]() | |
class | Random |
Random number generator.The Random class encapsulates the initialization of the given random number generator with a pseudo-random seed obtained by the std::time() function. Currently, the mersenne-twister mt19937 as provided by the C++ standard library is used per default. For more information see the for instance the following documentation of the random number functionality of the C++11 standard library: More... | |
struct | Rank |
Compile time check for array ranks.This type trait determines the rank of the given template argument. In case the given type is an array type, the nested value member constant is set to the number of dimensions of T. Otherwise value is set to 0. More... | |
struct | Real |
Generic wrapper for the real() function. More... | |
struct | ReduceExpr |
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 | ReduceTrait |
Base template for the ReduceTrait class. More... | |
struct | RemoveAdaptor |
Removal of top level adaptor types.In case the given type is an adaptor type (SymmetricMatrix, LowerMatrix, UpperMatrix, ...), the RemoveAdaptor type trait removes the adaptor and extracts the contained general matrix type. Else the given type is returned as is. Note that cv-qualifiers are preserved. More... | |
struct | RemoveAllExtents |
Removal of all array extents.The RemoveAllExtents type trait removes all array extents from the given type T. More... | |
struct | RemoveConst |
Removal of const-qualifiers.The RemoveConst type trait removes all top level 'const' qualifiers from the given type T. More... | |
struct | RemoveCV |
Removal of top level cv-qualifiers.The RemoveCV type trait removes all top level cv-qualifiers from the given type T. More... | |
struct | RemoveCVRef |
Removal of top level cv-qualifiers.The RemoveCVRef type trait removes any reference modifiers and all top level cv-qualifiers from the given type T. More... | |
struct | RemoveExtent |
Removal of the top level array extent.The RemoveExtent type trait removes the top level array extent from the given type T. More... | |
struct | RemovePointer |
Removal of pointer modifiers.The RemovePointer type trait removes any pointer modifiers from the given type T. More... | |
struct | RemoveReference |
Removal of reference modifiers.The RemoveReference type trait removes any reference modifiers from the given type T. More... | |
struct | RemoveVolatile |
Removal of volatile-qualifiers.The RemoveVolatile type trait removes all top level 'volatile' qualifiers from the given type T. More... | |
struct | RequiresEvaluation |
Compile time check to query the requirement to evaluate an expression.Via this type trait it is possible to determine whether a given vector or matrix expression type requires an intermediate evaluation in the context of a compound expression. In case the given type requires an evaluation, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | Reset |
Generic wrapper for the reset() function. More... | |
struct | RightShiftAssign |
Generic wrapper for bitwise right-shift assignment. More... | |
struct | Round |
Generic wrapper for the round() function. More... | |
class | RowData |
Auxiliary class template for the data members of the Row class.The auxiliary RowData class template represents an abstraction of the data members of the Row class template. The necessary set of data members is selected depending on the number of compile time row arguments. More... | |
struct | RowsTrait |
Base template for the RowsTrait class. More... | |
struct | RowTrait |
Base template for the RowTrait class. More... | |
struct | Schur |
Generic wrapper for the Schur product. More... | |
struct | SchurExpr |
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 | SchurTrait |
Base template for the SchurTrait class. More... | |
struct | Serial |
Generic wrapper for the Serial() function. More... | |
struct | SerialExpr |
Base class for all serial evaluation expression templates.The SerialExpr class serves as a tag for all expression templates that enforce a serial evaluation. All classes, that represent a serialization operation and that are used within the expression template environment of the Blaze library have to derive 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... | |
class | SerialSection |
Section to enforce the serial execution of operations.The SerialSection class is an auxiliary helper class for the BLAZE_SERIAL_SECTION macro. It provides the functionality to detect whether a serial section is active, i.e. if the currently executed code is inside a serial section. More... | |
class | SharedValue |
Value shared among several positions within a symmetric matrix.The SharedValue class template represents a single value of a symmetric matrix that is shared among several positions within the symmetric matrix. Changes to the value of one position are therefore applied to all positions sharing the same value. More... | |
struct | ShiftLI |
Generic wrapper for the uniform left-shift operation. More... | |
struct | ShiftLV |
Generic wrapper for the elementwise left-shift operation. More... | |
struct | ShiftRI |
Generic wrapper for the uniform right-shift operation. More... | |
struct | ShiftRV |
Generic wrapper for the elementwise right-shift operation. More... | |
struct | Sign |
Generic wrapper for the sign() function. More... | |
class | SIMDcdouble |
SIMD type for 64-bit double precision complex values. More... | |
class | SIMDcfloat |
SIMD type for 32-bit single precision complex values. More... | |
class | SIMDcint16 |
SIMD type for 16-bit signed integral complex values. More... | |
class | SIMDcint32 |
SIMD type for 32-bit signed integral complex values. More... | |
class | SIMDcint64 |
SIMD type for 64-bit signed integral complex values. More... | |
class | SIMDcint8 |
SIMD type for 8-bit signed integral complex values. More... | |
class | SIMDcuint16 |
SIMD type for 16-bit unsigned integral complex values. More... | |
class | SIMDcuint32 |
SIMD type for 32-bit unsigned integral complex values. More... | |
class | SIMDcuint64 |
SIMD type for 64-bit unsigned integral complex values. More... | |
class | SIMDcuint8 |
SIMD type for 8-bit unsigned integral complex values. More... | |
class | SIMDdouble |
SIMD type for 64-bit double precision floating point data values. More... | |
struct | SIMDf32FmaddExpr |
Expression object for 32-bit floating point fused multiply-add operations.The SIMDf32FmaddExpr class represents the compile time expression for 32-bit floating point fused multiply-add operations. More... | |
struct | SIMDf32FmsubExpr |
Expression object for 32-bit floating point fused multiply-subtract operations.The SIMDf32FmsubExpr class represents the compile time expression for 32-bit floating point fused multiply-subtract operations. More... | |
struct | SIMDf32MultExpr |
Expression object for 32-bit floating point multiplication operations.The SIMDf32MultExpr class represents the compile time expression for 32-bit floating point multiplication operations. More... | |
struct | SIMDf64FmaddExpr |
Addition operator for fusing a 32-bit floating point multiplication and addition. More... | |
struct | SIMDf64FmsubExpr |
Expression object for 64-bit floating point fused multiply-subtract operations.The SIMDf64FmsubExpr class represents the compile time expression for 64-bit floating point fused multiply-subtract operations. More... | |
struct | SIMDf64MultExpr |
Expression object for 64-bit floating point multiplication operations.The SIMDf64MultExpr class represents the compile time expression for 64-bit floating point multiplication operations. More... | |
class | SIMDfloat |
SIMD type for 32-bit single precision floating point data values. More... | |
class | SIMDint16 |
SIMD type for 16-bit signed integral data values. More... | |
class | SIMDint32 |
SIMD type for 32-bit signed integral data values. More... | |
class | SIMDint64 |
SIMD type for 64-bit integral data values. More... | |
class | SIMDint8 |
SIMD type for 8-bit signed integral data values. More... | |
struct | SIMDPack |
Base class for all SIMD data types.The SIMDPack class template is a base class for all SIMD data types within the Blaze library. It provides an abstraction from the actual type of the SIMD pack, but enables a conversion back to this type via the 'Curiously Recurring Template Pattern' (CRTP). More... | |
class | SIMDTrait |
SIMD characteristics of data types.The SIMDTrait class template provides the SIMD characteristics of a specific data type: More... | |
class | SIMDuint16 |
SIMD type for 16-bit unsigned integral data values. More... | |
class | SIMDuint32 |
SIMD type for 32-bit unsigned integral data values. More... | |
class | SIMDuint64 |
SIMD type for 64-bit unsigned integral data values. More... | |
class | SIMDuint8 |
SIMD type for 8-bit unsigned integral data values. More... | |
struct | Sin |
Generic wrapper for the sin() function. More... | |
class | Singleton |
Base class for all lifetime managed singletons.The Singleton class represents the base class for all lifetime managed singletons of the Blaze library. Classes, which are supposed to be implemented in terms of the singleton pattern, only have to derive from this class in order to gain all basic characteristics of a singleton: More... | |
struct | Sinh |
Generic wrapper for the sinh() function. More... | |
struct | Size |
Compile time evaluation of the size of vectors and matrices.The Size type trait evaluates the size of a particular dimension of the given vector or matrix type at compile time. In case the given type T is a vector or matrix type with a fixed size (e.g. StaticVector or StaticMatrix) and N is a valid dimension, the value member constant is set to the according size. In all other cases, value is set to -1. More... | |
class | size_t |
Size type of the Blaze library. More... | |
struct | SizeHelper1 |
struct | SizeHelper2 |
class | SmallArray |
Implementation of a dynamic array with small array optimization.The SmallArray class template is a hybrid data structure between a static array and a dynamic array. It provides static, in-place memory for up to N elements of type T, but can grow beyond this size by allocating dynamic memory via its allocator of type A. More... | |
class | SMatDeclDiagExpr |
Expression object for the explicit diagonal declaration of sparse matrices.The SMatDeclDiagExpr class represents the compile time expression for the explicit diagonal declaration of a sparse matrix. More... | |
class | SMatDeclHermExpr |
Expression object for the explicit Hermitian declaration of sparse matrices.The SMatDeclHermExpr class represents the compile time expression for the explicit Hermitian declaration of a sparse matrix. More... | |
class | SMatDeclLowExpr |
Expression object for the explicit lower declaration of sparse matrices.The SMatDeclLowExpr class represents the compile time expression for the explicit lower declaration of a sparse matrix. More... | |
class | SMatDeclSymExpr |
Expression object for the explicit symmetry declaration of sparse matrices.The SMatDeclSymExpr class represents the compile time expression for the explicit symmetry declaration of a sparse matrix. More... | |
class | SMatDeclUppExpr |
Expression object for the explicit upper declaration of sparse matrices.The SMatDeclUppExpr class represents the compile time expression for the explicit upper declaration of a sparse matrix. More... | |
class | SMatDMatKronExpr |
Expression object for sparse matrix-dense matrix Kronecker product.The SMatDMatKronExpr class represents the compile time expression for Kronecker products between a sparse matrix and a dense matrix. More... | |
class | SMatDMatMultExpr |
Expression object for sparse matrix-dense matrix multiplications.The SMatDMatMultExpr class represents the compile time expression for multiplications between a row-major sparse matrix and a row-major dense matrix. More... | |
class | SMatDMatSchurExpr |
Expression object for sparse matrix-dense matrix Schur product.The SMatDMatSchurExpr class represents the compile time expression for Schur products between a row-major sparse matrix and a dense matrix. More... | |
class | SMatDMatSubExpr |
Expression object for sparse matrix-dense matrix subtractions.The SMatDMatSubExpr class represents the compile time expression for subtractions between a sparse matrix and a dense matrix with identical storage order. More... | |
class | SMatDVecMultExpr |
Expression object for sparse matrix-dense vector multiplications.The SMatDVecMultExpr class represents the compile time expression for multiplications between row-major sparse matrices and dense vectors. More... | |
class | SMatEvalExpr |
Expression object for the forced evaluation of sparse matrices.The SMatEvalExpr class represents the compile time expression for the forced evaluation of a sparse matrix. More... | |
class | SMatMapExpr |
Expression object for the sparse matrix map() function.The SMatMapExpr class represents the compile time expression for the evaluation of a custom operation on each element of a sparse matrix via the map() function. More... | |
class | SMatReduceExpr |
Base template for row-major sparse matrix partial reduction operations.The SMatReduceExpr class represents the compile time expression for partial reduction operations of row-major sparse matrices. More... | |
class | SMatReduceExpr< MT, OP, columnwise > |
Expression object for column-wise row-major sparse matrix reduction operations.This specialization of the SMatReduceExpr class template represents the compile time expression for column-wise reduction operations of row-major sparse matrices. More... | |
class | SMatReduceExpr< MT, OP, rowwise > |
Expression object for row-wise row-major sparse matrix reduction operations.This specialization of the SMatReduceExpr class template represents the compile time expression for row-wise reduction operations of row-major sparse matrices. More... | |
class | SMatScalarDivExpr |
Expression object for sparse matrix-scalar divisions.The SMatScalarMult class represents the compile time expression for divisions between a sparse matrix and a scalar value. More... | |
class | SMatScalarMultExpr |
Expression object for sparse matrix-scalar multiplications.The SMatScalarMult class represents the compile time expression for multiplications between a sparse matrix and a scalar value. More... | |
class | SMatSerialExpr |
Expression object for the forced serial evaluation of sparse matrices.The SMatSerialExpr class represents the compile time expression for the forced serial evaluation of a sparse matrix. More... | |
class | SMatSMatAddExpr |
Expression object for sparse matrix-sparse matrix additions.The SMatSMatAddExpr class represents the compile time expression for additions between two row-major sparse matrices. More... | |
class | SMatSMatKronExpr |
Expression object for sparse matrix-sparse matrix Kronecker product.The SMatSMatKronExpr class represents the compile time expression for Kronecker products between sparse matrices of any storage order. More... | |
class | SMatSMatMultExpr |
Expression object for sparse matrix-sparse matrix multiplications.The SMatSMatMultExpr class represents the compile time expression for multiplications between row-major sparse matrices. More... | |
class | SMatSMatSchurExpr |
Expression object for sparse matrix-sparse matrix Schur product.The SMatSMatSchurExpr class represents the compile time expression for Schur products between sparse matrices. More... | |
class | SMatSMatSubExpr |
Expression object for sparse matrix-sparse matrix subtractions.The SMatSMatSubExpr class represents the compile time expression for subtractions between sparse matrices. More... | |
class | SMatSVecMultExpr |
Expression object for sparse matrix-sparse vector multiplications.The SMatSVecMultExpr class represents the compile time expression for multiplications between row-major sparse matrices and sparse vectors. More... | |
class | SMatTDMatMultExpr |
Expression object for sparse matrix-transpose dense matrix multiplications.The SMatTDMatMultExpr class represents the compile time expression for multiplications between a row-major sparse matrix and a column-major dense matrix. More... | |
class | SMatTDMatSubExpr |
Expression object for sparse matrix-transpose dense matrix subtractions.The SMatTDMatSubExpr class represents the compile time expression for subtractions between a row-major sparse matrix and a column-major dense matrix. More... | |
class | SMatTransExpr |
Expression object for sparse matrix transpositions.The SMatTransExpr class represents the compile time expression for transpositions of sparse matrices. More... | |
class | SMatTransposer |
Expression object for the transposition of a sparse matrix.The SMatTransposer class is a wrapper object for the temporary transposition of a sparse matrix. More... | |
class | SMatTSMatAddExpr |
Expression object for sparse matrix-transpose sparse matrix additions.The SMatTSMatAddExpr class represents the compile time expression for additions between a row-major sparse matrix and a column-major sparse matrix. More... | |
class | SMatTSMatKronExpr |
Expression object for sparse matrix-transpose sparse matrix Kronecker product.The SMatTSMatKronExpr class represents the compile time expression for Schur products between a row-major sparse matrix and a column-major sparse matrix. More... | |
class | SMatTSMatMultExpr |
Expression object for sparse matrix-transpose sparse matrix multiplications.The SMatTSMatMultExpr class represents the compile time expression for multiplications between a row-major and a column-major sparse matrix. More... | |
class | SMatTSMatSchurExpr |
Expression object for sparse matrix-transpose sparse matrix Schur product.The SMatTSMatSchurExpr class represents the compile time expression for Schur products between a row-major sparse matrix and a column-major sparse matrix. More... | |
class | SMatTSMatSubExpr |
Expression object for sparse matrix-transpose sparse matrix subtractions.The SMatTSMatSubExpr class represents the compile time expression for subtractions between a row-major sparse matrix and a column-major sparse matrix. More... | |
class | SMatVarExpr |
Base template for the row-/column-wise variance computations on row-major sparse matrices.The SMatVarExpr class represents the compile time expression for the computation of the row-/column-wise variance function on row-major sparse matrices. More... | |
class | SMatVarExpr< MT, columnwise > |
Expression object for the column-wise variance function on row-major sparse matrices.This specialization of the SMatVarExpr class template represents the compile time expression for the column-wise variance function on row-major sparse matrices. More... | |
class | SMatVarExpr< MT, rowwise > |
Expression object for the row-wise variance function on row-major sparse matrices.This specialization of the SMatVarExpr class template represents the compile time expression for the row-wise variance function on row-major sparse matrices. More... | |
struct | 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... | |
struct | SparseMatrix |
Base class for sparse matrices.The SparseMatrix class is a base class for all sparse matrix classes. It provides an abstraction from the actual type of the sparse matrix, but enables a conversion back to this type via the Matrix base class. More... | |
class | SparseMatrixProxy |
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... | |
struct | SparseVector |
Base class for sparse vectors.The SparseVector class is a base class for all arbitrarily sized (N-dimensional) sparse vectors. It provides an abstraction from the actual type of the sparse vector, but enables a conversion back to this type via the Vector base class. More... | |
class | SparseVectorProxy |
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 | SqrAbs |
Generic wrapper for the squared abs() function. More... | |
struct | Sqrt |
Generic wrapper for the sqrt() function. More... | |
class | StaticMatrix |
Efficient implementation of a fixed-sized matrix.The StaticMatrix class template is the representation of a fixed-size matrix with statically allocated elements of arbitrary type. The type of the elements, the number of rows and columns and the storage order of the matrix can be specified via the four template parameters: More... | |
class | StaticVector |
Efficient implementation of a fixed-sized vector.The StaticVector class template is the representation of a fixed-size vector with statically allocated elements of arbitrary type. The type of the elements, the number of elements and the transpose flag of the vector can be specified via the three template parameters: More... | |
struct | StorageOrder |
Evaluation of the storage order of a given matrix type.Via this type trait it is possible to evaluate the storage order of a given matrix type. In case the given type is a row-major matrix type the nested boolean value is set to rowMajor, in case it is a column-major matrix type it is set to columnMajor. If the given type is not a matrix type a compilation error is created. More... | |
class | StrictlyLowerMatrix |
Matrix adapter for strictly lower triangular ![]() | |
class | StrictlyLowerProxy |
Access proxy for strictly lower triangular matrices.The StrictlyLowerProxy provides controlled access to the elements of a non-const strictly lower triangular matrix. It guarantees that the strictly lower matrix invariant is not violated, i.e. that elements on the diagonal and in the upper part of the matrix remain 0. The following example illustrates this by means of a ![]() | |
class | StrictlyUpperMatrix |
Matrix adapter for strictly upper triangular ![]() | |
class | StrictlyUpperProxy |
Access proxy for strictly upper triangular matrices.The StrictlyUpperProxy provides controlled access to the elements of a non-const strictly upper triangular matrix. It guarantees that the strictly upper matrix invariant is not violated, i.e. that elements on the diagonal and in the lower part of the matrix remain 0. The following example illustrates this by means of a ![]() | |
struct | Sub |
Generic wrapper for the subtraction operator. More... | |
struct | SubAssign |
Generic wrapper for subtraction assignment. More... | |
struct | SubExpr |
Base class for all subtraction expression templates.The SubExpr class serves as a tag for all expression templates that implement mathematical subtractions. All classes, that represent a mathematical subtraction (vector subtractions and matrix subtractions) and that are used within the expression template environment of the Blaze library have to derive 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... | |
class | SubmatrixData |
Auxiliary class template for the data members of the Submatrix class.The auxiliary SubmatrixData class template represents an abstraction of the data members of the Submatrix class template. The necessary set of data members is selected depending on the number of compile time submatrix arguments. More... | |
struct | SubmatrixTrait |
Base template for the SubmatrixTrait class. More... | |
struct | SubTrait |
Base template for the SubTrait class. More... | |
class | SubvectorData |
Auxiliary class template for the data members of the Subvector class.The auxiliary SubvectorData class template represents an abstraction of the data members of the Subvector class template. The necessary set of data members is selected depending on the number of compile time subvector arguments. More... | |
struct | SubvectorTrait |
Base template for the SubvectorTrait class. More... | |
class | SVecDVecCrossExpr |
Expression object for sparse vector-dense vector cross products.The SVecDVecCrossExpr class represents the compile time expression for cross products between a sparse vector and a dense vector. More... | |
class | SVecDVecDivExpr |
Expression object for sparse vector-dense vector divisions.The SVecDVecDivExpr class represents the compile time expression for componentwise divisions between a sparse vector and a dense vector. More... | |
class | SVecDVecKronExpr |
Expression object for sparse vector-dense vector Kronecker products.The SVecDVecKronExpr class represents the compile time expression for Kronecker products between a sparse vector and a dense vector. More... | |
class | SVecDVecMultExpr |
Expression object for sparse vector-dense vector multiplications.The SVecDVecMultExpr class represents the compile time expression for componentwise multiplications between a sparse vector and a dense vector. More... | |
class | SVecDVecOuterExpr |
Expression object for sparse vector-dense vector outer products.The SVecDVecOuterExpr class represents the compile time expression for sparse vector-dense vector outer products. More... | |
class | SVecDVecSubExpr |
Expression object for sparse vector-dense vector subtractions.The SVecDVecSubExpr class represents the compile time expression for subtractions between a sparse vector and a dense vector. More... | |
class | SVecEvalExpr |
Expression object for the forced evaluation of sparse vectors.The SVecEvalExpr class represents the compile time expression for the forced evaluation of a sparse vector. More... | |
class | SVecExpandExpr |
Expression object for sparse vector expansion.The SVecExpandExpr class represents the compile time expression for expansions of sparse vectors. More... | |
class | SVecMapExpr |
Expression object for the sparse vector map() function.The SVecMapExpr class represents the compile time expression for the evaluation of a custom operation on each element of a sparse vector via the map() function. More... | |
class | SVecScalarDivExpr |
Expression object for divisions of a sparse vector by a scalar.The SVecScalarDivExpr class represents the compile time expression for divisions of sparse vectors by scalar values. More... | |
class | SVecScalarMultExpr |
Expression object for sparse vector-scalar multiplications.The SVecScalarMultExpr class represents the compile time expression for multiplications between a sparse vector and a scalar value. More... | |
class | SVecSerialExpr |
Expression object for the forced serial evaluation of sparse vectors.The SVecSerialExpr class represents the compile time expression for the forced serial evaluation of a sparse vector. More... | |
class | SVecSVecAddExpr |
Expression object for sparse vector-sparse vector additions.The SVecSVecAddExpr class represents the compile time expression for additions between sparse vectors. More... | |
class | SVecSVecCrossExpr |
Expression object for sparse vector-sparse vector cross products.The SVecSVecCrossExpr class represents the compile time expression for cross products between sparse vectors. More... | |
class | SVecSVecKronExpr |
Expression object for sparse vector-sparse vector Kronecker products.The SVecSVecKronExpr class represents the compile time expression for Kronecker products between sparse vectors. More... | |
class | SVecSVecMultExpr |
Expression object for sparse vector-sparse vector multiplications.The SVecSVecMultExpr class represents the compile time expression for componentwise multiplications between sparse vectors. More... | |
class | SVecSVecOuterExpr |
Expression object for sparse vector-sparse vector outer products.The SVecSVecOuterExpr class represents the compile time expression for sparse vector-sparse vector outer products. More... | |
class | SVecSVecSubExpr |
Expression object for sparse vector-sparse vector subtractions.The SVecSVecSubExpr class represents the compile time expression for subtractions between sparse vectors. More... | |
class | SVecTransExpr |
Expression object for sparse vector transpositions.The SVecTransExpr class represents the compile time expression for transpositions of sparse vectors. More... | |
class | SVecTransposer |
Expression object for the transposition of a sparse vector.The SVecTransposer class is a wrapper object for the temporary transposition of a sparse vector. More... | |
class | SymmetricElement |
Representation of two synchronized elements within the sparse symmetric matrix.The SymmetricElement class represents two synchronized elements (i.e. two value/index pairs) within a sparse symmetric matrix. It guarantees that a modification of element ![]() ![]() ![]() | |
class | SymmetricMatrix |
Matrix adapter for symmetric ![]() | |
class | SymmetricValue |
Representation of two synchronized values within a sparse symmetric matrix.The SymmetricValue class represents two synchronized values within a sparse symmetric matrix. It guarantees that a modification of value ![]() ![]() ![]() | |
struct | Tan |
Generic wrapper for the tan() function. More... | |
struct | Tanh |
Generic wrapper for the tanh() function. More... | |
class | TDMatDMatMultExpr |
Expression object for transpose dense matrix-dense matrix multiplications.The TDMatDMatMultExpr class represents the compile time expression for multiplications between a column-major dense matrix and a row-major dense matrix. More... | |
class | TDMatDVecMultExpr |
Expression object for transpose dense matrix-dense vector multiplications.The TDMatDVecMultExpr class represents the compile time expression for multiplications between column-major dense matrices and dense vectors. More... | |
class | TDMatSMatAddExpr |
Expression object for dense matrix-sparse matrix additions.The TDMatSMatAddExpr class represents the compile time expression for additions between a column-major dense matrix and a row-major sparse matrix. More... | |
class | TDMatSMatMultExpr |
Expression object for transpose dense matrix-sparse matrix multiplications.The TDMatSMatMultExpr class represents the compile time expression for multiplications between a column-major dense matrix and a row-major sparse matrix. More... | |
class | TDMatSMatSubExpr |
Expression object for transpose dense matrix-sparse matrix subtractions.The TDMatSMatSubExpr class represents the compile time expression for subtractions between a row-major dense matrix and a column-major sparse matrix. More... | |
class | TDMatSVecMultExpr |
Expression object for transpose dense matrix-sparse vector multiplications.The TDMatSVecMultExpr class represents the compile time expression for multiplications between column-major dense matrices and sparse vectors. More... | |
class | TDMatTDMatMultExpr |
Expression object for transpose dense matrix-transpose dense matrix multiplications.The TDMatTDMatMultExpr class represents the compile time expression for multiplications between two column-major dense matrices. More... | |
class | TDMatTSMatMultExpr |
Expression object for transpose dense matrix-transpose sparse matrix multiplications.The TDMatTSMatMultExpr class represents the compile time expression for multiplications between a column-major dense matrix and a column-major sparse matrix. More... | |
class | TDVecDMatMultExpr |
Expression object for transpose dense vector-dense matrix multiplications.The TDVecDMatMultExpr class represents the compile time expression for multiplications between transpose dense vectors and dense matrices. More... | |
class | TDVecSMatMultExpr |
Expression object for transpose dense vector-sparse matrix multiplications.The TDVecSMatMultExpr class represents the compile time expression for multiplications between transpose dense vectors and row-major sparse matrices. More... | |
class | TDVecTDMatMultExpr |
Expression object for transpose dense vector-transpose dense matrix multiplications.The TDVecTDMatMultExpr class represents the compile time expression for multiplications between transpose dense vectors and column-major dense matrices. More... | |
class | TDVecTSMatMultExpr |
Expression object for transpose dense vector-transpose sparse matrix multiplications.The TDVecTSMatMultExpr class represents the compile time expression for multiplications between transpose dense vectors and column-major sparse matrices. More... | |
class | Thread |
Implementation of a single thread of execution. More... | |
class | ThreadPool |
Implementation of a thread pool. More... | |
struct | Trans |
Generic wrapper for the trans() function. More... | |
struct | TransExpr |
Base class for all transposition expression templates.The TransExpr class serves as a tag for all expression templates that implement mathematical transpositions. All classes, that represent a mathematical transposition (vector transpositions and matrix transpositions) and that are used within the expression template environment of the Blaze library have to derive 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 | 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 | TransposeFlag |
Evaluation of the transpose flag of a given matrix type.Via this type trait it is possible to evaluate the transpose flag of a given vector type. In case the given type is a row vector type the nested boolean value is set to rowVector, in case it is a column vector type it is set to columnVector. If the given type is not a vector type a compilation error is created. More... | |
struct | Trunc |
Generic wrapper for the trunc() function. More... | |
class | TSMatDMatMultExpr |
Expression object for transpose sparse matrix-dense matrix multiplications.The TSMatDMatMultExpr class represents the compile time expression for multiplications between a column-major sparse matrix and a row-major dense matrix. More... | |
class | TSMatDMatSchurExpr |
Expression object for transpose sparse matrix-dense matrix Schur product.The TSMatDMatSchurExpr class represents the compile time expression for Schur products between a transpose sparse matrix and a dense matrix. More... | |
class | TSMatDMatSubExpr |
Expression object for transpose sparse matrix-dense matrix subtractions.The TSMatDMatSubExpr class represents the compile time expression for subtractions between a column-major sparse matrix and a row-major dense matrix. More... | |
class | TSMatDVecMultExpr |
Expression object for transpose sparse matrix-dense vector multiplications.The TSMatDVecMultExpr class represents the compile time expression for multiplications between column-major sparse matrices and dense vectors. More... | |
class | TSMatSMatKronExpr |
Expression object for sparse matrix-sparse matrix Kronecker product.The TSMatSMatKronExpr class represents the compile time expression for Kronecker products between a column-major sparse matrix and a row-major sparse matrix. More... | |
class | TSMatSMatMultExpr |
Expression object for transpose sparse matrix-sparse matrix multiplications.The TSMatSMatMultExpr class represents the compile time expression for multiplications between a column-major and a row-major sparse matrix. More... | |
class | TSMatSMatSchurExpr |
Expression object for transpose sparse matrix-sparse matrix Schur products.The TSMatSMatSchurExpr class represents the compile time expression for Schur products between a column-major sparse matrix and a row-major sparse matrix. More... | |
class | TSMatSMatSubExpr |
Expression object for transpose sparse matrix-sparse matrix subtractions.The TSMatSMatSubExpr class represents the compile time expression for subtractions between a column-major sparse matrix and a row-major sparse matrix. More... | |
class | TSMatSVecMultExpr |
Expression object for sparse matrix-sparse vector multiplications.The TSMatSVecMultExpr class represents the compile time expression for multiplications between column-major sparse matrices and sparse vectors. More... | |
class | TSMatTDMatMultExpr |
Expression object for transpose sparse matrix-transpose dense matrix multiplications.The TSMatTDMatMultExpr class represents the compile time expression for multiplications between a column-major sparse matrix and a column-major dense matrix. More... | |
class | TSMatTSMatAddExpr |
Expression object for transpose sparse matrix-transpose sparse matrix additions.The TSMatTSMatAddExpr class represents the compile time expression for additions between two column-major sparse matrices. More... | |
class | TSMatTSMatKronExpr |
Expression object for transpose sparse matrix-transpose sparse matrix Kronecker product.The TSMatTSMatKronExpr class represents the compile time expression for Kronecker products between two column-major sparse matrices. More... | |
class | TSMatTSMatMultExpr |
Expression object for transpose sparse matrix-transpose sparse matrix multiplications.The TSMatTSMatMultExpr class represents the compile time expression for multiplications between two column-major sparse matrices. More... | |
class | TSMatTSMatSchurExpr |
Expression object for transpose sparse matrix-transpose sparse matrix Schur product.The TSMatTSMatSchurExpr class represents the compile time expression for Schur products between two column-major sparse matrices. More... | |
class | TSMatTSMatSubExpr |
Expression object for transpose sparse matrix-transpose sparse matrix subtractions.The TSMatTSMatSubExpr class represents the compile time expression for subtractions between two column-major sparse matrices. More... | |
class | TSVecDMatMultExpr |
Expression object for transpose sparse vector-dense matrix multiplications.The TSVecDMatMultExpr class represents the compile time expression for multiplications between transpose sparse vectors and row-major dense matrices. More... | |
class | TSVecSMatMultExpr |
Expression object for sparse vector-sparse matrix multiplications.The TSVecSMatMultExpr class represents the compile time expression for multiplications between transpose sparse vectors and row-major sparse matrices. More... | |
class | TSVecTDMatMultExpr |
Expression object for transpose sparse vector-transpose dense matrix multiplications.The TSVecTDMatMultExpr class represents the compile time expression for multiplications between transpose sparse vectors and column-major dense matrices. More... | |
class | TSVecTSMatMultExpr |
Expression object for sparse vector-sparse matrix multiplications.The TSVecTSMatMultExpr class represents the compile time expression for multiplications between transpose sparse vectors and column-major sparse matrices. More... | |
struct | TVecMatMultExpr |
Base class for all vector/matrix multiplication expression templates.The TVecMatMultExpr class serves as a tag for all expression templates that implement a vector/matrix multiplication. All classes, that represent a vector/matrix multiplication and that are used within the expression template environment of the Blaze library have to derive 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 | TypeAt |
Indexing a type list.The TypeAt class can be used to access a type list at a specified position to query the according type. In order to index a type list, the TypeAt class has to be instantiated for a particular type list and an index value. The indexed type is available via the member type definition Type. The following example gives an impression of the use of the TypeAt class: More... | |
struct | TypeList |
Implementation of a type list.The TypeList class template represents a list of data types of arbitrary size. The following example gives an impression how type lists are used and manipulated: More... | |
struct | TypeValueMapping |
Conversion from a data type to a serial representation.This class template converts the given data type into an integral representation suited for serialization. Depending on the given data type, the value member enumeration is set to the according serial representation. More... | |
class | uint16_t |
16-bit unsigned integer type of the Blaze library. More... | |
class | uint32_t |
32-bit unsigned integer type of the Blaze library. More... | |
class | uint64_t |
64-bit unsigned integer type of the Blaze library. More... | |
class | uint8_t |
8-bit unsigned integer type of the Blaze library. More... | |
struct | UnaryMapExpr |
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 | UnderlyingBuiltin |
Evaluation of the underlying builtin element type of a given data type.This type trait evaluates the underlying fundamental element type at the heart of the given data type T. For this purpose either a nested ElementType or a nested value_type will be used. Examples: More... | |
struct | UnderlyingElement |
Evaluation of the element type of a given data type.This type trait evaluates the underlying element type of the given data type T. If the given type provides a nested type ElementType, this type is reported as underlying element type type via the nested type Type. Else if the type provides a nested value_type, this type is reported as underlying element type. Else the given type itself reported as the underlying element type. Examples: More... | |
struct | UnderlyingNumeric |
Evaluation of the underlying numeric element type of a given data type.This type trait evaluates the underlying numeric (fundamental or complex) element type at the heart of the given data type T. For this purpose either a nested ElementType or a nested value_type will be used. Examples: More... | |
class | UniformIterator |
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 | UniformMatrix |
Efficient implementation of a uniform matrix.The UniformMatrix class template is the representation of an arbitrary sized uniform matrix with elements of arbitrary type. The type of the elements and the storage order of the matrix can be specified via the two template parameters: More... | |
class | UniformVector |
Efficient implementation of a uniform vector.The UniformVector class template is the representation of an arbitrary sized uniform vector with elements of arbitrary type. The type of the elements and the transpose flag of the vector can be specified via the two template parameters: More... | |
class | UniLowerElement |
Representation of an element within a sparse lower unitriangular matrix.The UniLowerElement class represents an element (i.e. value/index pair) within a sparse lower unitriangular matrix. It guarantees that the unilower matrix invariant is not violated, i.e. that elements in the upper part of the matrix remain 0 and the diagonal elements remain 1. The following example illustrates this by means of a ![]() | |
class | UniLowerMatrix |
Matrix adapter for lower unitriangular ![]() | |
class | UniLowerProxy |
Access proxy for lower unitriangular matrices.The UniLowerProxy provides controlled access to the elements of a non-const lower unitriangular matrix. It guarantees that the unilower matrix invariant is not violated, i.e. that elements in the upper part of the matrix remain 0 and the diagonal elements remain 1. The following example illustrates this by means of a ![]() | |
class | UniLowerValue |
Representation of a value within a sparse lower unitriangular matrix.The UniLowerValue class represents a single value within a sparse lower unitriangular matrix. It guarantees that the unilower matrix invariant is not violated, i.e. that elements in the upper part of the matrix remain 0 and the diagonal elements remain 1. The following example illustrates this by means of a ![]() | |
struct | Unique |
Erasing all duplicates from a type list.The Unique class can be used to erase all duplicates from a type list TList. In order to erase all duplicates, the Unique class has to be instantiated for a particular type list. The following example gives an impression of the use of the Unique class: More... | |
class | UniUpperElement |
Representation of an element within a sparse upper unitriangular matrix.The UniUpperElement class represents an element (i.e. value/index pair) within a sparse upper unitriangular matrix. It guarantees that the uniupper matrix invariant is not violated, i.e. that elements in the lower part of the matrix remain 0 and the diagonal elements remain 1. The following example illustrates this by means of a ![]() | |
class | UniUpperMatrix |
Matrix adapter for upper unitriangular ![]() | |
class | UniUpperProxy |
Access proxy for upper unitriangular matrices.The UniUpperProxy provides controlled access to the elements of a non-const upper unitriangular matrix. It guarantees that the uniupper matrix invariant is not violated, i.e. that elements in the lower part of the matrix remain 0 and the diagonal elements remain 1. The following example illustrates this by means of a ![]() | |
class | UniUpperValue |
Representation of a value within a sparse upper unitriangular matrix.The UniUpperValue class represents a single value within a sparse upper unitriangular matrix. It guarantees that the uniupper matrix invariant is not violated, i.e. that elements in the upper part of the matrix remain 0 and the diagonal elements remain 1. The following example illustrates this by means of a ![]() | |
class | UnsignedValue |
Implementation of a wrapper for built-in unsigned integral values.This class wraps a value of built-in unsigned integral type in order to be able to extract non-negative unsigned integral values from an input stream. More... | |
class | UpperMatrix |
Matrix adapter for upper triangular ![]() | |
class | UpperProxy |
Access proxy for upper triangular matrices.The UpperProxy provides controlled access to the elements of a non-const upper triangular matrix. It guarantees that the upper matrix invariant is not violated, i.e. that elements in the lower part of the matrix remain default values. The following example illustrates this by means of a ![]() | |
class | ValueIndexPair |
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 | VecEvalExpr |
Base class for all vector evaluation expression templates.The VecEvalExpr class serves as a tag for all expression templates that implement a vector evaluation operation. All classes, that represent a vector evaluation operation and that are used within the expression template environment of the Blaze library have to derive 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 | VecExpandExpr |
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 | VecMapExpr |
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 | VecScalarDivExpr |
Base class for all vector/scalar division expression templates.The VecScalarDivExpr class serves as a tag for all expression templates that implement a vector/scalar division. All classes, that represent a vector/scalar division and that are used within the expression template environment of the Blaze library have to derive 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 | VecScalarMultExpr |
Base class for all vector/scalar multiplication expression templates.The VecScalarMultExpr class serves as a tag for all expression templates that implement a vector/scalar multiplication. All classes, that represent a vector/scalar multiplication and that are used within the expression template environment of the Blaze library have to derive 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 | VecSerialExpr |
Base class for all vector serial evaluation expression templates.The VecSerialExpr class serves as a tag for all expression templates that enforce a serial evaluation of a vector. All classes, that represent a vector serialization operation and that are used within the expression template environment of the Blaze library have to derive 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 | Vector |
Base class for N-dimensional vectors.The Vector class is a base class for all arbitrarily sized (N-dimensional) dense and sparse vector classes within the Blaze library. It provides an abstraction from the actual type of the vector, but enables a conversion back to this type via the 'Curiously Recurring Template Pattern' (CRTP). More... | |
class | VectorAccessProxy |
Access proxy for sparse, N-dimensional vectors.The VectorAccessProxy provides safe access to the elements of a non-const sparse vector. The proxied access to the elements of a sparse vector is necessary since it may be possible that several insertion operations happen in the same statement. The following code illustrates this with two examples by means of the CompressedVector class: More... | |
class | VectorSerializer |
Serializer for dense and sparse vectors.The VectorSerializer implements the necessary logic to serialize dense and sparse vectors, i.e. to convert them into a portable, binary representation. The following example demonstrates the (de-)serialization process of vectors: More... | |
struct | VecTransExpr |
Base class for all vector transposition expression templates.The VecTransExpr class serves as a tag for all expression templates that implement a vector transposition operation. All classes, that represent a vector transposition operation and that are used within the expression template environment of the Blaze library have to derive 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 | VecTVecMultExpr |
Base class for all outer product expression templates.The VecTVecMultExpr class serves as a tag for all expression templates that implement mathematical outer products (i.e. multiplications between a column vector and a row vector). All classes, that represent a mathematical outer product and that are used within the expression template environment of the Blaze library have to derive 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 | VecVecAddExpr |
Base class for all vector/vector addition expression templates.The VecVecAddExpr class serves as a tag for all expression templates that implement a vector/vector addition. All classes, that represent a vector addition and that are used within the expression template environment of the Blaze library have to derive 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 | VecVecDivExpr |
Base class for all vector/vector division expression templates.The VecVecDivExpr class serves as a tag for all expression templates that implement a vector/vector division. All classes, that represent a vector division and that are used within the expression template environment of the Blaze library have to derive 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 | VecVecKronExpr |
Base class for all vector/vector Kronecker expression templates.The VecVecKronExpr class serves as a tag for all expression templates that implement a vector/vector Kronecker product. All classes, that represent a vector Kronecker 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 vector Kronecker product expression template. Only in case a class is derived publicly from the VecVecKronExpr base class, the IsVecVecKronExpr type trait recognizes the class as valid vector Kronecker product expression template. More... | |
struct | VecVecMapExpr |
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 | VecVecMultExpr |
Base class for all vector/vector multiplication expression templates.The VecVecMultExpr class serves as a tag for all expression templates that implement a vector/vector multiplication. All classes, that represent a vector multiplication and that are used within the expression template environment of the Blaze library have to derive 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 | VecVecSubExpr |
Base class for all vector/vector subtraction expression templates.The VecVecSubExpr class serves as a tag for all expression templates that implement a vector/vector subtraction. All classes, that represent a vector subtraction and that are used within the expression template environment of the Blaze library have to derive 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 | View |
Base class for all views.The View class serves as a tag for all views (subvectors, submatrices, rows, columns, ...). All classes that represent a view and that are used within the expression template environment of the Blaze library have to derive 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... | |
struct | XorAssign |
Generic wrapper for bitwise XOR assignment. More... | |
struct | YieldsDiagonal |
Compile time check for operations on matrices.This type trait tests whether or not the given operation OP yields a diagonal matrix when applied to several matrices of types MT and MTs. In case the operation yields a diagonal matrix, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | YieldsHermitian |
Compile time check for operations on matrices.This type trait tests whether or not the given operation OP yields a Hermitian matrix when applied to several matrices of types MT and MTs. In case the operation yields a Hermitian matrix, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | YieldsIdentity |
Compile time check for operations on matrices.This type trait tests whether or not the given operation OP yields an identity matrix when applied to several matrices of types MT and MTs. In case the operation yields an identity matrix, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | YieldsLower |
Compile time check for operations on matrices.This type trait tests whether or not the given operation OP yields a lower matrix when applied to several matrices of types MT and MTs. In case the operation yields a lower matrix, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | YieldsStrictlyLower |
Compile time check for operations on matrices.This type trait tests whether or not the given operation OP yields a strictly lower matrix when applied to several matrices of types MT and MTs. In case the operation yields a strictly lower matrix, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | YieldsStrictlyTriangular |
Compile time check for operations on matrices.This type trait tests whether or not the given operation OP yields a lower or upper strictly triangular matrix when applied to several matrices of types MT and MTs. In case the operation yields a strictly triangular matrix, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | YieldsStrictlyUpper |
Compile time check for operations on matrices.This type trait tests whether or not the given operation OP yields a strictly upper matrix when applied to several matrices of types MT and MTs. In case the operation yields a strictly upper matrix, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | YieldsSymmetric |
Compile time check for operations on matrices.This type trait tests whether or not the given operation OP yields a symmetric matrix when applied to several matrices of types MT and MTs. In case the operation yields a symmetric matrix, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | YieldsTriangular |
Compile time check for operations on matrices.This type trait tests whether or not the given operation OP yields a lower or upper triangular matrix when applied to several matrices of types MT and MTs. In case the operation yields a triangular matrix, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | YieldsUniform |
Compile time check for operations on vectors and matrices.This type trait tests whether or not the given operation OP yields a uniform vector or matrix when applied to several vectors or matrices of types T and Ts. In case the operation yields a uniform vector or matrix, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | YieldsUniLower |
Compile time check for operations on matrices.This type trait tests whether or not the given operation OP yields an unilower matrix when applied to several matrices of types MT and MTs. In case the operation yields an unilower matrix, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | YieldsUniTriangular |
Compile time check for operations on matrices.This type trait tests whether or not the given operation OP yields a lower or upper unitriangular matrix when applied to several matrices of types MT and MTs. In case the operation yields an unitriangular matrix, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | YieldsUniUpper |
Compile time check for operations on matrices.This type trait tests whether or not the given operation OP yields an uniupper matrix when applied to several matrices of types MT and MTs. In case the operation yields an uniupper matrix, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | YieldsUpper |
Compile time check for operations on matrices.This type trait tests whether or not the given operation OP yields an upper matrix when applied to several matrices of types MT and MTs. In case the operation yields an upper matrix, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
struct | YieldsZero |
Compile time check for operations on vectors and matrices.This type trait tests whether or not the given operation OP yields a zero vector or zero matrix when applied to several vectors or matrices of types T and Ts. In case the operation yields a zero vector or matrix, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More... | |
class | ZeroMatrix |
Efficient implementation of an ![]() ![]() | |
class | ZeroVector |
Efficient implementation of an arbitrary sized zero vector.The ZeroVector class template is the representation of an immutable, arbitrary sized zero vector with N elements of arbitrary type. The type of the elements and the transpose flag of the vector can be specified via the two template parameters: More... | |
Typedefs | |
template<typename T > | |
using | BaseType_t = typename T::BaseType |
Alias declaration for nested BaseType type definitions.The BaseType_t alias declaration provides a convenient shortcut to access the nested BaseType type definition of the given type T. The following code example shows both ways to access the nested type definition: More... | |
template<typename T > | |
using | CompositeType_t = typename T::CompositeType |
Alias declaration for nested CompositeType type definitions.The CompositeType_t alias declaration provides a convenient shortcut to access the nested CompositeType type definition of the given type T. The following code example shows both ways to access the nested type definition: More... | |
template<typename T > | |
using | ConstIterator_t = typename T::ConstIterator |
Alias declaration for nested ConstIterator type definitions.The ConstIterator_t alias declaration provides a convenient shortcut to access the nested ConstIterator type definition of the given type T. The following code example shows both ways to access the nested type definition: More... | |
template<typename T > | |
using | ConstPointer_t = typename T::ConstPointer |
Alias declaration for nested ConstPointer type definitions.The ConstPointer_t alias declaration provides a convenient shortcut to access the nested ConstPointer type definition of the given type T. The following code example shows both ways to access the nested type definition: More... | |
template<typename T > | |
using | ConstReference_t = typename T::ConstReference |
Alias declaration for nested ConstReference type definitions.The ConstReference_t alias declaration provides a convenient shortcut to access the nested ConstReference type definition of the given type T. The following code example shows both ways to access the nested type definition: More... | |
template<typename T > | |
using | ElementType_t = typename T::ElementType |
Alias declaration for nested ElementType type definitions.The ElementType_t alias declaration provides a convenient shortcut to access the nested ElementType type definition of the given type T. The following code example shows both ways to access the nested type definition: More... | |
template<typename T > | |
using | Iterator_t = typename T::Iterator |
Alias declaration for nested Iterator type definitions.The Iterator_t alias declaration provides a convenient shortcut to access the nested Iterator type definition of the given type T. The following code example shows both ways to access the nested type definition: More... | |
template<typename T > | |
using | LeftOperand_t = typename T::LeftOperand |
Alias declaration for nested LeftOperand type definitions.The LeftOperand_t alias declaration provides a convenient shortcut to access the nested LeftOperand type definition of the given type T. The following code example shows both ways to access the nested type definition: More... | |
template<typename T > | |
using | MatrixType_t = typename T::MatrixType |
Alias declaration for nested MatrixType type definitions.The MatrixType_t alias declaration provides a convenient shortcut to access the nested MatrixType type definition of the given type T. The following code example shows both ways to access the nested type definition: More... | |
template<typename T > | |
using | Operand_t = typename T::Operand |
Alias declaration for nested Operand type definitions.The Operand_t alias declaration provides a convenient shortcut to access the nested Operand type definition of the given type T. The following code example shows both ways to access the nested type definition: More... | |
template<typename T > | |
using | OppositeType_t = typename T::OppositeType |
Alias declaration for nested OppositeType type definitions.The OppositeType_t alias declaration provides a convenient shortcut to access the nested OppositeType type definition of the given type T. The following code example shows both ways to access the nested type definition: More... | |
template<typename T > | |
using | Pointer_t = typename T::Pointer |
Alias declaration for nested Pointer type definitions.The Pointer_t alias declaration provides a convenient shortcut to access the nested Pointer type definition of the given type T. The following code example shows both ways to access the nested type definition: More... | |
template<typename T1 , typename T2 > | |
using | Rebind_t = typename T1::template Rebind< T2 >::Other |
Alias declaration for nested Rebind class templates.The Rebind_t alias declaration provides a convenient shortcut to access the nested Rebind class template of the given type T1. The following code example shows both ways to access the nested class template: More... | |
template<typename T > | |
using | Reference_t = typename T::Reference |
Alias declaration for nested Reference type definitions.The Reference_t alias declaration provides a convenient shortcut to access the nested Reference type definition of the given type T. The following code example shows both ways to access the nested type definition: More... | |
template<typename T > | |
using | RepresentedType_t = typename T::RepresentedType |
Alias declaration for nested RepresentedType type definitions.The RepresentedType_t alias declaration provides a convenient shortcut to access the nested RepresentedType type definition of the given type T. The following code example shows both ways to access the nested type definition: More... | |
template<typename T , size_t... Ns> | |
using | Resize_t = typename T::template Resize< Ns... >::Other |
Alias declaration for nested Resize class templates.The Resize_t alias declaration provides a convenient shortcut to access the nested Resize class template of the given type T1. The following code example shows both ways to access the nested class template: More... | |
template<typename T > | |
using | ResultType_t = typename T::ResultType |
Alias declaration for nested ResultType type definitions.The ResultType_t alias declaration provides a convenient shortcut to access the nested ResultType type definition of the given type T. The following code example shows both ways to access the nested type definition: More... | |
template<typename T > | |
using | ReturnType_t = typename T::ReturnType |
Alias declaration for nested ReturnType type definitions.The ReturnType_t alias declaration provides a convenient shortcut to access the nested ReturnType type definition of the given type T. The following code example shows both ways to access the nested type definition: More... | |
template<typename T > | |
using | RightOperand_t = typename T::RightOperand |
Alias declaration for nested RightOperand type definitions.The RightOperand_t alias declaration provides a convenient shortcut to access the nested RightOperand type definition of the given type T. The following code example shows both ways to access the nested type definition: More... | |
template<typename T > | |
using | SIMDType_t = typename T::SIMDType |
Alias declaration for nested SIMDType type definitions.The SIMDType_t alias declaration provides a convenient shortcut to access the nested SIMDType type definition of the given type T. The following code example shows both ways to access the nested type definition: More... | |
template<typename T > | |
using | TransposeType_t = typename T::TransposeType |
Alias declaration for nested TransposeType type definitions.The TransposeType_t alias declaration provides a convenient shortcut to access the nested TransposeType type definition of the given type T. The following code example shows both ways to access the nested type definition: More... | |
template<typename T > | |
using | ValueType_t = typename T::ValueType |
Alias declaration for nested ValueType type definitions.The ValueType_t alias declaration provides a convenient shortcut to access the nested ValueType type definition of the given type T. The following code example shows both ways to access the nested type definition: More... | |
template<typename T > | |
using | VectorType_t = typename T::VectorType |
Alias declaration for nested VectorType type definitions.The VectorType_t alias declaration provides a convenient shortcut to access the nested VectorType type definition of the given type T. The following code example shows both ways to access the nested type definition: More... | |
template<typename T > | |
using | ViewedType_t = typename T::ViewedType |
Alias declaration for nested ViewedType type definitions.The ViewedType_t alias declaration provides a convenient shortcut to access the nested ViewedType type definition of the given type T. The following code example shows both ways to access the nested type definition: More... | |
template<size_t Offset, size_t N> | |
using | 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 | 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 | SIMDchar = SIMDTrait< char >::Type |
The SIMD data type for 'char'. | |
using | SIMDschar = SIMDTrait< signed char >::Type |
The SIMD data type for 'signed char'. | |
using | SIMDuchar = SIMDTrait< unsigned char >::Type |
The SIMD data type for 'unsigned char'. | |
using | SIMDwchar = SIMDTrait< wchar_t >::Type |
The SIMD data type for 'wchar_t'. | |
using | SIMDcchar = SIMDTrait< complex< char > >::Type |
The SIMD data type for 'complex<char>'. | |
using | SIMDcschar = SIMDTrait< complex< signed char > >::Type |
The SIMD data type for 'complex<signed char>'. | |
using | SIMDcuchar = SIMDTrait< complex< unsigned char > >::Type |
The SIMD data type for 'complex<unsigned char>'. | |
using | SIMDcwchar = SIMDTrait< complex< wchar_t > >::Type |
The SIMD data type for 'complex<wchar_t>'. | |
using | SIMDshort = SIMDTrait< short >::Type |
The SIMD data type for 'short'. | |
using | SIMDushort = SIMDTrait< unsigned short >::Type |
The SIMD data type for 'unsigned short'. | |
using | SIMDcshort = SIMDTrait< complex< short > >::Type |
The SIMD data type for 'complex<short>'. | |
using | SIMDcushort = SIMDTrait< complex< unsigned short > >::Type |
The SIMD data type for 'complex<unsigned short>'. | |
using | SIMDint = SIMDTrait< int >::Type |
The SIMD data type for 'int'. | |
using | SIMDuint = SIMDTrait< unsigned int >::Type |
The SIMD data type for 'unsigned int'. | |
using | SIMDcint = SIMDTrait< complex< int > >::Type |
The SIMD data type for 'complex<int>'. | |
using | SIMDcuint = SIMDTrait< complex< unsigned int > >::Type |
The SIMD data type for 'complex<unsigned int>'. | |
using | SIMDlong = SIMDTrait< long >::Type |
The SIMD data type for 'long int'. | |
using | SIMDulong = SIMDTrait< unsigned long >::Type |
The SIMD data type for 'unsigned long int'. | |
using | SIMDclong = SIMDTrait< complex< long > >::Type |
The SIMD data type for 'complex<long int>'. | |
using | SIMDculong = SIMDTrait< complex< unsigned long > >::Type |
The SIMD data type for 'complex<unsigned long int>'. | |
template<typename T > | |
using | SIMDTrait_t = typename SIMDTrait< T >::Type |
Auxiliary alias declaration for the SIMDTrait class template.The SIMDTrait_t alias declaration provides a convenient shortcut to access the nested Type of the SIMDTrait class template. For instance, given the type T the following two type definitions are identical: More... | |
template<typename T1 , typename T2 > | |
using | AddTrait_t = typename AddTrait< T1, T2 >::Type |
Auxiliary alias declaration for the AddTrait class template.The AddTrait_t alias declaration provides a convenient shortcut to access the nested Type of the AddTrait class template. For instance, given the types T1 and T2 the following two type definitions are identical: More... | |
template<typename MT , ptrdiff_t... CBAs> | |
using | BandTrait_t = typename BandTrait< MT, CBAs... >::Type |
Auxiliary alias declaration for the BandTrait type trait.The BandTrait_t alias declaration provides a convenient shortcut to access the nested Type of the BandTrait class template. For instance, given the matrix type MT the following two type definitions are identical: More... | |
template<typename MT , size_t N> | |
using | ColumnsTrait_t = typename ColumnsTrait< MT, N >::Type |
Auxiliary alias declaration for the ColumnsTrait type trait.The ColumnsTrait_t alias declaration provides a convenient shortcut to access the nested Type of the ColumnsTrait class template. For instance, given the matrix type MT the following two type definitions are identical: More... | |
template<typename MT , size_t... CCAs> | |
using | ColumnTrait_t = typename ColumnTrait< MT, CCAs... >::Type |
Auxiliary alias declaration for the ColumnTrait type trait.The ColumnTrait_t alias declaration provides a convenient shortcut to access the nested Type of the ColumnTrait class template. For instance, given the matrix type MT the following two type definitions are identical: More... | |
template<typename T1 , typename T2 > | |
using | CrossTrait_t = typename CrossTrait< T1, T2 >::Type |
Auxiliary alias declaration for the CrossTrait class template.The CrossTrait_t alias declaration provides a convenient shortcut to access the nested Type of the CrossTrait class template. For instance, given the types T1 and T2 the following two type definitions are identical: More... | |
template<typename MT > | |
using | DeclDiagTrait_t = typename DeclDiagTrait< MT >::Type |
Auxiliary alias declaration for the DeclDiagTrait type trait.The DeclDiagTrait_t alias declaration provides a convenient shortcut to access the nested Type of the DeclDiagTrait class template. For instance, given the matrix type MT the following two type definitions are identical: More... | |
template<typename MT > | |
using | DeclHermTrait_t = typename DeclHermTrait< MT >::Type |
Auxiliary alias declaration for the DeclHermTrait type trait.The DeclHermTrait_t alias declaration provides a convenient shortcut to access the nested Type of the DeclHermTrait class template. For instance, given the matrix type MT the following two type definitions are identical: More... | |
template<typename MT > | |
using | DeclIdTrait_t = typename DeclIdTrait< MT >::Type |
Auxiliary alias declaration for the DeclIdTrait type trait.The DeclIdTrait_t alias declaration provides a convenient shortcut to access the nested Type of the DeclIdTrait class template. For instance, given the matrix type MT the following two type definitions are identical: More... | |
template<typename MT > | |
using | DeclLowTrait_t = typename DeclLowTrait< MT >::Type |
Auxiliary alias declaration for the DeclLowTrait type trait.The DeclLowTrait_t alias declaration provides a convenient shortcut to access the nested Type of the DeclLowTrait class template. For instance, given the matrix type MT the following two type definitions are identical: More... | |
template<typename MT > | |
using | DeclSymTrait_t = typename DeclSymTrait< MT >::Type |
Auxiliary alias declaration for the DeclSymTrait type trait.The DeclSymTrait_t alias declaration provides a convenient shortcut to access the nested Type of the DeclSymTrait class template. For instance, given the matrix type MT the following two type definitions are identical: More... | |
template<typename MT > | |
using | DeclUppTrait_t = typename DeclUppTrait< MT >::Type |
Auxiliary alias declaration for the DeclUppTrait type trait.The DeclUppTrait_t alias declaration provides a convenient shortcut to access the nested Type of the DeclUppTrait class template. For instance, given the matrix type MT the following two type definitions are identical: More... | |
template<typename T > | |
using | DeclZeroTrait_t = typename DeclZeroTrait< T >::Type |
Auxiliary alias declaration for the DeclZeroTrait type trait.The DeclZeroTrait_t alias declaration provides a convenient shortcut to access the nested Type of the DeclZeroTrait class template. For instance, given the vector or matrix type T the following two type definitions are identical: More... | |
template<typename T > | |
using | DerestrictTrait_t = typename DerestrictTrait< T >::Type |
Auxiliary alias declaration for the DerestrictTrait type trait.The DerestrictTrait_t alias declaration provides a convenient shortcut to access the nested Type of the DerestrictTrait class template. For instance, given the type T the following two type definitions are identical: More... | |
template<typename T1 , typename T2 > | |
using | DivTrait_t = typename DivTrait< T1, T2 >::Type |
Auxiliary alias declaration for the DivTrait class template.The DivTrait_t alias declaration provides a convenient shortcut to access the nested Type of the DivTrait class template. For instance, given the types T1 and T2 the following two type definitions are identical: More... | |
template<typename VT , size_t N> | |
using | ElementsTrait_t = typename ElementsTrait< VT, N >::Type |
Auxiliary alias declaration for the ElementsTrait type trait.The ElementsTrait_t alias declaration provides a convenient shortcut to access the nested Type of the ElementsTrait class template. For instance, given the vector type VT the following two type definitions are identical: More... | |
template<typename T , size_t... CEAs> | |
using | ExpandTrait_t = typename ExpandTrait< T, CEAs... >::Type |
Auxiliary alias declaration for the ExpandTrait type trait.The ExpandTrait_t alias declaration provides a convenient shortcut to access the nested Type of the ExpandTrait class template. For instance, given the matrix type MT the following two type definitions are identical: More... | |
template<typename T1 , typename T2 > | |
using | KronTrait_t = typename KronTrait< T1, T2 >::Type |
Auxiliary alias declaration for the KronTrait class template.The KronTrait_t alias declaration provides a convenient shortcut to access the nested Type of the KronTrait class template. For instance, given the types T1 and T2 the following two type definitions are identical: More... | |
template<typename... Args> | |
using | MapTrait_t = typename MapTrait< Args... >::Type |
Auxiliary alias declaration for the MapTrait class template.The MapTrait_t alias declaration provides a convenient shortcut to access the nested Type of the MapTrait class template. For instance, given the type T and the custom operation type OP the following two type definitions are identical: More... | |
template<typename T1 , typename T2 > | |
using | MultTrait_t = typename MultTrait< T1, T2 >::Type |
Auxiliary alias declaration for the MultTrait class template.The MultTrait_t alias declaration provides a convenient shortcut to access the nested Type of the MultTrait class template. For instance, given the types T1 and T2 the following two type definitions are identical: More... | |
template<typename T , typename OP , size_t... RF> | |
using | ReduceTrait_t = typename ReduceTrait< T, OP, RF... >::Type |
Auxiliary alias declaration for the ReduceTrait class template.The ReduceTrait_t alias declaration provides a convenient shortcut to access the nested Type of the ReduceTrait class template. For instance, given the type T and the custom operation type OP the following two type definitions are identical: More... | |
template<typename MT , size_t M> | |
using | RowsTrait_t = typename RowsTrait< MT, M >::Type |
Auxiliary alias declaration for the RowsTrait type trait.The RowsTrait_t alias declaration provides a convenient shortcut to access the nested Type of the RowsTrait class template. For instance, given the matrix type MT the following two type definitions are identical: More... | |
template<typename MT , size_t... CRAs> | |
using | RowTrait_t = typename RowTrait< MT, CRAs... >::Type |
Auxiliary alias declaration for the RowTrait type trait.The RowTrait_t alias declaration provides a convenient shortcut to access the nested Type of the RowTrait class template. For instance, given the matrix type MT the following two type definitions are identical: More... | |
template<typename T1 , typename T2 > | |
using | SchurTrait_t = typename SchurTrait< T1, T2 >::Type |
Auxiliary alias declaration for the SchurTrait class template.The SchurTrait_t alias declaration provides a convenient shortcut to access the nested Type of the SchurTrait class template. For instance, given the types T1 and T2 the following two type definitions are identical: More... | |
template<typename MT , size_t... CSAs> | |
using | SubmatrixTrait_t = typename SubmatrixTrait< MT, CSAs... >::Type |
Auxiliary alias declaration for the SubmatrixTrait type trait.The SubmatrixTrait_t alias declaration provides a convenient shortcut to access the nested Type of the SubmatrixTrait class template. For instance, given the matrix type MT the following two type definitions are identical: More... | |
template<typename T1 , typename T2 > | |
using | SubTrait_t = typename SubTrait< T1, T2 >::Type |
Auxiliary alias declaration for the SubTrait class template.The SubTrait_t alias declaration provides a convenient shortcut to access the nested Type of the SubTrait class template. For instance, given the types T1 and T2 the following two type definitions are identical: More... | |
template<typename VT , size_t... CSAs> | |
using | SubvectorTrait_t = typename SubvectorTrait< VT, CSAs... >::Type |
Auxiliary alias declaration for the SubvectorTrait type trait.The SubvectorTrait_t alias declaration provides a convenient shortcut to access the nested Type of the SubvectorTrait class template. For instance, given the vector type VT the following two type definitions are identical: More... | |
template<typename T1 , typename T2 > | |
using | HighType_t = typename HighType< T1, T2 >::Type |
Auxiliary alias declaration for the HighType type trait.The HighType_t alias declaration provides a convenient shortcut to access the nested Type of the HighType class template. For instance, given the types T1 and T2 the following two type definitions are identical: More... | |
template<typename T1 , typename T2 > | |
using | LowType_t = typename LowType< T1, T2 >::Type |
Auxiliary alias declaration for the LowType type trait.The LowType_t alias declaration provides a convenient shortcut to access the nested Type of the LowType class template. For instance, given the types T1 and T2 the following two type definitions are identical: More... | |
using | DefaultMaxSize = Ptrdiff_t< DefaultMaxSize_v > |
Type representation of the default size of the MaxSize type trait. | |
template<typename T > | |
using | RemoveAdaptor_t = typename RemoveAdaptor< T >::Type |
Auxiliary alias declaration for the RemoveAdaptor type trait.The RemoveAdaptor_t alias declaration provides a convenient shortcut to access the nested Type of the RemoveAdaptor class template. For instance, given the type T the following two type definitions are identical: More... | |
using | DefaultSize = Ptrdiff_t< DefaultSize_v > |
Type representation of the default size of the Size type trait. | |
template<typename T > | |
using | UnderlyingBuiltin_t = typename UnderlyingBuiltin< T >::Type |
Auxiliary alias declaration for the UnderlyingBuiltin type trait.The UnderlyingBuiltin_t alias declaration provides a convenient shortcut to access the nested Type of the UnderlyingBuiltin class template. For instance, given the type T the following two type definitions are identical: More... | |
template<typename T > | |
using | UnderlyingElement_t = typename UnderlyingElement< T >::Type |
Auxiliary alias declaration for the UnderlyingElement type trait.The UnderlyingElement_t alias declaration provides a convenient shortcut to access the nested Type of the UnderlyingElement class template. For instance, given the type T the following two type definitions are identical: More... | |
template<typename T > | |
using | UnderlyingNumeric_t = typename UnderlyingNumeric< T >::Type |
Auxiliary alias declaration for the UnderlyingNumeric type trait.The UnderlyingNumeric_t alias declaration provides a convenient shortcut to access the nested Type of the UnderlyingNumeric class template. For instance, given the type T the following two type definitions are identical: More... | |
using | 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 | 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, ...). | |
template<bool Condition, typename T = void> | |
using | DisableIf_t = typename DisableIf< Condition, T >::Type |
Auxiliary type for the DisableIf class template.The DisableIf_t alias declaration provides a convenient shortcut to access the nested Type of the DisableIf class template. For instance, given the type T the following two type definitions are identical: More... | |
template<bool Condition, typename T = void> | |
using | EnableIf_t = typename EnableIf< Condition, T >::Type |
Auxiliary type for the EnableIf class template.The EnableIf_t alias declaration provides a convenient shortcut to access the nested Type of the EnableIf class template. For instance, given the type T the following two type definitions are identical: More... | |
template<bool B> | |
using | BoolConstant = IntegralConstant< bool, B > |
Generic wrapper for a compile time constant boolean value.The BoolConstant alias template represents a generic wrapper for a compile time constant boolean value. The value of a BoolConstant can be accessed via the nested value (which is guaranteed to be of type bool ), the type can be accessed via the nested type definition ValueType. More... | |
using | FalseType = BoolConstant< false > |
Type/value traits base class.The FalseType class is used as base class for type traits and value traits that evaluate to false. | |
using | TrueType = BoolConstant< true > |
Type traits base class.The TrueType class is used as base class for type traits and value traits that evaluate to true. | |
template<bool B> | |
using | Bool_t = IntegralConstant< bool, B > |
Compile time integral constant wrapper for bool.The Bool_t alias template represents an integral wrapper for a compile time constant expression of type bool. The value of a Bool_t can be accessed via the nested value (which is guaranteed to be of type bool), the type can be accessed via the nested type definition ValueType. More... | |
template<char N> | |
using | Char_t = IntegralConstant< char, N > |
Compile time integral constant wrapper for char.The Char_t alias template represents an integral wrapper for a compile time constant expression of type char. The value of an Char_t can be accessed via the nested value (which is guaranteed to be of type char), the type can be accessed via the nested type definition ValueType. More... | |
template<int N> | |
using | Int_t = IntegralConstant< int, N > |
Compile time integral constant wrapper for int.The Int_t alias template represents an integral wrapper for a compile time constant expression of type int. The value of an Int_t can be accessed via the nested value (which is guaranteed to be of type int), the type can be accessed via the nested type definition ValueType. More... | |
template<long N> | |
using | Long_t = IntegralConstant< long, N > |
Compile time integral constant wrapper for long.The Long_t alias template represents an integral wrapper for a compile time constant expression of type long. The value of an Long_t can be accessed via the nested value (which is guaranteed to be of type long), the type can be accessed via the nested type definition ValueType. More... | |
template<ptrdiff_t N> | |
using | Ptrdiff_t = IntegralConstant< ptrdiff_t, N > |
Compile time integral constant wrapper for ptrdiff_t.The Ptrdiff_t alias template represents an integral wrapper for a compile time constant expression of type ptrdiff_t. The value of an Ptrdiff_t can be accessed via the nested value (which is guaranteed to be of type ptrdiff_t), the type can be accessed via the nested type definition ValueType. More... | |
template<size_t N> | |
using | Size_t = IntegralConstant< size_t, N > |
Compile time integral constant wrapper for size_t.The Size_t alias template represents an integral wrapper for a compile time constant expression of type size_t. The value of an Size_t can be accessed via the nested value (which is guaranteed to be of type size_t), the type can be accessed via the nested type definition ValueType. More... | |
template<typename T1 , typename T2 , typename... Ts> | |
using | And_t = Bool_t< IsSame< Bools< true, T1::value, T2::value,(Ts::value)... >, Bools< T1::value, T2::value,(Ts::value)..., true > >::value > |
Compile time logical AND evaluation.The And_t alias template performs at compile time a logical AND ('&&') evaluation of at least two compile time conditions: More... | |
template<typename T1 , typename T2 > | |
using | Equal_t = Bool_t<(T1::value==T2::value) > |
Compile time type comparison.The Equal_t alias template compares the two given types using the equality operator ('=='). In case T1::value is equal to T2::value, the nested value member is set to true. Otherwise it is set to false. More... | |
template<typename T1 , typename T2 > | |
using | Greater_t = Bool_t<(T1::value > T2::value) > |
Compile time type comparison.The Greater_t alias template compares the two given types using the greater-than operator ('>'). In case T1::value is greater than T2::value, the nested value member is set to 1. Otherwise it is set to 0. More... | |
template<bool Condition, typename T1 , typename T2 > | |
using | If_t = typename If< Condition, T1, T2 >::Type |
Auxiliary alias template for the If class template.The If_t alias template provides a convenient shortcut to access the nested Type of the If class template. For instance, given the types C, T1, and T2 the following two type definitions are identical: More... | |
template<typename T1 , typename T2 > | |
using | Less_t = Bool_t<(T1::value< T2::value) > |
Compile time type comparison.The Less_t alias template compares the two given types using the less-than operator ('<'). In case T1::value is less than T2::value, the nested value member is set to 1. Otherwise it is set to 0. More... | |
template<typename T1 , typename T2 > | |
using | Max_t = If_t< Less_t< T1, T2 >::value, T2, T1 > |
Compile time value evaluation.The Max_t alias template selects the larger of the two given template arguments T1 and T2. In order for Max_t to be able to determine the larger type, both arguments are required to have a nested member value. The result of the minimum operation can be accessed via the nested member value, the resulting type is available via the nested type ValueType. More... | |
template<typename T1 , typename T2 > | |
using | Min_t = If_t< Less_t< T1, T2 >::value, T1, T2 > |
Compile time value evaluation.The Min_t alias template selects the smaller of the two given template arguments T1 and T2. In order for Min_t to be able to determine the smaller type, both arguments are required to have a nested member value. The result of the minimum operation can be accessed via the nested member value, the resulting type is available via the nested type ValueType. More... | |
template<typename T1 , typename T2 > | |
using | Minus_t = IntegralConstant< CommonType_t< typename T1::ValueType, typename T2::ValueType >,(T1::value - T2::value) > |
Compile time integral subtraction.The Minus_t alias template returns the difference of the two given template arguments T1 and T2. In order for Minus_t to be able to subtract the two types, both arguments are required to have a nested member value. The result of the subtraction can be accessed via the nested member value, the resulting type is available via the nested type ValueType. More... | |
template<typename T1 , typename T2 > | |
using | Modulo_t = IntegralConstant< CommonType_t< typename T1::ValueType, typename T2::ValueType >,(T1::value % T2::value) > |
Compile time integral modulo operation.The Modulo_t alias template returns the result of a modulo operation between the two given template arguments T1 and T2. In order for Modulo_t to be able to perform the operation with the given two types, both arguments are required to have a nested member value. The result of the modulo operation can be accessed via the nested member value, the resulting type is available via the nested type ValueType. More... | |
template<typename T1 , typename T2 , typename... Ts> | |
using | Nand_t = Bool_t< !IsSame< Bools< true, T1::value, T2::value,(Ts::value)... >, Bools< T1::value, T2::value,(Ts::value)..., true > >::value > |
Compile time logical NAND evaluation.The Nand_t alias template performs at compile time a logical NAND evaluation of at least two compile time conditions: More... | |
template<typename T1 , typename T2 , typename... Ts> | |
using | Nor_t = Bool_t< IsSame< Bools< false, T1::value, T2::value,(Ts::value)... >, Bools< T1::value, T2::value,(Ts::value)..., false > >::value > |
Compile time logical 'not or' evaluation.The Nor_t alias template performs at compile time a logical 'not or' evaluation of at least two compile time conditions: More... | |
template<typename C > | |
using | Not_t = Bool_t< !C::value > |
Compile time type negation.The Not_t alias template negates the given compile time condition. In case the given condition would evaluate to true, the nested member enumeration is set to false and vice versa: More... | |
template<typename T1 , typename T2 , typename... Ts> | |
using | Or_t = Bool_t< !IsSame< Bools< false, T1::value, T2::value,(Ts::value)... >, Bools< T1::value, T2::value,(Ts::value)..., false > >::value > |
Compile time logical OR evaluation.The Or_t alias template performs at compile time a logical OR ('||') evaluation of at least two compile time conditions: More... | |
template<typename T1 , typename T2 > | |
using | Plus_t = IntegralConstant< CommonType_t< typename T1::ValueType, typename T2::ValueType >,(T1::value+T2::value) > |
Compile time integral addition.The Plus_t alias template returns the sum of the two given template arguments T1 and T2. In order for Plus_t to be able to add the two types, both arguments are required to have a nested member value. The result of the addition can be accessed via the nested member value, the resulting type is available via the nested type ValueType. More... | |
template<typename T1 , typename T2 > | |
using | Times_t = IntegralConstant< CommonType_t< typename T1::ValueType, typename T2::ValueType >,(T1::value *T2::value) > |
Compile time integral multiplication.The Times_t alias template returns the product of the two given template arguments T1 and T2. In order for Times_t to be able to multiply the two types, both arguments are required to have a nested member value. The result of the multiplication can be accessed via the nested member value, the resulting type is available via the nested type ValueType. More... | |
template<typename T1 , typename T2 > | |
using | Xor_t = Bool_t<(T1::value ^ T2::value) > |
Compile time bitwise XOR evaluation.The Xor_t alias template performs at compile time a bitwise XOR evaluation of the two given compile time conditions: More... | |
template<typename TL , typename T > | |
using | Append_t = typename Append< TL, T >::Type |
Auxiliary alias declaration for the Append class template.The Append_t alias declaration provides a convenient shortcut to access the nested Type of the Append class template. For instance, given the type list TL and the type T the following two type definitions are identical: More... | |
template<typename TL , typename T > | |
using | Erase_t = typename Erase< TL, T >::Type |
Auxiliary alias declaration for the Erase class template.The Erase_t alias declaration provides a convenient shortcut to access the nested Type of the Erase class template. For instance, given the type list TL and the type T the following two type definitions are identical: More... | |
template<typename TL , typename T > | |
using | EraseAll_t = typename EraseAll< TL, T >::Type |
Auxiliary alias declaration for the EraseAll class template.The EraseAll_t alias declaration provides a convenient shortcut to access the nested Type of the EraseAll class template. For instance, given the type list TL and the type T the following two type definitions are identical: More... | |
template<typename TL , size_t Index> | |
using | TypeAt_t = typename TypeAt< TL, Index >::Type |
Auxiliary alias declaration for the TypeAt class template.The TypeAt_t alias declaration provides a convenient shortcut to access the nested Type of the TypeAt class template. For instance, given the type list TL and the index Index the following two type definitions are identical: More... | |
template<typename TL > | |
using | Unique_t = typename Unique< TL >::Type |
Auxiliary alias declaration for the Unique class template.The Unique_t alias declaration provides a convenient shortcut to access the nested Type of the Unique class template. For instance, given the type list TL the following two type definitions are identical: More... | |
using | byte_t = unsigned char |
Byte data type of the Blaze library.The byte data type is guaranteed to be an integral data type of size 1. | |
using | large_t = int64_t |
The largest available signed integer data type. | |
using | ularge_t = uint64_t |
The largest available unsigned integer data type. | |
using | id_t = ularge_t |
Unsigned integer data type for integral IDs. | |
using | fortran_charlen_t = size_t |
Type of the hidden arguments of character type within a Fortran forward declaration. | |
template<typename T > | |
using | AddConst_t = typename AddConst< T >::Type |
Auxiliary alias declaration for the AddConst type trait.The AddConst_t alias declaration provides a convenient shortcut to access the nested Type of the AddConst class template. For instance, given the type T the following two type definitions are identical: More... | |
template<typename T > | |
using | AddCV_t = typename AddCV< T >::Type |
Auxiliary alias declaration for the AddCV type trait.The AddCV_t alias declaration provides a convenient shortcut to access the nested Type of the AddCV class template. For instance, given the type T the following two type definitions are identical: More... | |
template<typename T > | |
using | AddPointer_t = typename AddPointer< T >::Type |
Auxiliary alias declaration for the AddPointer type trait.The AddPointer_t alias declaration provides a convenient shortcut to access the nested Type of the AddPointer class template. For instance, given the type T the following two type definitions are identical: More... | |
template<typename T > | |
using | AddReference_t = typename AddReference< T >::Type |
Auxiliary alias declaration for the AddReference type trait.The AddReference_t alias declaration provides a convenient shortcut to access the nested Type of the AddReference class template. For instance, given the type T the following two type definitions are identical: More... | |
template<typename T > | |
using | AddVolatile_t = typename AddVolatile< T >::Type |
Auxiliary alias declaration for the AddVolatile type trait.The AddVolatile_t alias declaration provides a convenient shortcut to access the nested Type of the AddVolatile class template. For instance, given the type T the following two type definitions are identical: More... | |
template<typename... T> | |
using | CommonType_t = typename CommonType< T... >::Type |
Auxiliary alias declaration for the CommonType type trait.The CommonType_t alias declaration provides a convenient shortcut to access the nested Type of the CommonType class template. For instance, given the types T1 and T2 the following two type definitions are identical: More... | |
template<typename T > | |
using | Decay_t = typename Decay< T >::Type |
Auxiliary alias declaration for the Decay type trait.The Decay_t alias declaration provides a convenient shortcut to access the nested Type of the Decay class template. For instance, given the type T the following two type definitions are identical: More... | |
template<typename T > | |
using | MakeSigned_t = typename MakeSigned< T >::Type |
Auxiliary alias declaration for the MakeSigned type trait.The MakeSigned_t alias declaration provides a convenient shortcut to access the nested Type of the MakeSigned class template. For instance, given the type T the following two type definitions are identical: More... | |
template<typename T > | |
using | MakeUnsigned_t = typename MakeUnsigned< T >::Type |
Auxiliary alias declaration for the MakeUnsigned type trait.The MakeUnsigned_t alias declaration provides a convenient shortcut to access the nested Type of the MakeUnsigned class template. For instance, given the type T the following two type definitions are identical: More... | |
template<typename T > | |
using | RemoveAllExtents_t = typename RemoveAllExtents< T >::Type |
Auxiliary alias declaration for the RemoveAllExtents type trait.The RemoveAllExtents_t alias declaration provides a convenient shortcut to access the nested Type of the RemoveAllExtents class template. For instance, given the type T the following two type definitions are identical: More... | |
template<typename T > | |
using | RemoveConst_t = typename RemoveConst< T >::Type |
Auxiliary alias declaration for the RemoveConst type trait.The RemoveConst_t alias declaration provides a convenient shortcut to access the nested Type of the RemoveConst class template. For instance, given the type T the following two type definitions are identical: More... | |
template<typename T > | |
using | RemoveCV_t = typename RemoveCV< T >::Type |
Auxiliary alias declaration for the RemoveCV type trait.The RemoveCV_t alias declaration provides a convenient shortcut to access the nested Type of the RemoveCV class template. For instance, given the type T the following two type definitions are identical: More... | |
template<typename T > | |
using | RemoveCVRef_t = typename RemoveCVRef< T >::Type |
Auxiliary alias declaration for the RemoveCVRef type trait.The RemoveCVRef_t alias declaration provides a convenient shortcut to access the nested Type of the RemoveCVRef class template. For instance, given the type T the following two type definitions are identical: More... | |
template<typename T > | |
using | RemoveExtent_t = typename RemoveExtent< T >::Type |
Auxiliary alias declaration for the RemoveExtent type trait.The RemoveExtent_t alias declaration provides a convenient shortcut to access the nested Type of the RemoveExtent class template. For instance, given the type T the following two type definitions are identical: More... | |
template<typename T > | |
using | RemovePointer_t = typename RemovePointer< T >::Type |
Auxiliary alias declaration for the RemovePointer type trait.The RemovePointer_t alias declaration provides a convenient shortcut to access the nested Type of the RemovePointer class template. For instance, given the type T the following two type definitions are identical: More... | |
template<typename T > | |
using | RemoveReference_t = typename RemoveReference< T >::Type |
Auxiliary alias declaration for the RemoveReference type trait.The RemoveReference_t alias declaration provides a convenient shortcut to access the nested Type of the RemoveReference class template. For instance, given the type T the following two type definitions are identical: More... | |
template<typename T > | |
using | RemoveVolatile_t = typename RemoveVolatile< T >::Type |
Auxiliary alias declaration for the RemoveVolatile type trait.The RemoveVolatile_t alias declaration provides a convenient shortcut to access the nested Type of the RemoveVolatile class template. For instance, given the type T the following two type definitions are identical: More... | |
template<typename... Ts> | |
using | Void_t = void |
Compile time type check.This type trait maps an arbitrary sequence of types to the type void . It can for instance be used to determine the validity of an expression: More... | |
Enumerations | |
enum | AlignmentFlag : bool { unaligned = false, 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 | InversionFlag { byLU = 0, byLDLT = 1, byLDLH = 2, byLLH = 3, asGeneral = 4, asSymmetric = 5, asHermitian = 6, asLower = 7, asUniLower = 8, asUpper = 9, asUniUpper = 10, 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 A , typename T > | |
constexpr bool | operator<= (const NegativeAccuracy< A > &, const T &rhs) |
Less-or-equal-than comparison between a NegativeAccuracy object and a floating point value. More... | |
template<typename A , typename T > | |
constexpr bool | operator<= (const T &lhs, const NegativeAccuracy< A > &) |
Less-or-equal-than comparison between a floating point value and a NegativeAccuracy object. More... | |
template<typename A , typename T > | |
constexpr bool | operator>= (const NegativeAccuracy< A > &, const T &rhs) |
Greater-or-equal-than comparison between a NegativeAccuracy object and a floating point value. More... | |
template<typename A , typename T > | |
constexpr bool | operator>= (const T &lhs, const NegativeAccuracy< A > &) |
Less-or-equal-than comparison between a floating point value and a NegativeAccuracy object. More... | |
template<bool RF, typename VT , bool TF> | |
bool | isZero (const DenseVector< VT, TF > &dv) |
Checks if the given dense vector is a zero vector. More... | |
template<bool SO = defaultStorageOrder, typename T > | |
decltype(auto) constexpr | uniform (size_t m, size_t n, T &&init) |
Creating a uniform matrix. More... | |
template<bool TF = defaultTransposeFlag, typename T > | |
decltype(auto) constexpr | uniform (size_t n, T &&init) |
Creating a uniform vector. More... | |
template<typename E , typename T > | |
constexpr bool | operator<= (const NegativeEpsilon< E > &, const T &rhs) |
Less-or-equal-than comparison between a NegativeEpsilon object and a floating point value. More... | |
template<typename E , typename T > | |
constexpr bool | operator<= (const T &lhs, const NegativeEpsilon< E > &) |
Less-or-equal-than comparison between a floating point value and a NegativeEpsilon object. More... | |
template<typename E , typename T > | |
constexpr bool | operator>= (const NegativeEpsilon< E > &, const T &rhs) |
Greater-or-equal-than comparison between a NegativeEpsilon object and a floating point value. More... | |
template<typename E , typename T > | |
constexpr bool | operator>= (const T &lhs, const NegativeEpsilon< E > &) |
Less-or-equal-than comparison between a floating point value and a NegativeEpsilon object. More... | |
template<typename MT , bool SO> | |
BLAZE_ALWAYS_INLINE MT::ElementType * | data (DenseMatrix< MT, SO > &dm) noexcept |
Low-level data access to the dense matrix elements. More... | |
template<typename MT , bool SO> | |
BLAZE_ALWAYS_INLINE const MT::ElementType * | data (const DenseMatrix< MT, SO > &dm) noexcept |
Low-level data access to the dense matrix elements. More... | |
template<typename MT , bool SO> | |
BLAZE_ALWAYS_INLINE size_t | spacing (const DenseMatrix< MT, SO > &dm) noexcept |
Returns the spacing between the beginning of two rows/columns. More... | |
template<typename VT , bool TF> | |
BLAZE_ALWAYS_INLINE VT::ElementType * | data (DenseVector< VT, TF > &dv) noexcept |
Low-level data access to the dense vector elements. More... | |
template<typename VT , bool TF> | |
BLAZE_ALWAYS_INLINE const VT::ElementType * | data (const DenseVector< VT, TF > &dv) noexcept |
Low-level data access to the dense vector elements. More... | |
template<typename MT , bool SO> | |
decltype(auto) | decldiag (const DenseMatrix< MT, SO > &dm) |
Declares the given dense matrix expression dm as diagonal. More... | |
template<typename MT , bool SO> | |
decltype(auto) | declherm (const DenseMatrix< MT, SO > &dm) |
Declares the given dense matrix expression dm as Hermitian. More... | |
template<typename MT , bool SO> | |
decltype(auto) | decllow (const DenseMatrix< MT, SO > &dm) |
Declares the given dense matrix expression dm as lower. More... | |
template<typename MT , bool SO> | |
decltype(auto) | declsym (const DenseMatrix< MT, SO > &dm) |
Declares the given dense matrix expression dm as symmetric. More... | |
template<typename MT , bool SO> | |
decltype(auto) | declupp (const DenseMatrix< MT, SO > &dm) |
Declares the given dense matrix expression dm as upper. More... | |
template<typename MT1 , typename MT2 , bool SO> | |
decltype(auto) | operator+ (const DenseMatrix< MT1, SO > &lhs, const DenseMatrix< MT2, SO > &rhs) |
Addition operator for the addition of two dense matrices with identical storage order ( ![]() | |
template<typename MT1 , bool SO1, typename MT2 , bool SO2> | |
bool | operator== (const DenseMatrix< MT1, SO1 > &lhs, const DenseMatrix< MT2, SO2 > &rhs) |
Equality operator for the comparison of two dense matrices. More... | |
template<typename MT1 , bool SO1, typename MT2 , bool SO2> | |
bool | operator!= (const DenseMatrix< MT1, SO1 > &lhs, const DenseMatrix< MT2, SO2 > &rhs) |
Inequality operator for the comparison of two dense matrices. More... | |
template<typename MT1 , bool SO1, typename MT2 , bool SO2> | |
decltype(auto) | kron (const DenseMatrix< MT1, SO1 > &lhs, const DenseMatrix< MT2, SO2 > &rhs) |
Computes the Kronecker product of two dense matrices ( ![]() | |
template<typename MT1 , typename MT2 , bool SO, typename OP > | |
decltype(auto) | map (const DenseMatrix< MT1, SO > &lhs, const DenseMatrix< MT2, SO > &rhs, OP op) |
Evaluates the given binary operation on each single element of the dense matrices lhs and rhs. More... | |
template<typename MT1 , bool SO1, typename MT2 , bool SO2> | |
decltype(auto) | min (const DenseMatrix< MT1, SO1 > &lhs, const DenseMatrix< MT2, SO2 > &rhs) |
Computes the componentwise minimum of the dense matrices lhs and rhs. More... | |
template<typename MT1 , bool SO1, typename MT2 , bool SO2> | |
decltype(auto) | max (const DenseMatrix< MT1, SO1 > &lhs, const DenseMatrix< MT2, SO2 > &rhs) |
Computes the componentwise maximum of the dense matrices lhs and rhs. More... | |
template<typename MT1 , bool SO1, typename MT2 , bool SO2> | |
decltype(auto) | hypot (const DenseMatrix< MT1, SO1 > &lhs, const DenseMatrix< MT2, SO2 > &rhs) |
Computes the componentwise hypotenous for the dense matrices lhs and rhs. More... | |
template<typename MT1 , bool SO1, typename MT2 , bool SO2> | |
decltype(auto) | pow (const DenseMatrix< MT1, SO1 > &lhs, const DenseMatrix< MT2, SO2 > &rhs) |
Computes the componentwise exponential value for the dense matrices lhs and rhs. More... | |
template<typename MT1 , bool SO1, typename MT2 , bool SO2> | |
decltype(auto) | atan2 (const DenseMatrix< MT1, SO1 > &lhs, const DenseMatrix< MT2, SO2 > &rhs) |
Computes the multi-valued inverse tangent of the dense matrices lhs and rhs. More... | |
template<typename MT1 , bool SO1, typename MT2 , bool SO2> | |
decltype(auto) | operator<< (const DenseMatrix< MT1, SO1 > &lhs, const DenseMatrix< MT2, SO2 > &rhs) |
Left-shift operator for the elementwise left-shift of a dense matrix. More... | |
template<typename MT1 , bool SO1, typename MT2 , bool SO2> | |
decltype(auto) | operator>> (const DenseMatrix< MT1, SO1 > &lhs, const DenseMatrix< MT2, SO2 > &rhs) |
Right-shift operator for the elementwise right-shift of a dense matrix. More... | |
template<typename MT1 , bool SO1, typename MT2 , bool SO2> | |
decltype(auto) | operator & (const DenseMatrix< MT1, SO1 > &lhs, const DenseMatrix< MT2, SO2 > &rhs) |
Bitwise AND operator for two dense matrices. More... | |
template<typename MT1 , bool SO1, typename MT2 , bool SO2> | |
decltype(auto) | operator| (const DenseMatrix< MT1, SO1 > &lhs, const DenseMatrix< MT2, SO2 > &rhs) |
Bitwise OR operator for two dense matrices. More... | |
template<typename MT1 , bool SO1, typename MT2 , bool SO2> | |
decltype(auto) | operator^ (const DenseMatrix< MT1, SO1 > &lhs, const DenseMatrix< MT2, SO2 > &rhs) |
Bitwise XOR operator for two dense matrices. More... | |
template<typename MT1 , bool SO1, typename MT2 , bool SO2> | |
decltype(auto) | operator && (const DenseMatrix< MT1, SO1 > &lhs, const DenseMatrix< MT2, SO2 > &rhs) |
Logical AND operator for two dense matrices. More... | |
template<typename MT1 , bool SO1, typename MT2 , bool SO2> | |
decltype(auto) | operator|| (const DenseMatrix< MT1, SO1 > &lhs, const DenseMatrix< MT2, SO2 > &rhs) |
Logical OR operator for two dense matrices. More... | |
template<typename MT1 , typename MT2 > | |
decltype(auto) | operator * (const DenseMatrix< MT1, false > &lhs, const DenseMatrix< MT2, false > &rhs) |
Multiplication operator for the multiplication of two row-major dense matrices ( ![]() | |
template<typename MT1 , typename MT2 , bool SO> | |
decltype(auto) | operator% (const DenseMatrix< MT1, SO > &lhs, const DenseMatrix< MT2, SO > &rhs) |
Operator for the Schur product of two dense matrices with identical storage order ( ![]() | |
template<typename MT1 , typename MT2 , bool SO> | |
decltype(auto) | operator- (const DenseMatrix< MT1, SO > &lhs, const DenseMatrix< MT2, SO > &rhs) |
Subtraction operator for the subtraction of two dense matrices with identical storage order ( ![]() | |
template<typename MT , typename VT > | |
decltype(auto) | operator * (const DenseMatrix< MT, false > &mat, const DenseVector< VT, false > &vec) |
Multiplication operator for the multiplication of a row-major dense matrix and a dense vector ( ![]() | |
template<typename MT , bool SO> | |
decltype(auto) | eval (const DenseMatrix< MT, SO > &dm) |
Forces the evaluation of the given dense matrix expression dm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | inv (const DenseMatrix< MT, SO > &dm) |
Calculation of the inverse of the given dense matrix. More... | |
template<typename MT , bool SO, typename OP > | |
decltype(auto) | map (const DenseMatrix< MT, SO > &dm, OP op) |
Evaluates the given custom operation on each single element of the dense matrix dm. More... | |
template<typename MT , bool SO, typename OP > | |
decltype(auto) | forEach (const DenseMatrix< MT, SO > &dm, OP op) |
Evaluates the given custom operation on each single element of the dense matrix dm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | abs (const DenseMatrix< MT, SO > &dm) |
Applies the abs() function to each single element of the dense matrix dm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | sign (const DenseMatrix< MT, SO > &dm) |
Applies the sign() function to each single element of the dense matrix dm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | floor (const DenseMatrix< MT, SO > &dm) |
Applies the floor() function to each single element of the dense matrix dm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | ceil (const DenseMatrix< MT, SO > &dm) |
Applies the ceil() function to each single element of the dense matrix dm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | trunc (const DenseMatrix< MT, SO > &dm) |
Applies the trunc() function to each single element of the dense matrix dm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | round (const DenseMatrix< MT, SO > &dm) |
Applies the round() function to each single element of the dense matrix dm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | conj (const DenseMatrix< MT, SO > &dm) |
Returns a matrix containing the complex conjugate of each single element of dm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | ctrans (const DenseMatrix< MT, SO > &dm) |
Returns the conjugate transpose matrix of dm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | real (const DenseMatrix< MT, SO > &dm) |
Returns a matrix containing the real part of each single element of dm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | imag (const DenseMatrix< MT, SO > &dm) |
Returns a matrix containing the imaginary part of each single element of dm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | sqrt (const DenseMatrix< MT, SO > &dm) |
Computes the square root of each single element of the dense matrix dm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | invsqrt (const DenseMatrix< MT, SO > &dm) |
Computes the inverse square root of each single element of the dense matrix dm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | cbrt (const DenseMatrix< MT, SO > &dm) |
Computes the cubic root of each single element of the dense matrix dm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | invcbrt (const DenseMatrix< MT, SO > &dm) |
Computes the inverse cubic root of each single element of the dense matrix dm. More... | |
template<typename MT , bool SO, typename DT > | |
decltype(auto) | clamp (const DenseMatrix< MT, SO > &dm, const DT &min, const DT &max) |
Restricts each single element of the dense matrix dm to the range ![]() | |
template<typename MT , bool SO, typename ST , EnableIf_t< IsNumeric_v< ST > > * = nullptr> | |
decltype(auto) | pow (const DenseMatrix< MT, SO > &dm, ST exp) |
Computes the exponential value for each single element of the dense matrix dm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | exp (const DenseMatrix< MT, SO > &dm) |
Computes ![]() | |
template<typename MT , bool SO> | |
decltype(auto) | exp2 (const DenseMatrix< MT, SO > &dm) |
Computes ![]() | |
template<typename MT , bool SO> | |
decltype(auto) | exp10 (const DenseMatrix< MT, SO > &dm) |
Computes ![]() | |
template<typename MT , bool SO> | |
decltype(auto) | log (const DenseMatrix< MT, SO > &dm) |
Computes the natural logarithm for each single element of the dense matrix dm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | log2 (const DenseMatrix< MT, SO > &dm) |
Computes the binary logarithm for each single element of the dense matrix dm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | log10 (const DenseMatrix< MT, SO > &dm) |
Computes the common logarithm for each single element of the dense matrix dm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | sin (const DenseMatrix< MT, SO > &dm) |
Computes the sine for each single element of the dense matrix dm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | asin (const DenseMatrix< MT, SO > &dm) |
Computes the inverse sine for each single element of the dense matrix dm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | sinh (const DenseMatrix< MT, SO > &dm) |
Computes the hyperbolic sine for each single element of the dense matrix dm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | asinh (const DenseMatrix< MT, SO > &dm) |
Computes the inverse hyperbolic sine for each single element of the dense matrix dm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | cos (const DenseMatrix< MT, SO > &dm) |
Computes the cosine for each single element of the dense matrix dm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | acos (const DenseMatrix< MT, SO > &dm) |
Computes the inverse cosine for each single element of the dense matrix dm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | cosh (const DenseMatrix< MT, SO > &dm) |
Computes the hyperbolic cosine for each single element of the dense matrix dm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | acosh (const DenseMatrix< MT, SO > &dm) |
Computes the inverse hyperbolic cosine for each single element of the dense matrix dm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | tan (const DenseMatrix< MT, SO > &dm) |
Computes the tangent for each single element of the dense matrix dm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | atan (const DenseMatrix< MT, SO > &dm) |
Computes the inverse tangent for each single element of the dense matrix dm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | tanh (const DenseMatrix< MT, SO > &dm) |
Computes the hyperbolic tangent for each single element of the dense matrix dm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | atanh (const DenseMatrix< MT, SO > &dm) |
Computes the inverse hyperbolic tangent for each single element of the dense matrix dm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | erf (const DenseMatrix< MT, SO > &dm) |
Computes the error function for each single element of the dense matrix dm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | erfc (const DenseMatrix< MT, SO > &dm) |
Computes the complementary error function for each single element of the dense matrix dm. More... | |
template<typename MT , bool SO, typename ST , EnableIf_t< IsNumeric_v< ST > > * = nullptr> | |
decltype(auto) | operator+ (const DenseMatrix< MT, SO > &mat, ST scalar) |
Addition operator for the addition of a dense matrix and a scalar value ( ![]() | |
template<typename ST , typename MT , bool SO, EnableIf_t< IsNumeric_v< ST > > * = nullptr> | |
decltype(auto) | operator+ (ST scalar, const DenseMatrix< MT, SO > &mat) |
Addition operator for the addition of a scalar value and a dense matrix ( ![]() | |
template<typename MT , bool SO, typename ST , EnableIf_t< IsNumeric_v< ST > > * = nullptr> | |
decltype(auto) | operator- (const DenseMatrix< MT, SO > &mat, ST scalar) |
Subtraction operator for the subtraction of a dense matrix and a scalar value ( ![]() | |
template<typename ST , typename MT , bool SO, EnableIf_t< IsNumeric_v< ST > > * = nullptr> | |
decltype(auto) | operator- (ST scalar, const DenseMatrix< MT, SO > &mat) |
Subtraction operator for the subtraction of a scalar value and a dense matrix ( ![]() | |
template<typename ST , typename MT , bool SO, EnableIf_t< IsNumeric_v< ST > > * = nullptr> | |
decltype(auto) | operator/ (ST scalar, const DenseMatrix< MT, SO > &mat) |
Division operator for the division of a scalar value and a dense matrix ( ![]() | |
template<typename MT , bool SO> | |
decltype(auto) | operator<< (const DenseMatrix< MT, SO > &mat, int count) |
Left-shift operator for the uniform left-shift of a dense matrix. More... | |
template<typename MT , bool SO> | |
decltype(auto) | operator>> (const DenseMatrix< MT, SO > &mat, int count) |
Right-shift operator for the uniform right-shift of a dense matrix. More... | |
template<typename MT , bool SO, typename ST , EnableIf_t< IsNumeric_v< ST > > * = nullptr> | |
decltype(auto) | operator & (const DenseMatrix< MT, SO > &mat, ST scalar) |
Bitwise AND operator for the bitwise AND of a dense matrix and a scalar value. More... | |
template<typename MT , bool SO, typename ST , EnableIf_t< IsNumeric_v< ST > > * = nullptr> | |
decltype(auto) | operator| (const DenseMatrix< MT, SO > &mat, ST scalar) |
Bitwise OR operator for the bitwise OR of a dense matrix and a scalar value. More... | |
template<typename MT , bool SO, typename ST , EnableIf_t< IsNumeric_v< ST > > * = nullptr> | |
decltype(auto) | operator^ (const DenseMatrix< MT, SO > &mat, ST scalar) |
Bitwise XOR operator for the bitwise XOR of a dense matrix and a scalar value. More... | |
template<typename MT , bool SO> | |
decltype(auto) | operator! (const DenseMatrix< MT, SO > &mat) |
Logical NOT operator for the logical NOT of a dense matrix. More... | |
template<typename MT , bool SO> | |
decltype(auto) | mean (const DenseMatrix< MT, SO > &dm) |
Computes the (arithmetic) mean for the given dense matrix. More... | |
template<size_t RF, typename MT , bool SO> | |
decltype(auto) | mean (const DenseMatrix< MT, SO > &dm) |
Computes the row-/column-wise mean function for the given dense matrix. More... | |
template<typename MT , bool SO> | |
decltype(auto) | norm (const DenseMatrix< MT, SO > &dm) |
Computes the L2 norm for the given dense matrix. More... | |
template<typename MT , bool SO> | |
decltype(auto) | sqrNorm (const DenseMatrix< MT, SO > &dm) |
Computes the squared L2 norm for the given dense matrix. More... | |
template<typename MT , bool SO> | |
decltype(auto) | l1Norm (const DenseMatrix< MT, SO > &dm) |
Computes the L1 norm for the given dense matrix. More... | |
template<typename MT , bool SO> | |
decltype(auto) | l2Norm (const DenseMatrix< MT, SO > &dm) |
Computes the L2 norm for the given dense matrix. More... | |
template<typename MT , bool SO> | |
decltype(auto) | l3Norm (const DenseMatrix< MT, SO > &dm) |
Computes the L3 norm for the given dense matrix. More... | |
template<typename MT , bool SO> | |
decltype(auto) | l4Norm (const DenseMatrix< MT, SO > &dm) |
Computes the L4 norm for the given dense matrix. More... | |
template<typename MT , bool SO, typename ST > | |
decltype(auto) | lpNorm (const DenseMatrix< MT, SO > &dm, ST p) |
Computes the Lp norm for the given dense matrix. More... | |
template<size_t P, typename MT , bool SO> | |
decltype(auto) | lpNorm (const DenseMatrix< MT, SO > &dm) |
Computes the Lp norm for the given dense matrix. More... | |
template<typename MT , bool SO> | |
decltype(auto) | linfNorm (const DenseMatrix< MT, SO > &dm) |
Computes the infinity norm for the given dense matrix. More... | |
template<typename MT , bool SO> | |
decltype(auto) | maxNorm (const DenseMatrix< MT, SO > &dm) |
Computes the maximum norm for the given dense matrix. More... | |
template<typename MT , bool SO, typename OP > | |
decltype(auto) | reduce (const DenseMatrix< MT, SO > &dm, OP op) |
Performs a custom reduction operation on the given dense matrix. More... | |
template<size_t RF, typename MT , bool SO, typename OP > | |
decltype(auto) | reduce (const DenseMatrix< MT, SO > &dm, OP op) |
Performs a custom reduction operation on the given dense matrix. More... | |
template<typename MT , bool SO> | |
decltype(auto) | sum (const DenseMatrix< MT, SO > &dm) |
Reduces the given dense matrix by means of addition. More... | |
template<size_t RF, typename MT , bool SO> | |
decltype(auto) | sum (const DenseMatrix< MT, SO > &dm) |
Reduces the given dense matrix by means of addition. More... | |
template<typename MT , bool SO> | |
decltype(auto) | prod (const DenseMatrix< MT, SO > &dm) |
Reduces the given dense matrix by means of multiplication. More... | |
template<size_t RF, typename MT , bool SO> | |
decltype(auto) | prod (const DenseMatrix< MT, SO > &dm) |
Reduces the given dense matrix by means of multiplication. More... | |
template<typename MT , bool SO> | |
decltype(auto) | min (const DenseMatrix< MT, SO > &dm) |
Returns the smallest element of the dense matrix. More... | |
template<size_t RF, typename MT , bool SO> | |
decltype(auto) | min (const DenseMatrix< MT, SO > &dm) |
Returns the smallest element of each row/columns of the dense matrix. More... | |
template<typename MT , bool SO> | |
decltype(auto) | max (const DenseMatrix< MT, SO > &dm) |
Returns the largest element of the dense matrix. More... | |
template<size_t RF, typename MT , bool SO> | |
decltype(auto) | max (const DenseMatrix< MT, SO > &dm) |
Returns the largest element of each row/columns of the dense matrix. More... | |
template<typename MT , bool SO, typename ST , EnableIf_t< IsNumeric_v< ST > > * = nullptr> | |
decltype(auto) | operator/ (const DenseMatrix< MT, SO > &mat, ST scalar) |
Division operator for the division of a dense matrix by a scalar value ( ![]() | |
template<typename MT , bool SO> | |
decltype(auto) | operator- (const DenseMatrix< MT, SO > &dm) |
Unary minus operator for the negation of a dense matrix ( ![]() | |
template<typename MT , bool SO, typename ST , EnableIf_t< IsNumeric_v< ST > > * = nullptr> | |
decltype(auto) | operator * (const DenseMatrix< MT, SO > &mat, ST scalar) |
Multiplication operator for the multiplication of a dense matrix and a scalar value ( ![]() | |
template<typename ST , typename MT , bool SO, EnableIf_t< IsNumeric_v< ST > > * = nullptr> | |
decltype(auto) | operator * (ST scalar, const DenseMatrix< MT, SO > &mat) |
Multiplication operator for the multiplication of a scalar value and a dense matrix ( ![]() | |
template<typename MT , bool SO> | |
decltype(auto) | serial (const DenseMatrix< MT, SO > &dm) |
Forces the serial evaluation of the given dense matrix expression dm. More... | |
template<typename MT1 , typename MT2 , bool SO> | |
decltype(auto) | operator+ (const DenseMatrix< MT1, SO > &lhs, const SparseMatrix< MT2, SO > &rhs) |
Addition operator for the addition of a dense matrix and a sparse matrix with identical storage order ( ![]() | |
template<typename MT1 , typename MT2 , bool SO> | |
decltype(auto) | operator+ (const SparseMatrix< MT1, SO > &lhs, const DenseMatrix< MT2, SO > &rhs) |
Addition operator for the addition of a sparse matrix and a dense matrix ( ![]() | |
template<typename MT1 , bool SO1, typename MT2 , bool SO2> | |
bool | operator== (const DenseMatrix< MT1, SO1 > &lhs, const SparseMatrix< MT2, SO2 > &rhs) |
Equality operator for the comparison of a dense matrix and a sparse matrix. More... | |
template<typename MT1 , bool SO1, typename MT2 , bool SO2> | |
bool | operator== (const SparseMatrix< MT1, SO1 > &lhs, const DenseMatrix< MT2, SO2 > &rhs) |
Equality operator for the comparison of a sparse matrix and a dense matrix. More... | |
template<typename MT1 , bool SO1, typename MT2 , bool SO2> | |
bool | operator!= (const DenseMatrix< MT1, SO1 > &lhs, const SparseMatrix< MT2, SO2 > &rhs) |
Inequality operator for the comparison of a dense matrix and a sparse matrix. More... | |
template<typename MT1 , bool SO1, typename MT2 , bool SO2> | |
bool | operator!= (const SparseMatrix< MT1, SO1 > &lhs, const DenseMatrix< MT2, SO2 > &rhs) |
Inequality operator for the comparison of a sparse matrix and a dense matrix. More... | |
template<typename MT1 , bool SO1, typename MT2 , bool SO2> | |
decltype(auto) | kron (const DenseMatrix< MT1, SO1 > &lhs, const SparseMatrix< MT2, SO2 > &rhs) |
Computes the Kronecker product of a dense matrix and a sparse matrix ( ![]() | |
template<typename MT1 , typename MT2 > | |
decltype(auto) | operator * (const DenseMatrix< MT1, false > &lhs, const SparseMatrix< MT2, false > &rhs) |
Multiplication operator for the multiplication of a row-major dense matrix and a row-major sparse matrix ( ![]() | |
template<typename MT1 , typename MT2 > | |
decltype(auto) | operator% (const DenseMatrix< MT1, false > &lhs, const SparseMatrix< MT2, false > &rhs) |
Operator for the Schur product of a row-major dense matrix and a row-major sparse matrix ( ![]() | |
template<typename MT1 , typename MT2 > | |
decltype(auto) | operator% (const DenseMatrix< MT1, true > &lhs, const SparseMatrix< MT2, false > &rhs) |
Operator for the Schur product of a column-major dense matrix and a row-major sparse matrix ( ![]() | |
template<typename MT1 , typename MT2 , bool SO> | |
decltype(auto) | operator- (const DenseMatrix< MT1, SO > &lhs, const SparseMatrix< MT2, SO > &rhs) |
Subtraction operator for the subtraction of a dense matrix and a sparse matrix with identical storage order ( ![]() | |
template<typename MT , bool SO> | |
auto | softmax (const DenseMatrix< MT, SO > &dm) |
Computes the softmax function for the given dense matrix. More... | |
template<bool RF, typename MT , bool SO> | |
auto | softmax (const DenseMatrix< MT, SO > &dm) |
Computes the row-/columnwise softmax function for the given dense matrix. More... | |
template<typename MT , bool SO> | |
decltype(auto) | stddev (const DenseMatrix< MT, SO > &dm) |
Computes the standard deviation for the given dense matrix. More... | |
template<size_t RF, typename MT , bool SO> | |
decltype(auto) | stddev (const DenseMatrix< MT, SO > &dm) |
Computes the row-/columnwise standard deviation function for the given dense matrix. More... | |
template<typename MT , typename VT > | |
decltype(auto) | operator * (const DenseMatrix< MT, false > &mat, const SparseVector< VT, false > &vec) |
Multiplication operator for the multiplication of a row-major dense matrix and a sparse vector ( ![]() | |
template<typename MT1 , typename MT2 > | |
decltype(auto) | operator+ (const DenseMatrix< MT1, false > &lhs, const DenseMatrix< MT2, true > &rhs) |
Addition operator for the addition of a row-major and a colum-major dense matrix ( ![]() | |
template<typename MT1 , typename MT2 > | |
decltype(auto) | operator+ (const DenseMatrix< MT1, true > &lhs, const DenseMatrix< MT2, false > &rhs) |
Addition operator for the addition of a column-major and a row-major dense matrix ( ![]() | |
template<typename MT1 , typename MT2 , typename OP > | |
decltype(auto) | map (const DenseMatrix< MT1, false > &lhs, const DenseMatrix< MT2, true > &rhs, OP op) |
Evaluates the given binary operation on each single element of the row-major dense matrix lhs and the column-major dense matrix rhs. More... | |
template<typename MT1 , typename MT2 , typename OP > | |
decltype(auto) | map (const DenseMatrix< MT1, true > &lhs, const DenseMatrix< MT2, false > &rhs, OP op) |
Evaluates the given binary operation on each single element of the column-major dense matrix lhs and the row-major dense matrix rhs. More... | |
template<typename MT1 , typename MT2 > | |
decltype(auto) | operator * (const DenseMatrix< MT1, false > &lhs, const DenseMatrix< MT2, true > &rhs) |
Multiplication operator for the multiplication of a row-major dense matrix and a column-major dense matrix ( ![]() | |
template<typename MT1 , typename MT2 > | |
decltype(auto) | operator% (const DenseMatrix< MT1, false > &lhs, const DenseMatrix< MT2, true > &rhs) |
Operator for the Schur product of a row-major and a column-major dense matrix ( ![]() | |
template<typename MT1 , typename MT2 > | |
decltype(auto) | operator% (const DenseMatrix< MT1, true > &lhs, const DenseMatrix< MT2, false > &rhs) |
Operator for the Schur product of a column-major and a row-major dense matrix ( ![]() | |
template<typename MT1 , typename MT2 > | |
decltype(auto) | operator- (const DenseMatrix< MT1, false > &lhs, const DenseMatrix< MT2, true > &rhs) |
Subtraction operator for the subtraction of a row-major and a column-major dense matrix ( ![]() | |
template<typename MT1 , typename MT2 > | |
decltype(auto) | operator- (const DenseMatrix< MT1, true > &lhs, const DenseMatrix< MT2, false > &rhs) |
Subtraction operator for the subtraction of a column-major and a row-major dense matrix ( ![]() | |
template<typename MT , bool SO> | |
decltype(auto) | trans (const DenseMatrix< MT, SO > &dm) |
Calculation of the transpose of the given dense matrix. More... | |
template<typename MT1 , typename MT2 > | |
decltype(auto) | operator+ (const DenseMatrix< MT1, false > &lhs, const SparseMatrix< MT2, true > &rhs) |
Addition operator for the addition of a row-major dense matrix and a column-major sparse matrix ( ![]() | |
template<typename MT1 , typename MT2 > | |
decltype(auto) | operator+ (const SparseMatrix< MT1, true > &lhs, const DenseMatrix< MT2, false > &rhs) |
Addition operator for the addition of a column-major sparse matrix and a row-major dense matrix ( ![]() | |
template<typename MT1 , typename MT2 > | |
decltype(auto) | operator * (const DenseMatrix< MT1, false > &lhs, const SparseMatrix< MT2, true > &rhs) |
Multiplication operator for the multiplication of a row-major dense matrix and a column-major sparse matrix ( ![]() | |
template<typename MT1 , typename MT2 > | |
decltype(auto) | operator% (const DenseMatrix< MT1, false > &lhs, const SparseMatrix< MT2, true > &rhs) |
Operator for the Schur product of a row-major dense matrix and a column-major sparse matrix ( ![]() | |
template<typename MT1 , typename MT2 > | |
decltype(auto) | operator% (const DenseMatrix< MT1, true > &lhs, const SparseMatrix< MT2, true > &rhs) |
Operator for the Schur product of a column-major dense matrix and a column-major sparse matrix ( ![]() | |
template<typename MT1 , typename MT2 > | |
decltype(auto) | operator- (const DenseMatrix< MT1, false > &lhs, const SparseMatrix< MT2, true > &rhs) |
Subtraction operator for the subtraction of a row-major dense matrix and a column-major sparse matrix ( ![]() | |
template<typename MT , bool SO> | |
decltype(auto) | var (const DenseMatrix< MT, SO > &dm) |
Computes the variance for the given dense matrix. More... | |
template<size_t RF, typename MT , bool SO> | |
decltype(auto) | var (const DenseMatrix< MT, SO > &dm) |
Computes the row-/column-wise variance function for the given dense matrix. More... | |
template<typename VT1 , typename VT2 , bool TF> | |
decltype(auto) | operator+ (const DenseVector< VT1, TF > &lhs, const DenseVector< VT2, TF > &rhs) |
Addition operator for the addition of two dense vectors ( ![]() | |
template<typename VT1 , typename VT2 , bool TF> | |
decltype(auto) | operator% (const DenseVector< VT1, TF > &lhs, const DenseVector< VT2, TF > &rhs) |
Operator for the cross product of two dense vectors ( ![]() | |
template<typename VT1 , typename VT2 , bool TF> | |
decltype(auto) | cross (const DenseVector< VT1, TF > &lhs, const DenseVector< VT2, TF > &rhs) |
Cross product of two dense vectors ( ![]() | |
template<typename VT1 , typename VT2 , bool TF> | |
decltype(auto) | operator/ (const DenseVector< VT1, TF > &lhs, const DenseVector< VT2, TF > &rhs) |
Division operator for the componentwise quotient of two dense vectors ( ![]() | |
template<typename VT1 , bool TF1, typename VT2 , bool TF2> | |
bool | operator== (const DenseVector< VT1, TF1 > &lhs, const DenseVector< VT2, TF2 > &rhs) |
Equality operator for the comparison of two dense vectors. More... | |
template<typename VT1 , bool TF1, typename VT2 , bool TF2> | |
bool | operator!= (const DenseVector< VT1, TF1 > &lhs, const DenseVector< VT2, TF2 > &rhs) |
Inequality operator for the comparison of two dense vectors. More... | |
template<typename VT1 , typename VT2 > | |
decltype(auto) | operator * (const DenseVector< VT1, true > &lhs, const DenseVector< VT2, false > &rhs) |
Multiplication operator for the scalar product (inner product) of two dense vectors ( ![]() | |
template<typename VT1 , typename VT2 , bool TF> | |
decltype(auto) | kron (const DenseVector< VT1, TF > &lhs, const DenseVector< VT2, TF > &rhs) |
Computes the Kronecker product of two dense vectors ( ![]() | |
template<typename VT1 , typename VT2 , bool TF, typename OP > | |
decltype(auto) | map (const DenseVector< VT1, TF > &lhs, const DenseVector< VT2, TF > &rhs, OP op) |
Evaluates the given binary operation on each single element of the dense vectors lhs and rhs. More... | |
template<typename VT1 , typename VT2 , bool TF> | |
decltype(auto) | min (const DenseVector< VT1, TF > &lhs, const DenseVector< VT2, TF > &rhs) |
Computes the componentwise minimum of the dense vectors lhs and rhs. More... | |
template<typename VT1 , typename VT2 , bool TF> | |
decltype(auto) | max (const DenseVector< VT1, TF > &lhs, const DenseVector< VT2, TF > &rhs) |
Computes the componentwise maximum of the dense vectors lhs and rhs. More... | |
template<typename VT1 , typename VT2 , bool TF> | |
decltype(auto) | hypot (const DenseVector< VT1, TF > &lhs, const DenseVector< VT2, TF > &rhs) |
Computes the componentwise hypotenous for the dense vectors lhs and rhs. More... | |
template<typename VT1 , typename VT2 , bool TF> | |
decltype(auto) | pow (const DenseVector< VT1, TF > &lhs, const DenseVector< VT2, TF > &rhs) |
Computes the componentwise exponential value for the dense vectors lhs and rhs. More... | |
template<typename VT1 , typename VT2 , bool TF> | |
decltype(auto) | atan2 (const DenseVector< VT1, TF > &lhs, const DenseVector< VT2, TF > &rhs) |
Computes the multi-valued inverse tangent of the dense vectors lhs and rhs. More... | |
template<typename VT1 , typename VT2 , bool TF> | |
decltype(auto) | operator<< (const DenseVector< VT1, TF > &lhs, const DenseVector< VT2, TF > &rhs) |
Left-shift operator for the elementwise left-shift of a dense vector. More... | |
template<typename VT1 , typename VT2 , bool TF> | |
decltype(auto) | operator>> (const DenseVector< VT1, TF > &lhs, const DenseVector< VT2, TF > &rhs) |
Right-shift operator for the elementwise right-shift of a dense vector. More... | |
template<typename VT1 , typename VT2 , bool TF> | |
decltype(auto) | operator & (const DenseVector< VT1, TF > &lhs, const DenseVector< VT2, TF > &rhs) |
Bitwise AND operator for two dense vectors. More... | |
template<typename VT1 , typename VT2 , bool TF> | |
decltype(auto) | operator| (const DenseVector< VT1, TF > &lhs, const DenseVector< VT2, TF > &rhs) |
Bitwise OR operator for two dense vectors. More... | |
template<typename VT1 , typename VT2 , bool TF> | |
decltype(auto) | operator^ (const DenseVector< VT1, TF > &lhs, const DenseVector< VT2, TF > &rhs) |
Bitwise XOR operator for two dense vectors. More... | |
template<typename VT1 , typename VT2 , bool TF> | |
decltype(auto) | operator && (const DenseVector< VT1, TF > &lhs, const DenseVector< VT2, TF > &rhs) |
Logical AND operator for two dense vectors. More... | |
template<typename VT1 , typename VT2 , bool TF> | |
decltype(auto) | operator|| (const DenseVector< VT1, TF > &lhs, const DenseVector< VT2, TF > &rhs) |
Logical OR operator for two dense vectors. More... | |
template<typename VT1 , typename VT2 , bool TF> | |
decltype(auto) | operator * (const DenseVector< VT1, TF > &lhs, const DenseVector< VT2, TF > &rhs) |
Multiplication operator for the componentwise product of two dense vectors ( ![]() | |
template<typename VT1 , typename VT2 > | |
decltype(auto) | operator * (const DenseVector< VT1, false > &lhs, const DenseVector< VT2, true > &rhs) |
Multiplication operator for the outer product of two dense vectors ( ![]() | |
template<typename VT1 , typename VT2 , bool TF> | |
decltype(auto) | operator- (const DenseVector< VT1, TF > &lhs, const DenseVector< VT2, TF > &rhs) |
Subtraction operator for the subtraction of two dense vectors ( ![]() | |
template<typename VT , bool TF> | |
decltype(auto) | eval (const DenseVector< VT, TF > &dv) |
Forces the evaluation of the given dense vector expression dv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | expand (const DenseVector< VT, TF > &dv, size_t expansion) |
Expansion of the given dense vector. More... | |
template<size_t E, typename VT , bool TF> | |
decltype(auto) | expand (const DenseVector< VT, TF > &dv) |
Expansion of the given dense vector. More... | |
template<typename VT , bool TF, typename OP > | |
decltype(auto) | map (const DenseVector< VT, TF > &dv, OP op) |
Evaluates the given custom operation on each single element of the dense vector dv. More... | |
template<typename VT , bool TF, typename OP > | |
decltype(auto) | forEach (const DenseVector< VT, TF > &dv, OP op) |
Evaluates the given custom operation on each single element of the dense vector dv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | abs (const DenseVector< VT, TF > &dv) |
Applies the abs() function to each single element of the dense vector dv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | sign (const DenseVector< VT, TF > &dv) |
Applies the sign() function to each single element of the dense vector dv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | floor (const DenseVector< VT, TF > &dv) |
Applies the floor() function to each single element of the dense vector dv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | ceil (const DenseVector< VT, TF > &dv) |
Applies the ceil() function to each single element of the dense vector dv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | trunc (const DenseVector< VT, TF > &dv) |
Applies the trunc() function to each single element of the dense vector dv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | round (const DenseVector< VT, TF > &dv) |
Applies the round() function to each single element of the dense vector dv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | conj (const DenseVector< VT, TF > &dv) |
Returns a vector containing the complex conjugate of each single element of dv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | ctrans (const DenseVector< VT, TF > &dv) |
Returns the conjugate transpose vector of dv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | real (const DenseVector< VT, TF > &dv) |
Returns a vector containing the real part of each single element of dv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | imag (const DenseVector< VT, TF > &dv) |
Returns a vector containing the imaginary part of each single element of dv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | sqrt (const DenseVector< VT, TF > &dv) |
Computes the square root of each single element of the dense vector dv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | invsqrt (const DenseVector< VT, TF > &dv) |
Computes the inverse square root of each single element of the dense vector dv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | cbrt (const DenseVector< VT, TF > &dv) |
Computes the cubic root of each single element of the dense vector dv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | invcbrt (const DenseVector< VT, TF > &dv) |
Computes the inverse cubic root of each single element of the dense vector dv. More... | |
template<typename VT , bool TF, typename DT > | |
decltype(auto) | clamp (const DenseVector< VT, TF > &dv, const DT &min, const DT &max) |
Restricts each single element of the dense vector dv to the range ![]() | |
template<typename VT , bool TF, typename ST , EnableIf_t< IsNumeric_v< ST > > * = nullptr> | |
decltype(auto) | pow (const DenseVector< VT, TF > &dv, ST exp) |
Computes the exponential value for each single element of the dense vector dv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | exp (const DenseVector< VT, TF > &dv) |
Computes ![]() | |
template<typename VT , bool TF> | |
decltype(auto) | exp2 (const DenseVector< VT, TF > &dv) |
Computes ![]() | |
template<typename VT , bool TF> | |
decltype(auto) | exp10 (const DenseVector< VT, TF > &dv) |
Computes ![]() | |
template<typename VT , bool TF> | |
decltype(auto) | log (const DenseVector< VT, TF > &dv) |
Computes the natural logarithm for each single element of the dense vector dv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | log2 (const DenseVector< VT, TF > &dv) |
Computes the binary logarithm for each single element of the dense vector dv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | log10 (const DenseVector< VT, TF > &dv) |
Computes the common logarithm for each single element of the dense vector dv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | sin (const DenseVector< VT, TF > &dv) |
Computes the sine for each single element of the dense vector dv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | asin (const DenseVector< VT, TF > &dv) |
Computes the inverse sine for each single element of the dense vector dv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | sinh (const DenseVector< VT, TF > &dv) |
Computes the hyperbolic sine for each single element of the dense vector dv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | asinh (const DenseVector< VT, TF > &dv) |
Computes the inverse hyperbolic sine for each single element of the dense vector dv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | cos (const DenseVector< VT, TF > &dv) |
Computes the cosine for each single element of the dense vector dv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | acos (const DenseVector< VT, TF > &dv) |
Computes the inverse cosine for each single element of the dense vector dv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | cosh (const DenseVector< VT, TF > &dv) |
Computes the hyperbolic cosine for each single element of the dense vector dv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | acosh (const DenseVector< VT, TF > &dv) |
Computes the inverse hyperbolic cosine for each single element of the dense vector dv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | tan (const DenseVector< VT, TF > &dv) |
Computes the tangent for each single element of the dense vector dv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | atan (const DenseVector< VT, TF > &dv) |
Computes the inverse tangent for each single element of the dense vector dv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | tanh (const DenseVector< VT, TF > &dv) |
Computes the hyperbolic tangent for each single element of the dense vector dv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | atanh (const DenseVector< VT, TF > &dv) |
Computes the inverse hyperbolic tangent for each single element of the dense vector dv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | erf (const DenseVector< VT, TF > &dv) |
Computes the error function for each single element of the dense vector dv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | erfc (const DenseVector< VT, TF > &dv) |
Computes the complementary error function for each single element of the dense vector dv. More... | |
template<typename VT , bool TF, typename ST , EnableIf_t< IsNumeric_v< ST > > * = nullptr> | |
decltype(auto) | operator+ (const DenseVector< VT, TF > &vec, ST scalar) |
Addition operator for the addition of a dense vector and a scalar value ( ![]() | |
template<typename ST , typename VT , bool TF, EnableIf_t< IsNumeric_v< ST > > * = nullptr> | |
decltype(auto) | operator+ (ST scalar, const DenseVector< VT, TF > &vec) |
Addition operator for the addition of a scalar value and a dense vector ( ![]() | |
template<typename VT , bool TF, typename ST , EnableIf_t< IsNumeric_v< ST > > * = nullptr> | |
decltype(auto) | operator- (const DenseVector< VT, TF > &vec, ST scalar) |
Subtraction operator for the subtraction of a dense vector and a scalar value ( ![]() | |
template<typename ST , typename VT , bool TF, EnableIf_t< IsNumeric_v< ST > > * = nullptr> | |
decltype(auto) | operator- (ST scalar, const DenseVector< VT, TF > &vec) |
Subtraction operator for the subtraction of a scalar value and a dense vector ( ![]() | |
template<typename ST , typename VT , bool TF, EnableIf_t< IsNumeric_v< ST > > * = nullptr> | |
decltype(auto) | operator/ (ST scalar, const DenseVector< VT, TF > &vec) |
Division operator for the division of a scalar value and a dense vector ( ![]() | |
template<typename VT , bool TF> | |
decltype(auto) | operator<< (const DenseVector< VT, TF > &vec, int count) |
Left-shift operator for the uniform left-shift of a dense vector. More... | |
template<typename VT , bool TF> | |
decltype(auto) | operator>> (const DenseVector< VT, TF > &vec, int count) |
Right-shift operator for the uniform right-shift of a dense vector. More... | |
template<typename VT , bool TF, typename ST , EnableIf_t< IsNumeric_v< ST > > * = nullptr> | |
decltype(auto) | operator & (const DenseVector< VT, TF > &vec, ST scalar) |
Bitwise AND operator for the bitwise AND of a dense vector and a scalar value. More... | |
template<typename VT , bool TF, typename ST , EnableIf_t< IsNumeric_v< ST > > * = nullptr> | |
decltype(auto) | operator| (const DenseVector< VT, TF > &vec, ST scalar) |
Bitwise OR operator for the bitwise OR of a dense vector and a scalar value. More... | |
template<typename VT , bool TF, typename ST , EnableIf_t< IsNumeric_v< ST > > * = nullptr> | |
decltype(auto) | operator^ (const DenseVector< VT, TF > &vec, ST scalar) |
Bitwise XOR operator for the bitwise XOR of a dense vector and a scalar value. More... | |
template<typename VT , bool TF> | |
decltype(auto) | operator! (const DenseVector< VT, TF > &vec) |
Logical NOT operator for the logical NOT of a dense vector. More... | |
template<typename VT , bool TF> | |
decltype(auto) | mean (const DenseVector< VT, TF > &dv) |
Computes the (arithmetic) mean for the given dense vector. More... | |
template<typename VT , bool TF> | |
decltype(auto) | norm (const DenseVector< VT, TF > &dv) |
Computes the L2 norm for the given dense vector. More... | |
template<typename VT , bool TF> | |
decltype(auto) | sqrNorm (const DenseVector< VT, TF > &dv) |
Computes the squared L2 norm for the given dense vector. More... | |
template<typename VT , bool TF> | |
decltype(auto) | l1Norm (const DenseVector< VT, TF > &dv) |
Computes the L1 norm for the given dense vector. More... | |
template<typename VT , bool TF> | |
decltype(auto) | l2Norm (const DenseVector< VT, TF > &dv) |
Computes the L2 norm for the given dense vector. More... | |
template<typename VT , bool TF> | |
decltype(auto) | l3Norm (const DenseVector< VT, TF > &dv) |
Computes the L3 norm for the given dense vector. More... | |
template<typename VT , bool TF> | |
decltype(auto) | l4Norm (const DenseVector< VT, TF > &dv) |
Computes the L4 norm for the given dense vector. More... | |
template<typename VT , bool TF, typename ST > | |
decltype(auto) | lpNorm (const DenseVector< VT, TF > &dv, ST p) |
Computes the Lp norm for the given dense vector. More... | |
template<size_t P, typename VT , bool TF> | |
decltype(auto) | lpNorm (const DenseVector< VT, TF > &dv) |
Computes the Lp norm for the given dense vector. More... | |
template<typename VT , bool TF> | |
decltype(auto) | linfNorm (const DenseVector< VT, TF > &dv) |
Computes the infinity norm for the given dense vector. More... | |
template<typename VT , bool TF> | |
decltype(auto) | maxNorm (const DenseVector< VT, TF > &dv) |
Computes the maximum norm for the given dense vector. More... | |
template<typename VT , bool TF> | |
decltype(auto) | sqrLength (const DenseVector< VT, TF > &dv) |
Calculation of the square length (magnitude) of the dense vector ![]() | |
template<typename VT , bool TF> | |
decltype(auto) | length (const DenseVector< VT, TF > &dv) |
Calculation of the length (magnitude) of the dense vector ![]() | |
template<typename VT , bool TF, typename OP > | |
decltype(auto) | reduce (const DenseVector< VT, TF > &dv, OP op) |
Performs a custom reduction operation on the given dense vector. More... | |
template<typename VT , bool TF> | |
decltype(auto) | sum (const DenseVector< VT, TF > &dv) |
Reduces the given dense vector by means of addition. More... | |
template<typename VT , bool TF> | |
decltype(auto) | prod (const DenseVector< VT, TF > &dv) |
Reduces the given dense vector by means of multiplication. More... | |
template<typename VT , bool TF> | |
decltype(auto) | min (const DenseVector< VT, TF > &dv) |
Returns the smallest element of the dense vector. More... | |
template<typename VT , bool TF> | |
decltype(auto) | max (const DenseVector< VT, TF > &dv) |
Returns the largest element of the dense vector. More... | |
template<typename VT , bool TF> | |
size_t | argmin (const DenseVector< VT, TF > &dv) |
Returns the index of the first smallest element of the dense vector. More... | |
template<typename VT , bool TF> | |
size_t | argmax (const DenseVector< VT, TF > &dv) |
Returns the index of the first largest element of the dense vector. More... | |
template<typename VT , typename ST , bool TF, EnableIf_t< IsNumeric_v< ST > > * = nullptr> | |
decltype(auto) | operator/ (const DenseVector< VT, TF > &vec, ST scalar) |
Division operator for the divison of a dense vector by a scalar value ( ![]() | |
template<typename VT , bool TF> | |
decltype(auto) | operator- (const DenseVector< VT, TF > &dv) |
Unary minus operator for the negation of a dense vector ( ![]() | |
template<typename VT , typename ST , bool TF, EnableIf_t< IsNumeric_v< ST > > * = nullptr> | |
decltype(auto) | operator * (const DenseVector< VT, TF > &vec, ST scalar) |
Multiplication operator for the multiplication of a dense vector and a scalar value ( ![]() | |
template<typename ST , typename VT , bool TF, EnableIf_t< IsNumeric_v< ST > > * = nullptr> | |
decltype(auto) | operator * (ST scalar, const DenseVector< VT, TF > &vec) |
Multiplication operator for the multiplication of a scalar value and a dense vector ( ![]() | |
template<typename VT , bool TF> | |
decltype(auto) | normalize (const DenseVector< VT, TF > &vec) |
Normalization of the dense vector ( ![]() | |
template<typename VT , bool TF> | |
decltype(auto) | serial (const DenseVector< VT, TF > &dv) |
Forces the serial evaluation of the given dense vector expression dv. More... | |
template<typename VT , bool TF> | |
auto | softmax (const DenseVector< VT, TF > &dv) |
Computes the softmax function for the given dense vector. More... | |
template<typename VT , bool TF> | |
decltype(auto) | stddev (const DenseVector< VT, TF > &dv) |
Computes the standard deviation for the given dense vector. More... | |
template<typename VT1 , typename VT2 , bool TF> | |
decltype(auto) | operator+ (const DenseVector< VT1, TF > &lhs, const SparseVector< VT2, TF > &rhs) |
Addition operator for the addition of a dense vector and a sparse vector ( ![]() | |
template<typename VT1 , typename VT2 , bool TF> | |
decltype(auto) | operator+ (const SparseVector< VT1, TF > &lhs, const DenseVector< VT2, TF > &rhs) |
Addition operator for the addition of a sparse vector and a dense vector ( ![]() | |
template<typename VT1 , typename VT2 , bool TF> | |
decltype(auto) | operator% (const DenseVector< VT1, TF > &lhs, const SparseVector< VT2, TF > &rhs) |
Operator for the cross product of a dense vector and a sparse vector ( ![]() | |
template<typename VT1 , typename VT2 , bool TF> | |
decltype(auto) | cross (const DenseVector< VT1, TF > &lhs, const SparseVector< VT2, TF > &rhs) |
Cross product of a dense vector and a sparse vector ( ![]() | |
template<typename VT1 , bool TF1, typename VT2 , bool TF2> | |
bool | operator== (const DenseVector< VT1, TF1 > &lhs, const SparseVector< VT2, TF2 > &rhs) |
Equality operator for the comparison of a dense vector and a sparse vector. More... | |
template<typename VT1 , bool TF1, typename VT2 , bool TF2> | |
bool | operator== (const SparseVector< VT1, TF1 > &lhs, const DenseVector< VT2, TF2 > &rhs) |
Equality operator for the comparison of a sparse vector and a dense vector. More... | |
template<typename VT1 , bool TF1, typename VT2 , bool TF2> | |
bool | operator!= (const DenseVector< VT1, TF1 > &lhs, const SparseVector< VT2, TF2 > &rhs) |
Inequality operator for the comparison of a dense vector and a sparse vector. More... | |
template<typename VT1 , bool TF1, typename VT2 , bool TF2> | |
bool | operator!= (const SparseVector< VT1, TF1 > &lhs, const DenseVector< VT2, TF2 > &rhs) |
Inequality operator for the comparison of a sparse vector and a dense vector. More... | |
template<typename VT1 , typename VT2 > | |
decltype(auto) | operator * (const DenseVector< VT1, true > &lhs, const SparseVector< VT2, false > &rhs) |
Multiplication operator for the scalar product (inner product) of a dense and a sparse vector ( ![]() | |
template<typename VT1 , typename VT2 , bool TF> | |
decltype(auto) | kron (const DenseVector< VT1, TF > &lhs, const SparseVector< VT2, TF > &rhs) |
Computes the Kronecker product of a dense vector and a sparse vector ( ![]() | |
template<typename VT1 , typename VT2 , bool TF> | |
decltype(auto) | operator * (const DenseVector< VT1, TF > &lhs, const SparseVector< VT2, TF > &rhs) |
Multiplication operator for the componentwise product of a dense vector and a sparse vector ( ![]() | |
template<typename VT1 , typename VT2 > | |
decltype(auto) | operator * (const DenseVector< VT1, false > &lhs, const SparseVector< VT2, true > &rhs) |
Multiplication operator for the dense vector-sparse vector outer product ( ![]() | |
template<typename VT1 , typename VT2 , bool TF> | |
decltype(auto) | operator- (const DenseVector< VT1, TF > &lhs, const SparseVector< VT2, TF > &rhs) |
Subtraction operator for the subtraction of a dense vector and a sparse vector ( ![]() | |
template<typename VT , bool TF> | |
decltype(auto) | trans (const DenseVector< VT, TF > &dv) |
Calculation of the transpose of the given dense vector. More... | |
template<bool TTF, typename VT , bool TF> | |
decltype(auto) | transTo (const DenseVector< VT, TF > &dv) |
Conditional calculation of the transpose of the given dense vector. More... | |
template<typename VT , bool TF> | |
decltype(auto) | var (const DenseVector< VT, TF > &dv) |
Computes the variance for the given dense vector. More... | |
template<typename VT1 , typename VT2 , bool TF> | |
decltype(auto) | operator+ (const SparseVector< VT1, TF > &lhs, const SparseVector< VT2, TF > &rhs) |
Addition operator for the addition of two sparse vectors ( ![]() | |
template<typename MT1 , typename MT2 > | |
decltype(auto) | operator+ (const DenseMatrix< MT1, true > &lhs, const SparseMatrix< MT2, false > &rhs) |
Addition operator for the addition of a column-major dense matrix and a row-major sparse matrix ( ![]() | |
template<typename MT1 , typename MT2 > | |
decltype(auto) | operator+ (const SparseMatrix< MT1, false > &lhs, const DenseMatrix< MT2, true > &rhs) |
Addition operator for the addition of a row-major sparse matrix and a column-major dense matrix ( ![]() | |
template<typename MT1 , typename MT2 > | |
decltype(auto) | operator+ (const SparseMatrix< MT1, false > &lhs, const SparseMatrix< MT2, false > &rhs) |
Addition operator for the addition of two row-major sparse matrices ( ![]() | |
template<typename MT1 , typename MT2 > | |
decltype(auto) | operator+ (const SparseMatrix< MT1, false > &lhs, const SparseMatrix< MT2, true > &rhs) |
Addition operator for the addition of a row-major and a column-major sparse matrix ( ![]() | |
template<typename MT1 , typename MT2 > | |
decltype(auto) | operator+ (const SparseMatrix< MT1, true > &lhs, const SparseMatrix< MT2, false > &rhs) |
Addition operator for the addition of a column-major and a row-major sparse matrix ( ![]() | |
template<typename MT1 , typename MT2 > | |
decltype(auto) | operator+ (const SparseMatrix< MT1, true > &lhs, const SparseMatrix< MT2, true > &rhs) |
Addition operator for the addition of two column-major sparse matrices ( ![]() | |
template<typename MT1 , typename MT2 > | |
decltype(auto) | operator- (const DenseMatrix< MT1, true > &lhs, const SparseMatrix< MT2, false > &rhs) |
Subtraction operator for the subtraction of a column-major dense matrix and a row-major sparse matrix ( ![]() | |
template<typename MT1 , typename MT2 , bool SO> | |
decltype(auto) | operator- (const SparseMatrix< MT1, SO > &lhs, const DenseMatrix< MT2, SO > &rhs) |
Subtraction operator for the subtraction of a sparse matrix and a dense matrix with identical storage order ( ![]() | |
template<typename MT1 , typename MT2 > | |
decltype(auto) | operator- (const SparseMatrix< MT1, false > &lhs, const DenseMatrix< MT2, true > &rhs) |
Subtraction operator for the subtraction of a row-major sparse matrix and a column-major dense matrix ( ![]() | |
template<typename MT1 , typename MT2 > | |
decltype(auto) | operator- (const SparseMatrix< MT1, true > &lhs, const DenseMatrix< MT2, false > &rhs) |
Subtraction operator for the subtraction of a column-major sparse matrix and a row-major dense matrix ( ![]() | |
template<typename MT1 , typename MT2 > | |
decltype(auto) | operator- (const SparseMatrix< MT1, false > &lhs, const SparseMatrix< MT2, false > &rhs) |
Subtraction operator for the subtraction of two row-major sparse matrices ( ![]() | |
template<typename MT1 , typename MT2 > | |
decltype(auto) | operator- (const SparseMatrix< MT1, false > &lhs, const SparseMatrix< MT2, true > &rhs) |
Subtraction operator for the subtraction of a row-major and a column-major sparse matrix ( ![]() | |
template<typename MT1 , typename MT2 > | |
decltype(auto) | operator- (const SparseMatrix< MT1, true > &lhs, const SparseMatrix< MT2, false > &rhs) |
Subtraction operator for the subtraction of a column-major and a row-major sparse matrix ( ![]() | |
template<typename MT1 , typename MT2 > | |
decltype(auto) | operator- (const SparseMatrix< MT1, true > &lhs, const SparseMatrix< MT2, true > &rhs) |
Subtraction operator for the subtraction of two column-major sparse matrices ( ![]() | |
template<typename VT1 , typename VT2 , bool TF> | |
decltype(auto) | operator * (const SparseVector< VT1, TF > &lhs, const DenseVector< VT2, TF > &rhs) |
Multiplication operator for the componentwise product of a sparse vector and a dense vector ( ![]() | |
template<typename VT1 , typename VT2 > | |
decltype(auto) | operator * (const SparseVector< VT1, true > &lhs, const DenseVector< VT2, false > &rhs) |
Multiplication operator for the scalar product (inner product) of a sparse and a dense vector ( ![]() | |
template<typename VT1 , typename VT2 > | |
decltype(auto) | operator * (const SparseVector< VT1, false > &lhs, const DenseVector< VT2, true > &rhs) |
Multiplication operator for the sparse vector-dense vector outer product ( ![]() | |
template<typename VT1 , typename VT2 , bool TF> | |
decltype(auto) | operator * (const SparseVector< VT1, TF > &lhs, const SparseVector< VT2, TF > &rhs) |
Multiplication operator for the componentwise multiplication of two sparse vectors ( ![]() | |
template<typename VT1 , typename VT2 > | |
decltype(auto) | operator * (const SparseVector< VT1, true > &lhs, const SparseVector< VT2, false > &rhs) |
Multiplication operator for the scalar product (inner product) of two sparse vectors ( ![]() | |
template<typename VT1 , typename VT2 > | |
decltype(auto) | operator * (const SparseVector< VT1, false > &lhs, const SparseVector< VT2, true > &rhs) |
Multiplication operator for the sparse vector-sparse vector outer product ( ![]() | |
template<typename MT , typename VT > | |
decltype(auto) | operator * (const DenseMatrix< MT, true > &mat, const DenseVector< VT, false > &vec) |
Multiplication operator for the multiplication of a column-major dense matrix and a dense vector ( ![]() | |
template<typename MT , typename VT > | |
decltype(auto) | operator * (const DenseMatrix< MT, true > &mat, const SparseVector< VT, false > &vec) |
Multiplication operator for the multiplication of a column-major dense matrix and a sparse vector ( ![]() | |
template<typename MT , typename VT > | |
decltype(auto) | operator * (const SparseMatrix< MT, false > &mat, const DenseVector< VT, false > &vec) |
Multiplication operator for the multiplication of a row-major sparse matrix and a dense vector ( ![]() | |
template<typename MT , typename VT > | |
decltype(auto) | operator * (const SparseMatrix< MT, true > &mat, const DenseVector< VT, false > &vec) |
Multiplication operator for the multiplication of a column-major sparse matrix and a dense vector ( ![]() | |
template<typename MT , typename VT > | |
decltype(auto) | operator * (const SparseMatrix< MT, false > &mat, const SparseVector< VT, false > &vec) |
Multiplication operator for the multiplication of a row-major sparse matrix and a sparse vector ( ![]() | |
template<typename MT , typename VT > | |
decltype(auto) | operator * (const SparseMatrix< MT, true > &mat, const SparseVector< VT, false > &vec) |
Multiplication operator for the multiplication of a transpose sparse matrix and a sparse vector ( ![]() | |
template<typename VT , typename MT > | |
decltype(auto) | operator * (const DenseVector< VT, true > &vec, const DenseMatrix< MT, false > &mat) |
Multiplication operator for the multiplication of a transpose dense vector and a row-major dense matrix ( ![]() | |
template<typename VT , typename MT > | |
decltype(auto) | operator * (const DenseVector< VT, true > &vec, const DenseMatrix< MT, true > &mat) |
Multiplication operator for the multiplication of a transpose dense vector and a column-major dense matrix ( ![]() | |
template<typename VT , typename MT > | |
decltype(auto) | operator * (const DenseVector< VT, true > &vec, const SparseMatrix< MT, false > &mat) |
Multiplication operator for the multiplication of a transpose dense vector and a row-major sparse matrix ( ![]() | |
template<typename VT , typename MT > | |
decltype(auto) | operator * (const DenseVector< VT, true > &vec, const SparseMatrix< MT, true > &mat) |
Multiplication operator for the multiplication of a transpose dense vector and a column-major sparse matrix ( ![]() | |
template<typename VT , typename MT > | |
decltype(auto) | operator * (const SparseVector< VT, true > &vec, const DenseMatrix< MT, false > &mat) |
Multiplication operator for the multiplication of a transpose sparse vector and a row-major dense matrix ( ![]() | |
template<typename VT , typename MT > | |
decltype(auto) | operator * (const SparseVector< VT, true > &vec, const DenseMatrix< MT, true > &mat) |
Multiplication operator for the multiplication of a transpose sparse vector and a column-major dense matrix ( ![]() | |
template<typename VT , typename MT > | |
decltype(auto) | operator * (const SparseVector< VT, true > &vec, const SparseMatrix< MT, false > &mat) |
Multiplication operator for the multiplication of a transpose sparse vector and a row-major sparse matrix ( ![]() | |
template<typename VT , typename MT > | |
decltype(auto) | operator * (const SparseVector< VT, true > &vec, const SparseMatrix< MT, true > &mat) |
Multiplication operator for the multiplication of a transpose sparse vector and a column-major sparse matrix ( ![]() | |
template<typename MT1 , typename MT2 > | |
decltype(auto) | operator * (const DenseMatrix< MT1, true > &lhs, const DenseMatrix< MT2, false > &rhs) |
Multiplication operator for the multiplication of a column-major dense matrix and a row-major dense matrix ( ![]() | |
template<typename MT1 , typename MT2 > | |
decltype(auto) | operator * (const DenseMatrix< MT1, true > &lhs, const DenseMatrix< MT2, true > &rhs) |
Multiplication operator for the multiplication of two column-major dense matrices ( ![]() | |
template<typename MT1 , typename MT2 > | |
decltype(auto) | operator * (const DenseMatrix< MT1, true > &lhs, const SparseMatrix< MT2, false > &rhs) |
Multiplication operator for the multiplication of a column-major dense matrix and a row-major sparse matrix ( ![]() | |
template<typename MT1 , typename MT2 > | |
decltype(auto) | operator * (const DenseMatrix< MT1, true > &lhs, const SparseMatrix< MT2, true > &rhs) |
Multiplication operator for the multiplication of a column-major dense matrix and a column-major sparse matrix ( ![]() | |
template<typename MT1 , typename MT2 > | |
decltype(auto) | operator * (const SparseMatrix< MT1, false > &lhs, const DenseMatrix< MT2, false > &rhs) |
Multiplication operator for the multiplication of a row-major sparse matrix and a row-major dense matrix ( ![]() | |
template<typename MT1 , typename MT2 > | |
decltype(auto) | operator * (const SparseMatrix< MT1, false > &lhs, const DenseMatrix< MT2, true > &rhs) |
Multiplication operator for the multiplication of a row-major sparse matrix and a column-major dense matrix ( ![]() | |
template<typename MT1 , typename MT2 > | |
decltype(auto) | operator * (const SparseMatrix< MT1, true > &lhs, const DenseMatrix< MT2, false > &rhs) |
Multiplication operator for the multiplication of a column-major sparse matrix and a row-major dense matrix ( ![]() | |
template<typename MT1 , typename MT2 > | |
decltype(auto) | operator * (const SparseMatrix< MT1, true > &lhs, const DenseMatrix< MT2, true > &rhs) |
Multiplication operator for the multiplication of a column-major sparse matrix and a column-major dense matrix ( ![]() | |
template<typename MT1 , typename MT2 > | |
decltype(auto) | operator * (const SparseMatrix< MT1, false > &lhs, const SparseMatrix< MT2, false > &rhs) |
Multiplication operator for the multiplication of two row-major sparse matrices ( ![]() | |
template<typename MT1 , typename MT2 > | |
decltype(auto) | operator * (const SparseMatrix< MT1, false > &lhs, const SparseMatrix< MT2, true > &rhs) |
Multiplication operator for the multiplication of a row-major sparse matrix and a column-major sparse matrix ( ![]() | |
template<typename MT1 , typename MT2 > | |
decltype(auto) | operator * (const SparseMatrix< MT1, true > &lhs, const SparseMatrix< MT2, false > &rhs) |
Multiplication operator for the multiplication of a column-major sparse matrix and a row-major sparse matrix ( ![]() | |
template<typename MT1 , typename MT2 > | |
decltype(auto) | operator * (const SparseMatrix< MT1, true > &lhs, const SparseMatrix< MT2, true > &rhs) |
Multiplication operator for the multiplication of two column-major sparse matrices ( ![]() | |
template<typename VT1 , typename VT2 , bool TF> | |
decltype(auto) | operator/ (const SparseVector< VT1, TF > &lhs, const DenseVector< VT2, TF > &rhs) |
Division operator for the componentwise division of a sparse vector and a dense vector ( ![]() | |
template<typename VT1 , typename VT2 , bool TF> | |
decltype(auto) | operator% (const SparseVector< VT1, TF > &lhs, const DenseVector< VT2, TF > &rhs) |
Operator for the cross product of a sparse vector and a dense vector ( ![]() | |
template<typename VT1 , typename VT2 , bool TF> | |
decltype(auto) | operator% (const SparseVector< VT1, TF > &lhs, const SparseVector< VT2, TF > &rhs) |
Operator for the cross product of two sparse vectors ( ![]() | |
template<typename MT1 , typename MT2 > | |
decltype(auto) | operator% (const SparseMatrix< MT1, false > &lhs, const DenseMatrix< MT2, false > &rhs) |
Operator for the Schur product of a row-major sparse matrix and a row-major dense matrix ( ![]() | |
template<typename MT1 , typename MT2 > | |
decltype(auto) | operator% (const SparseMatrix< MT1, false > &lhs, const DenseMatrix< MT2, true > &rhs) |
Operator for the Schur product of a row-major sparse matrix and a column-major dense matrix ( ![]() | |
template<typename MT1 , typename MT2 > | |
decltype(auto) | operator% (const SparseMatrix< MT1, true > &lhs, const DenseMatrix< MT2, false > &rhs) |
Operator for the Schur product of a column-major sparse matrix and a row-major dense matrix ( ![]() | |
template<typename MT1 , typename MT2 > | |
decltype(auto) | operator% (const SparseMatrix< MT1, true > &lhs, const DenseMatrix< MT2, true > &rhs) |
Operator for the Schur product of a column-major sparse matrix and a column-major dense matrix ( ![]() | |
template<typename MT1 , typename MT2 > | |
decltype(auto) | operator% (const SparseMatrix< MT1, false > &lhs, const SparseMatrix< MT2, false > &rhs) |
Operator for the Schur product of two row-major sparse matrices ( ![]() | |
template<typename MT1 , typename MT2 > | |
decltype(auto) | operator% (const SparseMatrix< MT1, false > &lhs, const SparseMatrix< MT2, true > &rhs) |
Operator for the Schur product of a row-major and a column-major sparse matrix ( ![]() | |
template<typename MT1 , typename MT2 > | |
decltype(auto) | operator% (const SparseMatrix< MT1, true > &lhs, const SparseMatrix< MT2, false > &rhs) |
Operator for the Schur product of a column-major and a row-major sparse matrix ( ![]() | |
template<typename MT1 , typename MT2 > | |
decltype(auto) | operator% (const SparseMatrix< MT1, true > &lhs, const SparseMatrix< MT2, true > &rhs) |
Operator for the Schur product of two column-major sparse matrices ( ![]() | |
template<typename VT1 , typename VT2 , bool TF> | |
decltype(auto) | kron (const SparseVector< VT1, TF > &lhs, const DenseVector< VT2, TF > &rhs) |
Computes the Kronecker product of a sparse vector and a vector vector ( ![]() | |
template<typename VT1 , typename VT2 , bool TF> | |
decltype(auto) | kron (const SparseVector< VT1, TF > &lhs, const SparseVector< VT2, TF > &rhs) |
Computes the Kronecker product of two sparse vectors ( ![]() | |
template<typename MT1 , bool SO1, typename MT2 , bool SO2> | |
decltype(auto) | kron (const SparseMatrix< MT1, SO1 > &lhs, const DenseMatrix< MT2, SO2 > &rhs) |
Computes the Kronecker product of a sparse matrix and a dense matrix ( ![]() | |
template<typename MT1 , typename MT2 > | |
decltype(auto) | kron (const SparseMatrix< MT1, false > &lhs, const SparseMatrix< MT2, false > &rhs) |
Computes the Kronecker product of two row-major sparse matrices ( ![]() | |
template<typename MT1 , typename MT2 > | |
decltype(auto) | kron (const SparseMatrix< MT1, false > &lhs, const SparseMatrix< MT2, true > &rhs) |
Operator for the Kronecker product of a row-major and a column-major sparse matrix ( ![]() | |
template<typename MT1 , typename MT2 > | |
decltype(auto) | kron (const SparseMatrix< MT1, true > &lhs, const SparseMatrix< MT2, false > &rhs) |
Operator for the Kronecker product of a column-major and a row-major sparse matrix ( ![]() | |
template<typename MT1 , typename MT2 > | |
decltype(auto) | kron (const SparseMatrix< MT1, true > &lhs, const SparseMatrix< MT2, true > &rhs) |
Computes the Kronecker product of two column-major sparse matrices ( ![]() | |
template<typename VT , bool TF> | |
decltype(auto) | trans (const SparseVector< VT, TF > &sv) |
Calculation of the transpose of the given sparse vector. More... | |
template<typename MT , bool SO> | |
decltype(auto) | trans (const SparseMatrix< MT, SO > &sm) |
Calculation of the transpose of the given sparse matrix. More... | |
template<bool TTF, typename VT , bool TF> | |
decltype(auto) | transTo (const SparseVector< VT, TF > &sv) |
Conditional calculation of the transpose of the given sparse vector. More... | |
template<typename VT , bool TF> | |
decltype(auto) | eval (const SparseVector< VT, TF > &sv) |
Forces the evaluation of the given sparse vector expression sv. More... | |
template<typename MT , bool SO> | |
decltype(auto) | eval (const SparseMatrix< MT, SO > &sm) |
Forces the evaluation of the given sparse matrix expression sm. More... | |
template<typename VT , bool TF> | |
decltype(auto) | serial (const SparseVector< VT, TF > &sv) |
Forces the serial evaluation of the given sparse vector expression sv. More... | |
template<typename MT , bool SO> | |
decltype(auto) | serial (const SparseMatrix< MT, SO > &sm) |
Forces the serial evaluation of the given sparse matrix expression sm. More... | |
template<typename VT , bool TF, typename OP > | |
decltype(auto) | map (const SparseVector< VT, TF > &sv, OP op) |
Evaluates the given custom operation on each non-zero element of the sparse vector sv. More... | |
template<typename MT , bool SO, typename OP > | |
decltype(auto) | map (const SparseMatrix< MT, SO > &sm, OP op) |
Evaluates the given custom operation on each non-zero element of the sparse matrix sm. More... | |
template<typename VT , bool TF, typename OP > | |
decltype(auto) | reduce (const SparseVector< VT, TF > &sv, OP op) |
Performs a custom reduction operation on the given sparse vector. More... | |
template<typename MT , bool SO, typename OP > | |
decltype(auto) | reduce (const SparseMatrix< MT, SO > &sm, OP op) |
Performs a custom reduction operation on the given sparse matrix. More... | |
template<size_t RF, typename MT , bool SO, typename OP > | |
decltype(auto) | reduce (const SparseMatrix< MT, SO > &sm, OP op) |
Performs a custom reduction operation on the given sparse matrix. More... | |
template<typename VT , bool TF> | |
decltype(auto) | expand (const SparseVector< VT, TF > &sv, size_t expansion) |
Expansion of the given sparse vector. More... | |
template<size_t E, typename VT , bool TF> | |
decltype(auto) | expand (const SparseVector< VT, TF > &sv) |
Expansion of the given sparse vector. More... | |
template<typename VT , bool TF> | |
decltype(auto) | mean (const SparseVector< VT, TF > &sv) |
Computes the (arithmetic) mean for the given sparse vector. More... | |
template<typename MT , bool SO> | |
decltype(auto) | mean (const SparseMatrix< MT, SO > &sm) |
Computes the (arithmetic) mean for the given sparse matrix. More... | |
template<size_t RF, typename MT , bool SO> | |
decltype(auto) | mean (const SparseMatrix< MT, SO > &sm) |
Computes the row-/columnwise mean function for the given sparse matrix. More... | |
template<typename VT , bool TF> | |
decltype(auto) | var (const SparseVector< VT, TF > &sv) |
Computes the variance for the given sparse vector. More... | |
template<typename MT , bool SO> | |
decltype(auto) | var (const SparseMatrix< MT, SO > &sm) |
Computes the variance for the given sparse matrix. More... | |
template<size_t RF, typename MT , bool SO> | |
decltype(auto) | var (const SparseMatrix< MT, SO > &sm) |
Computes the row-/column-wise variance function for the given sparse matrix. More... | |
template<typename VT , bool TF> | |
decltype(auto) | stddev (const SparseVector< VT, TF > &sv) |
Computes the standard deviation for the given sparse vector. More... | |
template<typename MT , bool SO> | |
decltype(auto) | stddev (const SparseMatrix< MT, SO > &sm) |
Computes the standard deviation for the given sparse matrix. More... | |
template<size_t RF, typename MT , bool SO> | |
decltype(auto) | stddev (const SparseMatrix< MT, SO > &sm) |
Computes the row-/columnwise standard deviation function for the given sparse matrix. More... | |
template<typename MT , bool SO> | |
decltype(auto) | declsym (const SparseMatrix< MT, SO > &sm) |
Declares the given sparse matrix expression sm as symmetric. More... | |
template<typename MT , bool SO> | |
decltype(auto) | declherm (const SparseMatrix< MT, SO > &sm) |
Declares the given sparse matrix expression sm as Hermitian. More... | |
template<typename MT , bool SO> | |
decltype(auto) | decllow (const SparseMatrix< MT, SO > &sm) |
Declares the given sparse matrix expression sm as lower. More... | |
template<typename MT , bool SO> | |
decltype(auto) | declupp (const SparseMatrix< MT, SO > &sm) |
Declares the given sparse matrix expression sm as upper. More... | |
template<typename MT , bool SO> | |
decltype(auto) | decldiag (const SparseMatrix< MT, SO > &sm) |
Declares the given sparse matrix expression sm as diagonal. More... | |
template<typename MT , bool SO> | |
BLAZE_ALWAYS_INLINE MT::Iterator | begin (Matrix< MT, SO > &matrix, size_t i) |
Returns an iterator to the first element of row/column i. More... | |
template<typename MT , bool SO> | |
BLAZE_ALWAYS_INLINE MT::ConstIterator | begin (const Matrix< MT, SO > &matrix, size_t i) |
Returns an iterator to the first element of row/column i. More... | |
template<typename MT , bool SO> | |
BLAZE_ALWAYS_INLINE MT::ConstIterator | cbegin (const Matrix< MT, SO > &matrix, size_t i) |
Returns an iterator to the first element of row/column i. More... | |
template<typename MT , bool SO> | |
BLAZE_ALWAYS_INLINE MT::Iterator | end (Matrix< MT, SO > &matrix, size_t i) |
Returns an iterator just past the last element of row/column i. More... | |
template<typename MT , bool SO> | |
BLAZE_ALWAYS_INLINE MT::ConstIterator | end (const Matrix< MT, SO > &matrix, size_t i) |
Returns an iterator just past the last element of row/column i. More... | |
template<typename MT , bool SO> | |
BLAZE_ALWAYS_INLINE MT::ConstIterator | cend (const Matrix< MT, SO > &matrix, size_t i) |
Returns an iterator just past the last element of row/column i. More... | |
template<typename MT , bool SO> | |
BLAZE_ALWAYS_INLINE constexpr size_t | rows (const Matrix< MT, SO > &matrix) noexcept |
Returns the current number of rows of the matrix. More... | |
template<typename MT , bool SO> | |
BLAZE_ALWAYS_INLINE constexpr size_t | columns (const Matrix< MT, SO > &matrix) noexcept |
Returns the current number of columns of the matrix. More... | |
template<typename MT , bool SO> | |
BLAZE_ALWAYS_INLINE constexpr size_t | size (const Matrix< MT, SO > &matrix) noexcept |
Returns the total number of elements of the matrix. More... | |
template<typename MT , bool SO> | |
BLAZE_ALWAYS_INLINE size_t | capacity (const Matrix< MT, SO > &matrix) noexcept |
Returns the maximum capacity of the matrix. More... | |
template<typename MT , bool SO> | |
BLAZE_ALWAYS_INLINE size_t | capacity (const Matrix< MT, SO > &matrix, size_t i) noexcept |
Returns the current capacity of the specified row/column. More... | |
template<typename MT , bool SO> | |
BLAZE_ALWAYS_INLINE size_t | nonZeros (const Matrix< MT, SO > &matrix) |
Returns the total number of non-zero elements in the matrix. More... | |
template<typename MT , bool SO> | |
BLAZE_ALWAYS_INLINE size_t | nonZeros (const Matrix< MT, SO > &matrix, size_t i) |
Returns the number of non-zero elements in the specified row/column. More... | |
template<typename MT , bool SO> | |
BLAZE_ALWAYS_INLINE void | resize (Matrix< MT, SO > &matrix, size_t m, size_t n, bool preserve) |
Changing the size of the matrix. More... | |
template<typename MT , bool SO> | |
BLAZE_ALWAYS_INLINE void | shrinkToFit (Matrix< MT, SO > &matrix) |
Requesting the removal of unused capacity. More... | |
template<typename MT , bool SO> | |
BLAZE_ALWAYS_INLINE void | transpose (Matrix< MT, SO > &matrix) |
In-place transpose of the given matrix. More... | |
template<typename MT , bool SO> | |
BLAZE_ALWAYS_INLINE void | ctranspose (Matrix< MT, SO > &matrix) |
In-place conjugate transpose of the given matrix. More... | |
template<typename MT , bool SO> | |
BLAZE_ALWAYS_INLINE constexpr bool | isEmpty (const Matrix< MT, SO > &matrix) noexcept |
Checks if the given matrix is empty. More... | |
template<typename MT , bool SO> | |
BLAZE_ALWAYS_INLINE bool | isSquare (const Matrix< MT, SO > &matrix) noexcept |
Checks if the given matrix is a square matrix. More... | |
template<typename MT1 , bool SO1, typename MT2 , bool SO2> | |
BLAZE_ALWAYS_INLINE bool | isSame (const Matrix< MT1, SO1 > &a, const Matrix< MT2, SO2 > &b) noexcept |
Returns whether the two given matrices represent the same observable state. More... | |
template<typename MT , bool SO, typename OP > | |
decltype(auto) | forEach (const SparseMatrix< MT, SO > &sm, OP op) |
Evaluates the given custom operation on each non-zero element of the sparse matrix sm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | abs (const SparseMatrix< MT, SO > &sm) |
Applies the abs() function to each non-zero element of the sparse matrix sm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | sign (const SparseMatrix< MT, SO > &sm) |
Applies the sign() function to each non-zero element of the sparse matrix sm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | floor (const SparseMatrix< MT, SO > &sm) |
Applies the floor() function to each non-zero element of the sparse matrix sm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | ceil (const SparseMatrix< MT, SO > &sm) |
Applies the ceil() function to each non-zero element of the sparse matrix sm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | trunc (const SparseMatrix< MT, SO > &sm) |
Applies the trunc() function to each non-zero element of the sparse matrix sm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | round (const SparseMatrix< MT, SO > &sm) |
Applies the round() function to each non-zero element of the sparse matrix sm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | conj (const SparseMatrix< MT, SO > &sm) |
Returns a matrix containing the complex conjugate of each single element of sm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | ctrans (const SparseMatrix< MT, SO > &sm) |
Returns the conjugate transpose matrix of sm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | real (const SparseMatrix< MT, SO > &sm) |
Returns a matrix containing the real parts of each single element of sm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | imag (const SparseMatrix< MT, SO > &sm) |
Returns a matrix containing the imaginary parts of each single element of sm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | sqrt (const SparseMatrix< MT, SO > &sm) |
Computes the square root of each non-zero element of the sparse matrix sm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | invsqrt (const SparseMatrix< MT, SO > &sm) |
Computes the inverse square root of each non-zero element of the sparse matrix sm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | cbrt (const SparseMatrix< MT, SO > &sm) |
Computes the cubic root of each non-zero element of the sparse matrix sm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | invcbrt (const SparseMatrix< MT, SO > &sm) |
Computes the inverse cubic root of each non-zero element of the sparse matrix sm. More... | |
template<typename MT , bool SO, typename DT > | |
decltype(auto) | clamp (const SparseMatrix< MT, SO > &sm, const DT &min, const DT &max) |
Restricts each single element of the sparse matrix sm to the range ![]() | |
template<typename MT , bool SO, typename ST , EnableIf_t< IsNumeric_v< ST > > * = nullptr> | |
decltype(auto) | pow (const SparseMatrix< MT, SO > &sm, ST exp) |
Computes the exponential value for each non-zero element of the sparse matrix sm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | exp (const SparseMatrix< MT, SO > &sm) |
Computes ![]() | |
template<typename MT , bool SO> | |
decltype(auto) | exp2 (const SparseMatrix< MT, SO > &sm) |
Computes ![]() | |
template<typename MT , bool SO> | |
decltype(auto) | exp10 (const SparseMatrix< MT, SO > &sm) |
Computes ![]() | |
template<typename MT , bool SO> | |
decltype(auto) | log (const SparseMatrix< MT, SO > &sm) |
Computes the natural logarithm for each non-zero element of the sparse matrix sm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | log2 (const SparseMatrix< MT, SO > &sm) |
Computes the binary logarithm for each non-zero element of the sparse matrix sm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | log10 (const SparseMatrix< MT, SO > &sm) |
Computes the common logarithm for each non-zero element of the sparse matrix sm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | sin (const SparseMatrix< MT, SO > &sm) |
Computes the sine for each non-zero element of the sparse matrix sm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | asin (const SparseMatrix< MT, SO > &sm) |
Computes the inverse sine for each non-zero element of the sparse matrix sm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | sinh (const SparseMatrix< MT, SO > &sm) |
Computes the hyperbolic sine for each non-zero element of the sparse matrix sm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | asinh (const SparseMatrix< MT, SO > &sm) |
Computes the inverse hyperbolic sine for each non-zero element of the sparse matrix sm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | cos (const SparseMatrix< MT, SO > &sm) |
Computes the cosine for each non-zero element of the sparse matrix sm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | acos (const SparseMatrix< MT, SO > &sm) |
Computes the inverse cosine for each non-zero element of the sparse matrix sm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | cosh (const SparseMatrix< MT, SO > &sm) |
Computes the hyperbolic cosine for each non-zero element of the sparse matrix sm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | acosh (const SparseMatrix< MT, SO > &sm) |
Computes the inverse hyperbolic cosine for each non-zero element of the sparse matrix sm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | tan (const SparseMatrix< MT, SO > &sm) |
Computes the tangent for each non-zero element of the sparse matrix sm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | atan (const SparseMatrix< MT, SO > &sm) |
Computes the inverse tangent for each non-zero element of the sparse matrix sm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | tanh (const SparseMatrix< MT, SO > &sm) |
Computes the hyperbolic tangent for each non-zero element of the sparse matrix sm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | atanh (const SparseMatrix< MT, SO > &sm) |
Computes the inverse hyperbolic tangent for each non-zero element of the sparse matrix sm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | erf (const SparseMatrix< MT, SO > &sm) |
Computes the error function for each non-zero element of the sparse matrix sm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | erfc (const SparseMatrix< MT, SO > &sm) |
Computes the complementary error function for each non-zero element of the sparse matrix sm. More... | |
template<typename MT , bool SO> | |
decltype(auto) | norm (const SparseMatrix< MT, SO > &sm) |
Computes the L2 norm for the given sparse matrix. More... | |
template<typename MT , bool SO> | |
decltype(auto) | sqrNorm (const SparseMatrix< MT, SO > &sm) |
Computes the squared L2 norm for the given sparse matrix. More... | |
template<typename MT , bool SO> | |
decltype(auto) | l1Norm (const SparseMatrix< MT, SO > &sm) |
Computes the L1 norm for the given sparse matrix. More... | |
template<typename MT , bool SO> | |
decltype(auto) | l2Norm (const SparseMatrix< MT, SO > &sm) |
Computes the L2 norm for the given sparse matrix. More... | |
template<typename MT , bool SO> | |
decltype(auto) | l3Norm (const SparseMatrix< MT, SO > &sm) |
Computes the L3 norm for the given sparse matrix. More... | |
template<typename MT , bool SO> | |
decltype(auto) | l4Norm (const SparseMatrix< MT, SO > &sm) |
Computes the L4 norm for the given sparse matrix. More... | |
template<typename MT , bool SO, typename ST > | |
decltype(auto) | lpNorm (const SparseMatrix< MT, SO > &sm, ST p) |
Computes the Lp norm for the given sparse matrix. More... | |
template<size_t P, typename MT , bool SO> | |
decltype(auto) | lpNorm (const SparseMatrix< MT, SO > &sm) |
Computes the Lp norm for the given sparse matrix. More... | |
template<typename MT , bool SO> | |
decltype(auto) | linfNorm (const SparseMatrix< MT, SO > &sm) |
Computes the infinity norm for the given sparse matrix. More... | |
template<typename MT , bool SO> | |
decltype(auto) | maxNorm (const SparseMatrix< MT, SO > &sm) |
Computes the maximum norm for the given sparse matrix. More... | |
template<typename MT , bool SO> | |
decltype(auto) | sum (const SparseMatrix< MT, SO > &sm) |
Reduces the given sparse matrix by means of addition. More... | |
template<size_t RF, typename MT , bool SO> | |
decltype(auto) | sum (const SparseMatrix< MT, SO > &sm) |
Reduces the given sparse matrix by means of addition. More... | |
template<typename MT , bool SO> | |
decltype(auto) | prod (const SparseMatrix< MT, SO > &sm) |
Reduces the given sparse matrix by means of multiplication. More... | |
template<size_t RF, typename MT , bool SO> | |
decltype(auto) | prod (const SparseMatrix< MT, SO > &sm) |
Reduces the given sparse matrix by means of multiplication. More... | |
template<typename MT , bool SO> | |
decltype(auto) | min (const SparseMatrix< MT, SO > &sm) |
Returns the smallest element of the sparse matrix. More... | |
template<size_t RF, typename MT , bool SO> | |
decltype(auto) | min (const SparseMatrix< MT, SO > &sm) |
Returns the smallest element of each row/columns of the sparse matrix. More... | |
template<typename MT , bool SO> | |
decltype(auto) | max (const SparseMatrix< MT, SO > &sm) |
Returns the largest element of the sparse matrix. More... | |
template<size_t RF, typename MT , bool SO> | |
decltype(auto) | max (const SparseMatrix< MT, SO > &sm) |
Returns the largest element of each row/columns of the sparse matrix. More... | |
template<typename MT , bool SO, typename ST , EnableIf_t< IsNumeric_v< ST > > * = nullptr> | |
decltype(auto) | operator/ (const SparseMatrix< MT, SO > &mat, ST scalar) |
Division operator for the division of a sparse matrix by a scalar value ( ![]() | |
template<typename MT , bool SO> | |
decltype(auto) | operator- (const SparseMatrix< MT, SO > &sm) |
Unary minus operator for the negation of a sparse matrix ( ![]() | |
template<typename MT , bool SO, typename ST , EnableIf_t< IsNumeric_v< ST > > * = nullptr> | |
decltype(auto) | operator * (const SparseMatrix< MT, SO > &mat, ST scalar) |
Multiplication operator for the multiplication of a sparse matrix and a scalar value ( ![]() | |
template<typename ST , typename MT , bool SO, EnableIf_t< IsNumeric_v< ST > > * = nullptr> | |
decltype(auto) | operator * (ST scalar, const SparseMatrix< MT, SO > &mat) |
Multiplication operator for the multiplication of a scalar value and a sparse matrix ( ![]() | |
template<typename MT1 , bool SO1, typename MT2 , bool SO2> | |
bool | operator== (const SparseMatrix< MT1, SO1 > &lhs, const SparseMatrix< MT2, SO2 > &rhs) |
Equality operator for the comparison of two sparse matrices. More... | |
template<typename MT1 , bool SO1, typename MT2 , bool SO2> | |
bool | operator!= (const SparseMatrix< MT1, SO1 > &lhs, const SparseMatrix< MT2, SO2 > &rhs) |
Inequality operator for the comparison of two sparse matrices. More... | |
template<typename VT1 , typename VT2 , bool TF> | |
decltype(auto) | cross (const SparseVector< VT1, TF > &lhs, const DenseVector< VT2, TF > &rhs) |
Cross product of a sparse vector and a dense vector ( ![]() | |
template<typename VT1 , typename VT2 , bool TF> | |
decltype(auto) | operator- (const SparseVector< VT1, TF > &lhs, const DenseVector< VT2, TF > &rhs) |
Subtraction operator for the subtraction of a sparse vector and a dense vector ( ![]() | |
template<typename VT , bool TF, typename OP > | |
decltype(auto) | forEach (const SparseVector< VT, TF > &sv, OP op) |
Evaluates the given custom operation on each non-zero element of the sparse vector sv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | abs (const SparseVector< VT, TF > &sv) |
Applies the abs() function to each non-zero element of the sparse vector sv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | sign (const SparseVector< VT, TF > &sv) |
Applies the sign() function to each non-zero element of the sparse vector sv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | floor (const SparseVector< VT, TF > &sv) |
Applies the floor() function to each non-zero element of the sparse vector sv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | ceil (const SparseVector< VT, TF > &sv) |
Applies the ceil() function to each non-zero element of the sparse vector sv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | trunc (const SparseVector< VT, TF > &sv) |
Applies the trunc() function to each non-zero element of the sparse vector sv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | round (const SparseVector< VT, TF > &sv) |
Applies the round() function to each non-zero element of the sparse vector sv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | conj (const SparseVector< VT, TF > &sv) |
Returns a vector containing the complex conjugate of each single element of sv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | ctrans (const SparseVector< VT, TF > &sv) |
Returns the conjugate transpose vector of sv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | real (const SparseVector< VT, TF > &sv) |
Returns a vector containing the real parts of each single element of sv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | imag (const SparseVector< VT, TF > &sv) |
Returns a vector containing the imaginary parts of each single element of sv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | sqrt (const SparseVector< VT, TF > &sv) |
Computes the square root of each non-zero element of the sparse vector sv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | invsqrt (const SparseVector< VT, TF > &sv) |
Computes the inverse square root of each non-zero element of the sparse vector sv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | cbrt (const SparseVector< VT, TF > &sv) |
Computes the cubic root of each non-zero element of the sparse vector sv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | invcbrt (const SparseVector< VT, TF > &sv) |
Computes the inverse cubic root of each non-zero element of the sparse vector sv. More... | |
template<typename VT , bool TF, typename DT > | |
decltype(auto) | clamp (const SparseVector< VT, TF > &sv, const DT &min, const DT &max) |
Restricts each single element of the sparse vector sv to the range ![]() | |
template<typename VT , bool TF, typename ST , EnableIf_t< IsNumeric_v< ST > > * = nullptr> | |
decltype(auto) | pow (const SparseVector< VT, TF > &sv, ST exp) |
Computes the exponential value for each non-zero element of the sparse vector sv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | exp (const SparseVector< VT, TF > &sv) |
Computes ![]() | |
template<typename VT , bool TF> | |
decltype(auto) | exp2 (const SparseVector< VT, TF > &sv) |
Computes ![]() | |
template<typename VT , bool TF> | |
decltype(auto) | exp10 (const SparseVector< VT, TF > &sv) |
Computes ![]() | |
template<typename VT , bool TF> | |
decltype(auto) | log (const SparseVector< VT, TF > &sv) |
Computes the natural logarithm of each non-zero element of the sparse vector sv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | log2 (const SparseVector< VT, TF > &sv) |
Computes the binary logarithm of each non-zero element of the sparse vector sv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | log10 (const SparseVector< VT, TF > &sv) |
Computes the common logarithm of each non-zero element of the sparse vector sv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | sin (const SparseVector< VT, TF > &sv) |
Computes the sine of each non-zero element of the sparse vector sv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | asin (const SparseVector< VT, TF > &sv) |
Computes the inverse sine of each non-zero element of the sparse vector sv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | sinh (const SparseVector< VT, TF > &sv) |
Computes the hyperbolic sine of each non-zero element of the sparse vector sv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | asinh (const SparseVector< VT, TF > &sv) |
Computes the inverse hyperbolic sine of each non-zero element of the sparse vector sv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | cos (const SparseVector< VT, TF > &sv) |
Computes the cosine of each non-zero element of the sparse vector sv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | acos (const SparseVector< VT, TF > &sv) |
Computes the inverse cosine of each non-zero element of the sparse vector sv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | cosh (const SparseVector< VT, TF > &sv) |
Computes the hyperbolic cosine of each non-zero element of the sparse vector sv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | acosh (const SparseVector< VT, TF > &sv) |
Computes the inverse hyperbolic cosine of each non-zero element of the sparse vector sv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | tan (const SparseVector< VT, TF > &sv) |
Computes the tangent of each non-zero element of the sparse vector sv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | atan (const SparseVector< VT, TF > &sv) |
Computes the inverse tangent of each non-zero element of the sparse vector sv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | tanh (const SparseVector< VT, TF > &sv) |
Computes the hyperbolic tangent of each non-zero element of the sparse vector sv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | atanh (const SparseVector< VT, TF > &sv) |
Computes the inverse hyperbolic tangent of each non-zero element of the sparse vector sv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | erf (const SparseVector< VT, TF > &sv) |
Computes the error function of each non-zero element of the sparse vector sv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | erfc (const SparseVector< VT, TF > &sv) |
Computes the complementary error function of each non-zero element of the sparse vector sv. More... | |
template<typename VT , bool TF> | |
decltype(auto) | norm (const SparseVector< VT, TF > &sv) |
Computes the L2 norm for the given sparse vector. More... | |
template<typename VT , bool TF> | |
decltype(auto) | sqrNorm (const SparseVector< VT, TF > &sv) |
Computes the squared L2 norm for the given sparse vector. More... | |
template<typename VT , bool TF> | |
decltype(auto) | l1Norm (const SparseVector< VT, TF > &sv) |
Computes the L1 norm for the given sparse vector. More... | |
template<typename VT , bool TF> | |
decltype(auto) | l2Norm (const SparseVector< VT, TF > &sv) |
Computes the L2 norm for the given sparse vector. More... | |
template<typename VT , bool TF> | |
decltype(auto) | l3Norm (const SparseVector< VT, TF > &sv) |
Computes the L3 norm for the given sparse vector. More... | |
template<typename VT , bool TF> | |
decltype(auto) | l4Norm (const SparseVector< VT, TF > &sv) |
Computes the L4 norm for the given sparse vector. More... | |
template<typename VT , bool TF, typename ST > | |
decltype(auto) | lpNorm (const SparseVector< VT, TF > &sv, ST p) |
Computes the Lp norm for the given sparse vector. More... | |
template<size_t P, typename VT , bool TF> | |
decltype(auto) | lpNorm (const SparseVector< VT, TF > &sv) |
Computes the Lp norm for the given sparse vector. More... | |
template<typename VT , bool TF> | |
decltype(auto) | linfNorm (const SparseVector< VT, TF > &sv) |
Computes the infinity norm for the given sparse vector. More... | |
template<typename VT , bool TF> | |
decltype(auto) | maxNorm (const SparseVector< VT, TF > &sv) |
Computes the maximum norm for the given sparse vector. More... | |
template<typename VT , bool TF> | |
decltype(auto) | sqrLength (const SparseVector< VT, TF > &sv) |
Calculation of the square length (magnitude) of the sparse vector ![]() | |
template<typename VT , bool TF> | |
decltype(auto) | length (const SparseVector< VT, TF > &sv) |
Calculation of the length (magnitude) of the sparse vector ![]() | |
template<typename VT , bool TF> | |
decltype(auto) | sum (const SparseVector< VT, TF > &sv) |
Reduces the given sparse vector by means of addition. More... | |
template<typename VT , bool TF> | |
decltype(auto) | prod (const SparseVector< VT, TF > &sv) |
Reduces the given sparse vector by means of multiplication. More... | |
template<typename VT , bool TF> | |
decltype(auto) | min (const SparseVector< VT, TF > &sv) |
Returns the smallest element of the sparse vector. More... | |
template<typename VT , bool TF> | |
decltype(auto) | max (const SparseVector< VT, TF > &sv) |
Returns the largest element of the sparse vector. More... | |
template<typename VT , bool TF> | |
size_t | argmin (const SparseVector< VT, TF > &sv) |
Returns the index of the first smallest non-zero element of the sparse vector. More... | |
template<typename VT , bool TF> | |
size_t | argmax (const SparseVector< VT, TF > &sv) |
Returns the index of the first largest non-zero element of the sparse vector. More... | |
template<typename VT , typename ST , bool TF, EnableIf_t< IsNumeric_v< ST > > * = nullptr> | |
decltype(auto) | operator/ (const SparseVector< VT, TF > &vec, ST scalar) |
Division operator for the divison of a sparse vector by a scalar value ( ![]() | |
template<typename VT , bool TF> | |
decltype(auto) | operator- (const SparseVector< VT, TF > &sv) |
Unary minus operator for the negation of a sparse vector ( ![]() | |
template<typename VT , typename ST , bool TF, EnableIf_t< IsNumeric_v< ST > > * = nullptr> | |
decltype(auto) | operator * (const SparseVector< VT, TF > &vec, ST scalar) |
Multiplication operator for the multiplication of a sparse vector and a scalar value ( ![]() | |
template<typename ST , typename VT , bool TF, EnableIf_t< IsNumeric_v< ST > > * = nullptr> | |
decltype(auto) | operator * (ST scalar, const SparseVector< VT, TF > &vec) |
Multiplication operator for the multiplication of a scalar value and a sparse vector ( ![]() | |
template<typename VT , bool TF> | |
decltype(auto) | normalize (const SparseVector< VT, TF > &vec) |
Normalization of the sparse vector ( ![]() | |
template<typename VT1 , typename VT2 , bool TF> | |
decltype(auto) | cross (const SparseVector< VT1, TF > &lhs, const SparseVector< VT2, TF > &rhs) |
Cross product of two sparse vectors ( ![]() | |
template<typename VT1 , bool TF1, typename VT2 , bool TF2> | |
bool | operator== (const SparseVector< VT1, TF1 > &lhs, const SparseVector< VT2, TF2 > &rhs) |
Equality operator for the comparison of two sparse vectors. More... | |
template<typename VT1 , bool TF1, typename VT2 , bool TF2> | |
bool | operator!= (const SparseVector< VT1, TF1 > &lhs, const SparseVector< VT2, TF2 > &rhs) |
Inequality operator for the comparison of two sparse vectors. More... | |
template<typename VT1 , typename VT2 , bool TF> | |
decltype(auto) | operator- (const SparseVector< VT1, TF > &lhs, const SparseVector< VT2, TF > &rhs) |
Subtraction operator for the subtraction of two sparse vectors ( ![]() | |
template<typename MT1 , typename MT2 , DisableIf_t<(IsUniLower_v< MT1 > &&IsUniUpper_v< MT2 >)||(IsUniUpper_v< MT1 > &&IsUniLower_v< MT2 >)||(IsStrictlyLower_v< MT1 > &&IsUpper_v< MT2 >)||(IsStrictlyUpper_v< MT1 > &&IsLower_v< MT2 >)||(IsLower_v< MT1 > &&IsStrictlyUpper_v< MT2 >)||(IsUpper_v< MT1 > &&IsStrictlyLower_v< MT2 >)||(IsZero_v< MT1 >||IsZero_v< MT2 >) > * = nullptr> | |
const TSMatTSMatSchurExpr< MT1, MT2 > | tsmattsmatschur (const SparseMatrix< MT1, true > &lhs, const SparseMatrix< MT2, true > &rhs) |
Backend implementation of the Schur product between two column-major sparse matrices ( ![]() | |
template<typename VT , bool TF> | |
BLAZE_ALWAYS_INLINE VT::Iterator | begin (Vector< VT, TF > &vector) |
Returns an iterator to the first element of the given vector. More... | |
template<typename VT , bool TF> | |
BLAZE_ALWAYS_INLINE VT::ConstIterator | begin (const Vector< VT, TF > &vector) |
Returns an iterator to the first element of the given vector. More... | |
template<typename VT , bool TF> | |
BLAZE_ALWAYS_INLINE VT::ConstIterator | cbegin (const Vector< VT, TF > &vector) |
Returns an iterator to the first element of the given vector. More... | |
template<typename VT , bool TF> | |
BLAZE_ALWAYS_INLINE VT::Iterator | end (Vector< VT, TF > &vector) |
Returns an iterator just past the last element of the given vector. More... | |
template<typename VT , bool TF> | |
BLAZE_ALWAYS_INLINE VT::ConstIterator | end (const Vector< VT, TF > &vector) |
Returns an iterator just past the last element of the given vector. More... | |
template<typename VT , bool TF> | |
BLAZE_ALWAYS_INLINE VT::ConstIterator | cend (const Vector< VT, TF > &vector) |
Returns an iterator just past the last element of the given vector. More... | |
template<typename VT , bool TF> | |
BLAZE_ALWAYS_INLINE constexpr size_t | size (const Vector< VT, TF > &vector) noexcept |
Returns the current size/dimension of the vector. More... | |
template<typename VT , bool TF> | |
BLAZE_ALWAYS_INLINE size_t | capacity (const Vector< VT, TF > &vector) noexcept |
Returns the maximum capacity of the vector. More... | |
template<typename VT , bool TF> | |
BLAZE_ALWAYS_INLINE size_t | nonZeros (const Vector< VT, TF > &vector) |
Returns the number of non-zero elements in the vector. More... | |
template<typename VT , bool TF> | |
BLAZE_ALWAYS_INLINE void | resize (Vector< VT, TF > &vector, size_t n, bool preserve) |
Changing the size of the vector. More... | |
template<typename VT , bool TF> | |
BLAZE_ALWAYS_INLINE void | shrinkToFit (Vector< VT, TF > &vector) |
Requesting the removal of unused capacity. More... | |
template<typename VT , bool TF> | |
BLAZE_ALWAYS_INLINE constexpr bool | isEmpty (const Vector< VT, TF > &vector) noexcept |
Checks if the given vector is empty. More... | |
template<typename VT1 , bool TF1, typename VT2 , bool TF2> | |
BLAZE_ALWAYS_INLINE bool | isSame (const Vector< VT1, TF1 > &a, const Vector< VT2, TF2 > &b) noexcept |
Returns whether the two given vectors represent the same observable state. More... | |
template<typename OP , typename A1 > | |
constexpr Bind1st< OP, A1 > | bind1st (const OP &op, const A1 &a1) |
Binds the given object/value to the 1st parameter of the given binary operation. More... | |
template<typename OP , typename A2 > | |
constexpr Bind2nd< OP, A2 > | bind2nd (const OP &op, const A2 &a2) |
Binds the given object/value to the 2nd parameter of the given binary operation. More... | |
template<typename Type > | |
size_t | 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 | 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 | 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 | 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 | 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 | 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 | 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 | 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 | 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 | 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 | 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 | 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 | 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 | 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 | 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 | 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 | 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 | 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 | clear (const DenseMatrixProxy< PT, MT > &proxy) |
Clearing the represented matrix. More... | |
template<typename PT , typename VT > | |
BLAZE_ALWAYS_INLINE DenseVectorProxy< PT, VT >::Iterator | 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 | 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 | 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 | 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 | 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 | 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 | 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 | 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 | 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 | clear (const DenseVectorProxy< PT, VT > &proxy) |
Clearing the represented vector. More... | |
template<typename PT , typename RT , typename ET > | |
decltype(auto) | pow2 (const Proxy< PT, RT > &proxy) |
Computing the square value of the represented element. More... | |
template<typename PT , typename RT , typename ET > | |
decltype(auto) | pow3 (const Proxy< PT, RT > &proxy) |
Computing the cube value of the represented element. More... | |
template<typename PT , typename RT , typename ET > | |
decltype(auto) | 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 | 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 | 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 | 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 | 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 | 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 | 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 | 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 | 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 | 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 | 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 | 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 | 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 | 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 | clear (const SparseMatrixProxy< PT, MT > &proxy) |
Clearing the represented matrix. More... | |
template<typename PT , typename VT > | |
BLAZE_ALWAYS_INLINE SparseVectorProxy< PT, VT >::Iterator | 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 | 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 | 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 | 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 | 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 | 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 | 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 | 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 | 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 | clear (const SparseVectorProxy< PT, VT > &proxy) |
Clearing the represented element. More... | |
template<typename Archive , typename MT , bool SO> | |
void | serialize (Archive &archive, const Matrix< MT, SO > &mat) |
Serializes the given matrix and writes it to the archive. More... | |
template<typename Archive , typename MT , bool SO> | |
void | deserialize (Archive &archive, Matrix< MT, SO > &mat) |
Deserializes a matrix from the given archive. More... | |
template<typename Archive , typename VT , bool TF> | |
void | serialize (Archive &archive, const Vector< VT, TF > &vec) |
Serializes the given vector and writes it to the archive. More... | |
template<typename Archive , typename VT , bool TF> | |
void | deserialize (Archive &archive, Vector< VT, TF > &vec) |
Deserializes a vector from the given archive. More... | |
template<typename Type > | |
BLAZE_ALWAYS_INLINE constexpr void | clear (Type &clearable) |
Clearing the given value/object to the default state. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE constexpr EnableIf_t< IsBuiltin_v< T >, T > | conj (T a) noexcept |
Computing the conjugate of the given value/object. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE void | conjugate (T &a) noexcept(IsNumeric_v< T >) |
In-place conjugation of the given value/object. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE void | cswap (T &a, T &b) noexcept(IsNumeric_v< T >) |
Swapping two conjugated values/objects. More... | |
template<typename T > | |
constexpr size_t | digits (T a) noexcept |
Returns the number of valid digits of an integral value. More... | |
template<bool RF, typename T1 , typename T2 , typename = EnableIf_t< ( IsSigned_v<T1> && IsSigned_v<T2> ) || ( IsUnsigned_v<T1> && IsUnsigned_v<T2> ) >> | |
constexpr bool | equal (const T1 &a, const T2 &b) |
Generic equality comparison. More... | |
template<typename T1 , typename T2 > | |
constexpr bool | equal (const T1 &a, const T2 &b) |
Generic equality check. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE constexpr EnableIf_t< IsBuiltin_v< T >||IsComplex_v< T >, const T & > | eval (const T &a) noexcept |
Formal evaluation of the given argument. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE constexpr EnableIf_t< IsBuiltin_v< T >||IsComplex_v< T >, T > | evaluate (const T &a) noexcept |
Formal evaluation of the given argument. More... | |
template<typename T , typename = EnableIf_t< IsBuiltin_v<T> >> | |
decltype(auto) BLAZE_ALWAYS_INLINE | exp10 (const T &a) noexcept(noexcept(pow(T(10), a))) |
Returns the base-10 exponent of the given built-in value. More... | |
template<typename T1 , typename T2 > | |
BLAZE_ALWAYS_INLINE constexpr bool | greater (const T1 &a, const T2 &b) noexcept(IsBuiltin_v< CommonType_t< T1, T2 > >) |
Generic greater-than comparison. More... | |
template<typename T , typename = EnableIf_t< IsBuiltin_v<T> >> | |
auto | invcbrt (T a) noexcept -> decltype(inv(cbrt(a))) |
Returns the inverse cubic root of the given built-in value. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE constexpr EnableIf_t< IsIntegral_v< T >, double > | inv (T a) noexcept |
Inverting the given integral value. More... | |
BLAZE_ALWAYS_INLINE constexpr float | inv (float a) noexcept |
Inverting the given single precision value. More... | |
BLAZE_ALWAYS_INLINE constexpr double | inv (double a) noexcept |
Inverting the given double precision value. More... | |
BLAZE_ALWAYS_INLINE constexpr long double | inv (long double a) noexcept |
Inverting the given extended precision value. More... | |
BLAZE_ALWAYS_INLINE constexpr complex< float > | inv (const complex< float > &a) noexcept |
Inverting the given single precision complex number. More... | |
BLAZE_ALWAYS_INLINE constexpr complex< double > | inv (const complex< double > &a) noexcept |
Inverting the given double precision complex number. More... | |
BLAZE_ALWAYS_INLINE constexpr complex< long double > | inv (const complex< long double > &a) noexcept |
Inverting the given extended precision complex number. More... | |
BLAZE_ALWAYS_INLINE void | invert (float &a) noexcept |
In-place inversion of the given single precision value. More... | |
BLAZE_ALWAYS_INLINE void | invert (double &a) noexcept |
In-place inversion of the given double precision value. More... | |
BLAZE_ALWAYS_INLINE void | invert (long double &a) noexcept |
In-place inversion of the given extended precision value. More... | |
BLAZE_ALWAYS_INLINE void | invert (complex< float > &a) noexcept |
In-place inversion of the given single precision complex number. More... | |
BLAZE_ALWAYS_INLINE void | invert (complex< double > &a) noexcept |
In-place inversion of the given double precision complex number. More... | |
BLAZE_ALWAYS_INLINE void | invert (complex< long double > &a) noexcept |
In-place inversion of the given extended precision complex number. More... | |
template<typename T , typename = EnableIf_t< IsBuiltin_v<T> >> | |
auto | invsqrt (T a) noexcept -> decltype(inv(sqrt(a))) |
Returns the inverse square root of the given built-in value. More... | |
template<typename T , typename = EnableIf_t< IsBuiltin_v<T> >> | |
auto | invsqrt (const complex< T > &a) noexcept -> decltype(inv(sqrt(a))) |
Returns the inverse square root of the given complex number. More... | |
template<bool RF, typename Type > | |
BLAZE_ALWAYS_INLINE bool | isDefault (const Type &v) noexcept(IsBuiltin_v< Type >) |
Returns whether the given value/object is in default state. More... | |
template<typename Type > | |
BLAZE_ALWAYS_INLINE bool | isDefault (const Type &v) noexcept(IsBuiltin_v< Type >) |
Returns whether the given value/object is in default state. More... | |
template<typename Type , typename = EnableIf_t< IsNumeric_v<Type> >> | |
BLAZE_ALWAYS_INLINE bool | isDivisor (const Type &v) |
Returns whether the given value/object is a valid divisor. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE EnableIf_t< IsNumeric_v< T >, bool > | isnan (T a) noexcept |
Platform independent implementation of the C99 isnan function. More... | |
template<bool RF, typename Type > | |
BLAZE_ALWAYS_INLINE EnableIf_t< IsNumeric_v< Type >, bool > | isOne (const Type &v) |
Returns whether the given value/object represents the numeric value 1. More... | |
template<typename Type > | |
BLAZE_ALWAYS_INLINE bool | isOne (const Type &v) |
Returns whether the given value/object represents the numeric value 1. More... | |
template<bool RF, typename Type > | |
BLAZE_ALWAYS_INLINE bool | isReal (const Type &v) noexcept |
Returns whether the given value/object represents a real number. More... | |
template<typename Type > | |
BLAZE_ALWAYS_INLINE bool | isReal (const Type &v) noexcept |
Returns whether the given value/object represents a real number. More... | |
template<bool RF, typename Type > | |
BLAZE_ALWAYS_INLINE EnableIf_t< IsNumeric_v< Type >, bool > | isZero (const Type &v) noexcept |
Returns whether the given value/object represents the numeric value 0. More... | |
template<typename Type > | |
BLAZE_ALWAYS_INLINE bool | isZero (const Type &v) noexcept |
Returns whether the given value/object represents the numeric value 0. More... | |
template<typename T1 , typename T2 > | |
BLAZE_ALWAYS_INLINE constexpr bool | less (const T1 &a, const T2 &b) noexcept(IsBuiltin_v< CommonType_t< T1, T2 > >) |
Generic less-than comparison. More... | |
template<typename T1 , typename T2 > | |
BLAZE_ALWAYS_INLINE constexpr auto | nextMultiple (T1 value, T2 factor) noexcept |
Rounds up an integral value to the next multiple of a given factor. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINEdecltype(auto) constexpr | pow2 (const T &a) noexcept(noexcept(a *a)) |
Squaring the given value/object. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINEdecltype(auto) constexpr | pow3 (const T &a) noexcept(noexcept(a *a *a)) |
Cubing the given value/object. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINEdecltype(auto) constexpr | pow4 (const T &a) noexcept(noexcept(pow2(pow2(a)))) |
Quadruple the given value/object. More... | |
template<typename T > | |
decltype(auto) BLAZE_ALWAYS_INLINE | qdrt (const T &a) |
Computing the quad root (4th root) of the given value/object. More... | |
template<typename Type > | |
BLAZE_ALWAYS_INLINE constexpr void | reset (Type &resettable) |
Resetting the given value/object to the default value. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE constexpr EnableIf_t< IsBuiltin_v< T >||IsComplex_v< T >, const T & > | serial (const T &a) noexcept |
Formal serialization of the evaluation of the given argument. More... | |
template<typename T , typename = EnableIf_t< IsIntegral_v<T> >> | |
constexpr T | sign (T a) noexcept |
Evaluating the sign of the given value. More... | |
constexpr float | sign (float a) noexcept |
Evaluating the sign of the given single precision value. More... | |
constexpr double | sign (double a) noexcept |
Evaluating the sign of the given double precision value. More... | |
constexpr long double | sign (long double a) noexcept |
Evaluating the sign of the given extended precision value. More... | |
BLAZE_ALWAYS_INLINE const SIMDint8 | abs (const SIMDint8 &a) noexcept=delete |
Absolute value of a vector of 8-bit signed integral values. More... | |
BLAZE_ALWAYS_INLINE const SIMDint16 | abs (const SIMDint16 &a) noexcept=delete |
Absolute value of a vector of 16-bit signed integral values. More... | |
BLAZE_ALWAYS_INLINE const SIMDint32 | abs (const SIMDint32 &a) noexcept=delete |
Absolute value of a vector of 32-bit signed integral values. More... | |
BLAZE_ALWAYS_INLINE const SIMDint64 | abs (const SIMDint64 &a) noexcept=delete |
Absolute value of a vector of 64-bit signed integral values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const SIMDfloat | abs (const SIMDf32< T > &a) noexcept=delete |
Absolute of a vector of single precision floating point values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const SIMDdouble | abs (const SIMDf64< T > &a) noexcept=delete |
Absolute of a vector of double precision floating point values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const SIMDfloat | acos (const SIMDf32< T > &a) noexcept=delete |
Inverse cosine of a vector of single precision floating point values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const SIMDdouble | acos (const SIMDf64< T > &a) noexcept=delete |
Inverse cosine of a vector of double precision floating point values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const SIMDfloat | acosh (const SIMDf32< T > &a) noexcept=delete |
Inverse hyperbolic cosine of a vector of single precision floating point values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const SIMDdouble | acosh (const SIMDf64< T > &a) noexcept=delete |
Inverse hyperbolic cosine of a vector of double precision floating point values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const T | operator+ (const SIMDi8< T > &a, const SIMDi8< T > &b) noexcept=delete |
Addition of two vectors of 8-bit integral SIMD values of the same type. More... | |
template<typename T1 , typename T2 > | |
BLAZE_ALWAYS_INLINE const SIMDuint8 | operator+ (const SIMDi8< T1 > &a, const SIMDi8< T2 > &b) noexcept=delete |
Addition of two vectors of 8-bit integral SIMD values of different type. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const T | operator+ (const SIMDci8< T > &a, const SIMDci8< T > &b) noexcept=delete |
Addition of two vectors of 8-bit integral complex SIMD values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const T | operator+ (const SIMDi16< T > &a, const SIMDi16< T > &b) noexcept=delete |
Addition of two vectors of 16-bit integral SIMD values of the same type. More... | |
template<typename T1 , typename T2 > | |
BLAZE_ALWAYS_INLINE const SIMDuint16 | operator+ (const SIMDi16< T1 > &a, const SIMDi16< T2 > &b) noexcept=delete |
Addition of two vectors of 16-bit integral SIMD values of different type. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const T | operator+ (const SIMDci16< T > &a, const SIMDci16< T > &b) noexcept=delete |
Addition of two vectors of 16-bit integral complex SIMD values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const T | operator+ (const SIMDi32< T > &a, const SIMDi32< T > &b) noexcept=delete |
Addition of two vectors of 32-bit integral SIMD values of the same type. More... | |
template<typename T1 , typename T2 > | |
BLAZE_ALWAYS_INLINE const SIMDuint32 | operator+ (const SIMDi32< T1 > &a, const SIMDi32< T2 > &b) noexcept=delete |
Addition of two vectors of 32-bit integral SIMD values of different type. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const T | operator+ (const SIMDci32< T > &a, const SIMDci32< T > &b) noexcept=delete |
Addition of two vectors of 32-bit integral complex SIMD values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const T | operator+ (const SIMDi64< T > &a, const SIMDi64< T > &b) noexcept=delete |
Addition of two vectors of 64-bit integral SIMD values of the same type. More... | |
template<typename T1 , typename T2 > | |
BLAZE_ALWAYS_INLINE const SIMDuint64 | operator+ (const SIMDi64< T1 > &a, const SIMDi64< T2 > &b) noexcept=delete |
Addition of two vectors of 64-bit integral SIMD values of different type. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const T | operator+ (const SIMDci64< T > &a, const SIMDci64< T > &b) noexcept=delete |
Addition of two vectors of 64-bit integral complex SIMD values. More... | |
template<typename T1 , typename T2 > | |
BLAZE_ALWAYS_INLINE const SIMDfloat | operator+ (const SIMDf32< T1 > &a, const SIMDf32< T2 > &b) noexcept=delete |
Addition of two vectors of single precision floating point SIMD values. More... | |
BLAZE_ALWAYS_INLINE const SIMDcfloat | operator+ (const SIMDcfloat &a, const SIMDcfloat &b) noexcept=delete |
Addition of two vectors of single precision complex SIMD values. More... | |
template<typename T1 , typename T2 > | |
BLAZE_ALWAYS_INLINE const SIMDdouble | operator+ (const SIMDf64< T1 > &a, const SIMDf64< T2 > &b) noexcept=delete |
Addition of two vectors of double precision floating point SIMD values. More... | |
BLAZE_ALWAYS_INLINE const SIMDcdouble | operator+ (const SIMDcdouble &a, const SIMDcdouble &b) noexcept=delete |
Addition of two vectors of double precision complex SIMD values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const SIMDfloat | asin (const SIMDf32< T > &a) noexcept=delete |
Inverse sine of a vector of single precision floating point values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const SIMDdouble | asin (const SIMDf64< T > &a) noexcept=delete |
Inverse sine of a vector of double precision floating point values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const SIMDfloat | asinh (const SIMDf32< T > &a) noexcept=delete |
Inverse hyperbolic sine of a vector of single precision floating point values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const SIMDdouble | asinh (const SIMDf64< T > &a) noexcept=delete |
Inverse hyperbolic sine of a vector of double precision floating point values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const SIMDfloat | atan (const SIMDf32< T > &a) noexcept=delete |
Inverse tangent of a vector of single precision floating point values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const SIMDdouble | atan (const SIMDf64< T > &a) noexcept=delete |
Inverse tangent of a vector of double precision floating point values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const SIMDfloat | atan2 (const SIMDf32< T > &a, const SIMDf32< T > &b) noexcept=delete |
Multi-valued inverse tangent of a vector of single precision floating point values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const SIMDdouble | atan2 (const SIMDf64< T > &a, const SIMDf64< T > &b) noexcept=delete |
Multi-valued inverse tangent of a vector of double precision floating point values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const SIMDfloat | atanh (const SIMDf32< T > &a) noexcept=delete |
Inverse hyperbolic tangent of a vector of single precision floating point values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const SIMDdouble | atanh (const SIMDf64< T > &a) noexcept=delete |
Inverse hyperbolic tangent of a vector of double precision floating point values. More... | |
template<typename T1 , typename T2 > | |
BLAZE_ALWAYS_INLINE T1 & | operator+= (SIMDPack< T1 > &lhs, const SIMDPack< T2 > &rhs) |
Addition assignment operator for the addition of two SIMD packs. More... | |
template<typename T1 , typename T2 > | |
BLAZE_ALWAYS_INLINE T1 & | operator-= (SIMDPack< T1 > &lhs, const SIMDPack< T2 > &rhs) |
Subtraction assignment operator for the subtraction of two SIMD packs. More... | |
template<typename T1 , typename T2 > | |
BLAZE_ALWAYS_INLINE T1 & | operator *= (SIMDPack< T1 > &lhs, const SIMDPack< T2 > &rhs) |
Multiplication assignment operator for the multiplication of two SIMD packs. More... | |
template<typename T1 , typename T2 > | |
BLAZE_ALWAYS_INLINE T1 & | operator/= (SIMDPack< T1 > &lhs, const SIMDPack< T2 > &rhs) |
Division assignment operator for the division of two SIMD packs. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const T | operator & (const SIMDi8< T > &a, const SIMDi8< T > &b) noexcept=delete |
Bitwise AND ('&') of two vectors of 8-bit integral SIMD values of the same type. More... | |
template<typename T1 , typename T2 > | |
BLAZE_ALWAYS_INLINE const SIMDuint8 | operator & (const SIMDi8< T1 > &a, const SIMDi8< T2 > &b) noexcept=delete |
Bitwise AND ('&') of two vectors of 8-bit integral SIMD values of different type. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const T | operator & (const SIMDci8< T > &a, const SIMDci8< T > &b) noexcept=delete |
Bitwise AND ('&') of two vectors of 8-bit integral complex SIMD values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const T | operator & (const SIMDi16< T > &a, const SIMDi16< T > &b) noexcept=delete |
Bitwise AND ('&') of two vectors of 16-bit integral SIMD values of the same type. More... | |
template<typename T1 , typename T2 > | |
BLAZE_ALWAYS_INLINE const SIMDuint16 | operator & (const SIMDi16< T1 > &a, const SIMDi16< T2 > &b) noexcept=delete |
Bitwise AND ('&') of two vectors of 16-bit integral SIMD values of different type. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const T | operator & (const SIMDci16< T > &a, const SIMDci16< T > &b) noexcept=delete |
Bitwise AND ('&') of two vectors of 16-bit integral complex SIMD values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const T | operator & (const SIMDi32< T > &a, const SIMDi32< T > &b) noexcept=delete |
Bitwise AND ('&') of two vectors of 32-bit integral SIMD values of the same type. More... | |
template<typename T1 , typename T2 > | |
BLAZE_ALWAYS_INLINE const SIMDuint32 | operator & (const SIMDi32< T1 > &a, const SIMDi32< T2 > &b) noexcept=delete |
Bitwise AND ('&') of two vectors of 32-bit integral SIMD values of different type. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const T | operator & (const SIMDci32< T > &a, const SIMDci32< T > &b) noexcept=delete |
Bitwise AND ('&') of two vectors of 32-bit integral complex SIMD values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const T | operator & (const SIMDi64< T > &a, const SIMDi64< T > &b) noexcept=delete |
Bitwise AND ('&') of two vectors of 64-bit integral SIMD values of the same type. More... | |
template<typename T1 , typename T2 > | |
BLAZE_ALWAYS_INLINE const SIMDuint64 | operator & (const SIMDi64< T1 > &a, const SIMDi64< T2 > &b) noexcept=delete |
Bitwise AND ('&') of two vectors of 64-bit integral SIMD values of different type. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const T | operator & (const SIMDci64< T > &a, const SIMDci64< T > &b) noexcept=delete |
Bitwise AND ('&') of two vectors of 64-bit integral complex SIMD values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const T | operator| (const SIMDi8< T > &a, const SIMDi8< T > &b) noexcept=delete |
Bitwise OR ('|') of two vectors of 8-bit integral SIMD values of the same type. More... | |
template<typename T1 , typename T2 > | |
BLAZE_ALWAYS_INLINE const SIMDuint8 | operator| (const SIMDi8< T1 > &a, const SIMDi8< T2 > &b) noexcept=delete |
Bitwise OR ('|') of two vectors of 8-bit integral SIMD values of different type. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const T | operator| (const SIMDci8< T > &a, const SIMDci8< T > &b) noexcept=delete |
Bitwise OR ('|') of two vectors of 8-bit integral complex SIMD values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const T | operator| (const SIMDi16< T > &a, const SIMDi16< T > &b) noexcept=delete |
Bitwise OR ('|') of two vectors of 16-bit integral SIMD values of the same type. More... | |
template<typename T1 , typename T2 > | |
BLAZE_ALWAYS_INLINE const SIMDuint16 | operator| (const SIMDi16< T1 > &a, const SIMDi16< T2 > &b) noexcept=delete |
Bitwise OR ('|') of two vectors of 16-bit integral SIMD values of different type. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const T | operator| (const SIMDci16< T > &a, const SIMDci16< T > &b) noexcept=delete |
Bitwise OR ('|') of two vectors of 16-bit integral complex SIMD values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const T | operator| (const SIMDi32< T > &a, const SIMDi32< T > &b) noexcept=delete |
Bitwise OR ('|') of two vectors of 32-bit integral SIMD values of the same type. More... | |
template<typename T1 , typename T2 > | |
BLAZE_ALWAYS_INLINE const SIMDuint32 | operator| (const SIMDi32< T1 > &a, const SIMDi32< T2 > &b) noexcept=delete |
Bitwise OR ('|') of two vectors of 32-bit integral SIMD values of different type. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const T | operator| (const SIMDci32< T > &a, const SIMDci32< T > &b) noexcept=delete |
Bitwise OR ('|') of two vectors of 32-bit integral complex SIMD values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const T | operator| (const SIMDi64< T > &a, const SIMDi64< T > &b) noexcept=delete |
Bitwise OR ('|') of two vectors of 64-bit integral SIMD values of the same type. More... | |
template<typename T1 , typename T2 > | |
BLAZE_ALWAYS_INLINE const SIMDuint64 | operator| (const SIMDi64< T1 > &a, const SIMDi64< T2 > &b) noexcept=delete |
Bitwise OR ('|') of two vectors of 64-bit integral SIMD values of different type. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const T | operator| (const SIMDci64< T > &a, const SIMDci64< T > &b) noexcept=delete |
Bitwise OR ('|') of two vectors of 64-bit integral complex SIMD values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const T | operator^ (const SIMDi8< T > &a, const SIMDi8< T > &b) noexcept=delete |
Bitwise XOR ('^') of two vectors of 8-bit integral SIMD values of the same type. More... | |
template<typename T1 , typename T2 > | |
BLAZE_ALWAYS_INLINE const SIMDuint8 | operator^ (const SIMDi8< T1 > &a, const SIMDi8< T2 > &b) noexcept=delete |
Bitwise XOR ('^') of two vectors of 8-bit integral SIMD values of different type. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const T | operator^ (const SIMDci8< T > &a, const SIMDci8< T > &b) noexcept=delete |
Bitwise XOR ('^') of two vectors of 8-bit integral complex SIMD values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const T | operator^ (const SIMDi16< T > &a, const SIMDi16< T > &b) noexcept=delete |
Bitwise XOR ('^') of two vectors of 16-bit integral SIMD values of the same type. More... | |
template<typename T1 , typename T2 > | |
BLAZE_ALWAYS_INLINE const SIMDuint16 | operator^ (const SIMDi16< T1 > &a, const SIMDi16< T2 > &b) noexcept=delete |
Bitwise XOR ('^') of two vectors of 16-bit integral SIMD values of different type. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const T | operator^ (const SIMDci16< T > &a, const SIMDci16< T > &b) noexcept=delete |
Bitwise XOR ('^') of two vectors of 16-bit integral complex SIMD values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const T | operator^ (const SIMDi32< T > &a, const SIMDi32< T > &b) noexcept=delete |
Bitwise XOR ('^') of two vectors of 32-bit integral SIMD values of the same type. More... | |
template<typename T1 , typename T2 > | |
BLAZE_ALWAYS_INLINE const SIMDuint32 | operator^ (const SIMDi32< T1 > &a, const SIMDi32< T2 > &b) noexcept=delete |
Bitwise XOR ('^') of two vectors of 32-bit integral SIMD values of different type. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const T | operator^ (const SIMDci32< T > &a, const SIMDci32< T > &b) noexcept=delete |
Bitwise XOR ('^') of two vectors of 32-bit integral complex SIMD values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const T | operator^ (const SIMDi64< T > &a, const SIMDi64< T > &b) noexcept=delete |
Bitwise XOR ('^') of two vectors of 64-bit integral SIMD values of the same type. More... | |
template<typename T1 , typename T2 > | |
BLAZE_ALWAYS_INLINE const SIMDuint64 | operator^ (const SIMDi64< T1 > &a, const SIMDi64< T2 > &b) noexcept=delete |
Bitwise XOR ('^') of two vectors of 64-bit integral SIMD values of different type. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const T | operator^ (const SIMDci64< T > &a, const SIMDci64< T > &b) noexcept=delete |
Bitwise XOR ('^') of two vectors of 64-bit integral complex SIMD values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const SIMDfloat | cbrt (const SIMDf32< T > &a) noexcept=delete |
Computes the cubic root for a vector of single precision floating point values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const SIMDdouble | cbrt (const SIMDf64< T > &a) noexcept=delete |
Computes the cubic root for a vector of double precision floating point values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const SIMDfloat | ceil (const SIMDf32< T > &a) noexcept=delete |
Computes the largest integer value not less than the given value for a vector of single precision floating point values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const SIMDdouble | ceil (const SIMDf64< T > &a) noexcept=delete |
Computes the largest integer value not less than the given value for a vector of double precision floating point values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const T | conj (const SIMDi8< T > &a) noexcept |
Complex conjugate of a vector of 8-bit integral values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const T | conj (const SIMDi16< T > &a) noexcept |
Complex conjugate of a vector of 16-bit integral values. More... | |
BLAZE_ALWAYS_INLINE const SIMDcint16 | conj (const SIMDcint16 &a) noexcept=delete |
Complex conjugate of a vector of 16-bit integral complex values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const T | conj (const SIMDi32< T > &a) noexcept |
Complex conjugate of a vector of 32-bit integral values. More... | |
BLAZE_ALWAYS_INLINE const SIMDcint32 | conj (const SIMDcint32 &a) noexcept=delete |
Complex conjugate of a vector of 32-bit integral complex values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const T | conj (const SIMDi64< T > &a) noexcept |
Complex conjugate of a vector of 64-bit integral values. More... | |
BLAZE_ALWAYS_INLINE const SIMDcint64 | conj (const SIMDcint64 &a) noexcept=delete |
Complex conjugate of a vector of 64-bit integral complex values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const T | conj (const SIMDf32< T > &a) noexcept |
Complex conjugate of a vector of single precision floating point values. More... | |
BLAZE_ALWAYS_INLINE const SIMDcfloat | conj (const SIMDcfloat &a) noexcept=delete |
Complex conjugate of a vector of single precision complex values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const T | conj (const SIMDf64< T > &a) noexcept |
Complex conjugate of a vector of double precision floating point values. More... | |
BLAZE_ALWAYS_INLINE const SIMDcdouble | conj (const SIMDcdouble &a) noexcept=delete |
Complex conjugate of a vector of double precision complex values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const SIMDfloat | cos (const SIMDf32< T > &a) noexcept=delete |
Cosine of a vector of single precision floating point values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const SIMDdouble | cos (const SIMDf64< T > &a) noexcept=delete |
Cosine of a vector of double precision floating point values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const SIMDfloat | cosh (const SIMDf32< T > &a) noexcept=delete |
Hyperbolic cosine of a vector of single precision floating point values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const SIMDdouble | cosh (const SIMDf64< T > &a) noexcept=delete |
Hyperbolic cosine of a vector of double precision floating point values. More... | |
BLAZE_ALWAYS_INLINE const SIMDint8 | operator/ (const SIMDint8 &a, const SIMDint8 &b) noexcept=delete |
Division of two vectors of 8-bit signed integral SIMD values. More... | |
BLAZE_ALWAYS_INLINE const SIMDcint8 | operator/ (const SIMDcint8 &a, const SIMDint8 &b) noexcept=delete |
Scaling of a vector of 8-bit signed integral complex SIMD values. More... | |
BLAZE_ALWAYS_INLINE const SIMDint16 | operator/ (const SIMDint16 &a, const SIMDint16 &b) noexcept=delete |
Division of two vectors of 16-bit signed integral SIMD values. More... | |
BLAZE_ALWAYS_INLINE const SIMDcint16 | operator/ (const SIMDcint16 &a, const SIMDint16 &b) noexcept=delete |
Scaling of a vector of 16-bit signed integral complex SIMD values. More... | |
BLAZE_ALWAYS_INLINE const SIMDint32 | operator/ (const SIMDint32 &a, const SIMDint32 &b) noexcept=delete |
Division of two vectors of 32-bit signed integral SIMD values. More... | |
BLAZE_ALWAYS_INLINE const SIMDcint32 | operator/ (const SIMDcint32 &a, const SIMDint32 &b) noexcept=delete |
Scaling of a vector of 32-bit signed integral complex SIMD values. More... | |
BLAZE_ALWAYS_INLINE const SIMDint64 | operator/ (const SIMDint64 &a, const SIMDint64 &b) noexcept=delete |
Division of two vectors of 64-bit signed integral SIMD values. More... | |
BLAZE_ALWAYS_INLINE const SIMDcint64 | operator/ (const SIMDcint64 &a, const SIMDint64 &b) noexcept=delete |
Scaling of a vector of 64-bit signed integral complex SIMD values. More... | |
template<typename T1 , typename T2 > | |
BLAZE_ALWAYS_INLINE const SIMDfloat | operator/ (const SIMDf32< T1 > &a, const SIMDf32< T2 > &b) noexcept=delete |
Division of two vectors of single precision floating point SIMD values. More... | |
BLAZE_ALWAYS_INLINE const SIMDcfloat | operator/ (const SIMDcfloat &a, const SIMDfloat &b) noexcept=delete |
Scaling of a vector of single precision floating point values complex SIMD values. More... | |
template<typename T1 , typename T2 > | |
BLAZE_ALWAYS_INLINE const SIMDdouble | operator/ (const SIMDf64< T1 > &a, const SIMDf64< T2 > &b) noexcept=delete |
Division of two vectors of double precision floating point SIMD values. More... | |
BLAZE_ALWAYS_INLINE const SIMDcdouble | operator/ (const SIMDcdouble &a, const SIMDdouble &b) noexcept=delete |
Scaling of a vector of double precision floating point values complex SIMD values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE bool | operator== (const SIMDi8< T > &a, const SIMDi8< T > &b) noexcept |
Equality comparison of two vectors of 8-bit integral SIMD values of the same type. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE bool | operator== (const SIMDci8< T > &a, const SIMDci8< T > &b) noexcept |
Equality comparison of two vectors of 8-bit integral SIMD complex values of the same type. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE bool | operator== (const SIMDi16< T > &a, const SIMDi16< T > &b) noexcept |
Equality comparison of two vectors of 16-bit integral SIMD values of the same type. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE bool | operator== (const SIMDci16< T > &a, const SIMDci16< T > &b) noexcept |
Equality comparison of two vectors of 16-bit integral complex SIMD values of the same type. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE bool | operator== (const SIMDi32< T > &a, const SIMDi32< T > &b) noexcept |
Equality comparison of two vectors of 32-bit integral SIMD values of the same type. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE bool | operator== (const SIMDci32< T > &a, const SIMDci32< T > &b) noexcept |
Equality comparison of two vectors of 32-bit integral complex SIMD values of the same type. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE bool | operator== (const SIMDi64< T > &a, const SIMDi64< T > &b) noexcept |
Equality comparison of two vectors of 64-bit integral SIMD values of the same type. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE bool | operator== (const SIMDci64< T > &a, const SIMDci64< T > &b) noexcept |
Equality comparison of two vectors of 64-bit integral SIMD complex values of the same type. More... | |
template<typename T1 , typename T2 > | |
BLAZE_ALWAYS_INLINE bool | operator== (const SIMDf32< T1 > &a, const SIMDf32< T2 > &b) noexcept=delete |
Equality comparison of two vectors of single precision floating point SIMD values. More... | |
BLAZE_ALWAYS_INLINE bool | operator== (const SIMDcfloat &a, const SIMDcfloat &b) noexcept=delete |
Equality comparison of two vectors of single precision complex SIMD values. More... | |
template<typename T1 , typename T2 > | |
BLAZE_ALWAYS_INLINE bool | operator== (const SIMDf64< T1 > &a, const SIMDf64< T2 > &b) noexcept=delete |
Equality comparison of two vectors of double precision floating point SIMD values. More... | |
BLAZE_ALWAYS_INLINE bool | operator== (const SIMDcdouble &a, const SIMDcdouble &b) noexcept=delete |
Equality comparison of two vectors of double precision complex SIMD values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE bool | operator!= (const SIMDPack< T > &a, const SIMDPack< T > &b) noexcept |
Inequality comparison of two SIMD vectors of the same type. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const SIMDfloat | erf (const SIMDf32< T > &a) noexcept=delete |
Computes the error function for a vector of single precision floating point values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const SIMDdouble | erf (const SIMDf64< T > &a) noexcept=delete |
Computes the error function for a vector of double precision floating point values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const SIMDfloat | erfc (const SIMDf32< T > &a) noexcept=delete |
Computes the complementary error function for a vector of single precision floating point values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const SIMDdouble | erfc (const SIMDf64< T > &a) noexcept=delete |
Computes the complementary error function for a vector of double precision floating point values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const SIMDfloat | exp (const SIMDf32< T > &a) noexcept=delete |
Computes ![]() | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const SIMDdouble | exp (const SIMDf64< T > &a) noexcept=delete |
Computes ![]() | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const SIMDfloat | exp10 (const SIMDf32< T > &a) noexcept=delete |
Computes ![]() | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const SIMDdouble | exp10 (const SIMDf64< T > &a) noexcept=delete |
Computes ![]() | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const SIMDfloat | exp2 (const SIMDf32< T > &a) noexcept=delete |
Computes ![]() | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const SIMDdouble | exp2 (const SIMDf64< T > &a) noexcept=delete |
Computes ![]() | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const SIMDfloat | floor (const SIMDf32< T > &a) noexcept=delete |
Computes the largest integer value not greater than the given value for a vector of single precision floating point values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const SIMDdouble | floor (const SIMDf64< T > &a) noexcept=delete |
Computes the largest integer value not greater than the given value for a vector of double precision floating point values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const SIMDfloat | hypot (const SIMDf32< T > &a, const SIMDf32< T > &b) noexcept=delete |
Computes the length of the hypotenous of a right triangle of a vector of single precision floating point values ( ![]() | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const SIMDdouble | hypot (const SIMDf64< T > &a, const SIMDf64< T > &b) noexcept=delete |
Computes the length of the hypotenous of a right triangle of a vector of double precision floating point values ( ![]() | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const SIMDfloat | invcbrt (const SIMDf32< T > &a) noexcept=delete |
Computes the inverse cubic root for a vector of single precision floating point values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const SIMDdouble | invcbrt (const SIMDf64< T > &a) noexcept=delete |
Computes the inverse cubic root for a vector of double precision floating point values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const SIMDfloat | invsqrt (const SIMDf32< T > &a) noexcept=delete |
Computes the inverse square root for a vector of single precision floating point values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const SIMDdouble | invsqrt (const SIMDf64< T > &a) noexcept=delete |
Computes the inverse square root for a vector of double precision floating point values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const EnableIf_t< IsIntegral_v< T > &&HasSize_v< T, 1UL >, If_t< IsSigned_v< T >, SIMDint8, SIMDuint8 > > | loada (const T *address) noexcept |
Loads a vector of 1-byte integral values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const EnableIf_t< IsIntegral_v< T > &&HasSize_v< T, 1UL >, If_t< IsSigned_v< T >, SIMDcint8, SIMDcuint8 > > | loada (const complex< T > *address) noexcept |
Loads a vector of 1-byte integral complex values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const EnableIf_t< IsIntegral_v< T > &&HasSize_v< T, 2UL >, If_t< IsSigned_v< T >, SIMDint16, SIMDuint16 > > | loada (const T *address) noexcept |
Loads a vector of 2-byte integral values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const EnableIf_t< IsIntegral_v< T > &&HasSize_v< T, 2UL >, If_t< IsSigned_v< T >, SIMDcint16, SIMDcuint16 > > | loada (const complex< T > *address) noexcept |
Loads a vector of 2-byte integral complex values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const EnableIf_t< IsIntegral_v< T > &&HasSize_v< T, 4UL >, If_t< IsSigned_v< T >, SIMDint32, SIMDuint32 > > | loada (const T *address) noexcept |
Loads a vector of 4-byte integral values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const EnableIf_t< IsIntegral_v< T > &&HasSize_v< T, 4UL >, If_t< IsSigned_v< T >, SIMDcint32, SIMDcuint32 > > | loada (const complex< T > *address) noexcept |
Loads a vector of 4-byte integral complex values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const EnableIf_t< IsIntegral_v< T > &&HasSize_v< T, 8UL >, If_t< IsSigned_v< T >, SIMDint64, SIMDuint64 > > | loada (const T *address) noexcept |
Loads a vector of 8-byte integral values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const EnableIf_t< IsIntegral_v< T > &&HasSize_v< T, 8UL >, If_t< IsSigned_v< T >, SIMDcint64, SIMDcuint64 > > | loada (const complex< T > *address) noexcept |
Loads a vector of 8-byte integral complex values. More... | |
BLAZE_ALWAYS_INLINE const SIMDfloat | loada (const float *address) noexcept |
Loads a vector of 'float' values. More... | |
BLAZE_ALWAYS_INLINE const SIMDcfloat | loada (const complex< float > *address) noexcept |
Loads a vector of 'complex<float>' values. More... | |
BLAZE_ALWAYS_INLINE const SIMDdouble | loada (const double *address) noexcept |
Loads a vector of 'double' values. More... | |
BLAZE_ALWAYS_INLINE const SIMDcdouble | loada (const complex< double > *address) noexcept |
Loads a vector of 'complex<double>' values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const EnableIf_t< IsIntegral_v< T > &&HasSize_v< T, 1UL >, If_t< IsSigned_v< T >, SIMDint8, SIMDuint8 > > | loadu (const T *address) noexcept |
Loads a vector of 1-byte integral values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const EnableIf_t< IsIntegral_v< T > &&HasSize_v< T, 1UL >, If_t< IsSigned_v< T >, SIMDcint8, SIMDcuint8 > > | loadu (const complex< T > *address) noexcept |
Loads a vector of 1-byte integral complex values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const EnableIf_t< IsIntegral_v< T > &&HasSize_v< T, 2UL >, If_t< IsSigned_v< T >, SIMDint16, SIMDuint16 > > | loadu (const T *address) noexcept |
Loads a vector of 2-byte integral values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const EnableIf_t< IsIntegral_v< T > &&HasSize_v< T, 2UL >, If_t< IsSigned_v< T >, SIMDcint16, SIMDcuint16 > > | loadu (const complex< T > *address) noexcept |
Loads a vector of 2-byte integral complex values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const EnableIf_t< IsIntegral_v< T > &&HasSize_v< T, 4UL >, If_t< IsSigned_v< T >, SIMDint32, SIMDuint32 > > | loadu (const T *address) noexcept |
Loads a vector of 4-byte integral values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const EnableIf_t< IsIntegral_v< T > &&HasSize_v< T, 4UL >, If_t< IsSigned_v< T >, SIMDcint32, SIMDcuint32 > > | loadu (const complex< T > *address) noexcept |
Loads a vector of 4-byte integral complex values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const EnableIf_t< IsIntegral_v< T > &&HasSize_v< T, 8UL >, If_t< IsSigned_v< T >, SIMDint64, SIMDuint64 > > | loadu (const T *address) noexcept |
Loads a vector of 8-byte integral values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const EnableIf_t< IsIntegral_v< T > &&HasSize_v< T, 8UL >, If_t< IsSigned_v< T >, SIMDcint64, SIMDcuint64 > > | loadu (const complex< T > *address) noexcept |
Loads a vector of 8-byte integral complex values. More... | |
BLAZE_ALWAYS_INLINE const SIMDfloat | loadu (const float *address) noexcept |
Loads a vector of 'float' values. More... | |
BLAZE_ALWAYS_INLINE const SIMDcfloat | loadu (const complex< float > *address) noexcept |
Loads a vector of 'complex<float>' values. More... | |
BLAZE_ALWAYS_INLINE const SIMDdouble | loadu (const double *address) noexcept |
Loads a vector of 'double' values. More... | |
BLAZE_ALWAYS_INLINE const SIMDcdouble | loadu (const complex< double > *address) noexcept |
Loads a vector of 'complex<double>' values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const SIMDfloat | log (const SIMDf32< T > &a) noexcept=delete |
Computes the natural logarithm for a vector of single precision floating point values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const SIMDdouble | log (const SIMDf64< T > &a) noexcept=delete |
Computes the natural logarithm for a vector of double precision floating point values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const SIMDfloat | log10 (const SIMDf32< T > &a) noexcept=delete |
Computes the common logarithm for a vector of single precision floating point values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const SIMDdouble | log10 (const SIMDf64< T > &a) noexcept=delete |
Computes the common logarithm for a vector of double precision floating point values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const SIMDfloat | log2 (const SIMDf32< T > &a) noexcept=delete |
Computes the binary logarithm for a vector of single precision floating point values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const SIMDdouble | log2 (const SIMDf64< T > &a) noexcept=delete |
Computes the binary logarithm for a vector of double precision floating point values. More... | |
BLAZE_ALWAYS_INLINE const SIMDint8 | max (const SIMDint8 &a, const SIMDint8 &b) noexcept=delete |
Componentwise maximum of two vectors of 8-bit signed integral SIMD values. More... | |
BLAZE_ALWAYS_INLINE const SIMDuint8 | max (const SIMDuint8 &a, const SIMDuint8 &b) noexcept=delete |
Componentwise maximum of two vectors of 8-bit unsigned integral SIMD values. More... | |
BLAZE_ALWAYS_INLINE const SIMDint16 | max (const SIMDint16 &a, const SIMDint16 &b) noexcept=delete |
Componentwise maximum of two vectors of 16-bit signed integral SIMD values. More... | |
BLAZE_ALWAYS_INLINE const SIMDuint16 | max (const SIMDuint16 &a, const SIMDuint16 &b) noexcept=delete |
Componentwise maximum of two vectors of 16-bit unsigned integral SIMD values. More... | |
BLAZE_ALWAYS_INLINE const SIMDint32 | max (const SIMDint32 &a, const SIMDint32 &b) noexcept=delete |
Componentwise maximim of two vectors of 32-bit signed integral SIMD values. More... | |
BLAZE_ALWAYS_INLINE const SIMDuint32 | max (const SIMDuint32 &a, const SIMDuint32 &b) noexcept=delete |
Componentwise maximum of two vectors of 32-bit unsigned integral SIMD values. More... | |
template<typename T1 , typename T2 > | |
BLAZE_ALWAYS_INLINE const SIMDfloat | max (const SIMDf32< T1 > &a, const SIMDf32< T2 > &b) noexcept=delete |
Componentwise maximum of two vectors of single precision floating point SIMD values. More... | |
template<typename T1 , typename T2 > | |
BLAZE_ALWAYS_INLINE const SIMDdouble | max (const SIMDf64< T1 > &a, const SIMDf64< T2 > &b) noexcept=delete |
Componentwise maximum of two vectors of double precision floating point SIMD values. More... | |
BLAZE_ALWAYS_INLINE const SIMDint8 | min (const SIMDint8 &a, const SIMDint8 &b) noexcept=delete |
Componentwise minimum of two vectors of 8-bit signed integral SIMD values. More... | |
BLAZE_ALWAYS_INLINE const SIMDuint8 | min (const SIMDuint8 &a, const SIMDuint8 &b) noexcept=delete |
Componentwise minimum of two vectors of 8-bit unsigned integral SIMD values. More... | |
BLAZE_ALWAYS_INLINE const SIMDint16 | min (const SIMDint16 &a, const SIMDint16 &b) noexcept=delete |
Componentwise minimum of two vectors of 16-bit signed integral SIMD values. More... | |
BLAZE_ALWAYS_INLINE const SIMDuint16 | min (const SIMDuint16 &a, const SIMDuint16 &b) noexcept=delete |
Componentwise minimum of two vectors of 16-bit unsigned integral SIMD values. More... | |
BLAZE_ALWAYS_INLINE const SIMDint32 | min (const SIMDint32 &a, const SIMDint32 &b) noexcept=delete |
Componentwise minimum of two vectors of 32-bit signed integral SIMD values. More... | |
BLAZE_ALWAYS_INLINE const SIMDuint32 | min (const SIMDuint32 &a, const SIMDuint32 &b) noexcept=delete |
Componentwise minimum of two vectors of 32-bit unsigned integral SIMD values. More... | |
template<typename T1 , typename T2 > | |
BLAZE_ALWAYS_INLINE const SIMDfloat | min (const SIMDf32< T1 > &a, const SIMDf32< T2 > &b) noexcept=delete |
Componentwise minimum of two vectors of single precision floating point SIMD values. More... | |
template<typename T1 , typename T2 > | |
BLAZE_ALWAYS_INLINE const SIMDdouble | min (const SIMDf64< T1 > &a, const SIMDf64< T2 > &b) noexcept=delete |
Componentwise minimum of two vectors of double precision floating point SIMD values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const T | operator * (const SIMDi16< T > &a, const SIMDi16< T > &b) noexcept=delete |
Multiplication of two vectors of 16-bit integral SIMD values of the same type. More... | |
template<typename T1 , typename T2 > | |
BLAZE_ALWAYS_INLINE const SIMDuint16 | operator * (const SIMDi16< T1 > &a, const SIMDi16< T2 > &b) noexcept=delete |
Multiplication of two vectors of 16-bit integral SIMD values of different type. More... | |
BLAZE_ALWAYS_INLINE const SIMDcint16 | operator * (const SIMDcint16 &a, const SIMDint16 &b) noexcept=delete |
Scaling of a vector of 16-bit signed integral complex SIMD values. More... | |
BLAZE_ALWAYS_INLINE const SIMDcuint16 | operator * (const SIMDcuint16 &a, const SIMDuint16 &b) noexcept=delete |
Scaling of a vector of 16-bit unsigned integral complex SIMD values. More... | |
BLAZE_ALWAYS_INLINE const SIMDcint16 | operator * (const SIMDint16 &a, const SIMDcint16 &b) noexcept=delete |
Scaling of a vector of 16-bit signed integral complex SIMD values. More... | |
BLAZE_ALWAYS_INLINE const SIMDcuint16 | operator * (const SIMDuint16 &a, const SIMDcuint16 &b) noexcept=delete |
Scaling of a vector of 16-bit unsigned integral complex SIMD values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const T | operator * (const SIMDci16< T > &a, const SIMDci16< T > &b) noexcept=delete |
Multiplication of two vectors of 16-bit integral complex SIMD values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const T | operator * (const SIMDi32< T > &a, const SIMDi32< T > &b) noexcept=delete |
Multiplication of two vectors of 32-bit integral SIMD values of the same type. More... | |
template<typename T1 , typename T2 > | |
BLAZE_ALWAYS_INLINE const SIMDuint32 | operator * (const SIMDi32< T1 > &a, const SIMDi32< T2 > &b) noexcept=delete |
Multiplication of two vectors of 32-bit integral SIMD values of different type. More... | |
BLAZE_ALWAYS_INLINE const SIMDcint32 | operator * (const SIMDcint32 &a, const SIMDint32 &b) noexcept=delete |
Scaling of a vector of 32-bit signed integral complex SIMD values. More... | |
BLAZE_ALWAYS_INLINE const SIMDcuint32 | operator * (const SIMDcuint32 &a, const SIMDuint32 &b) noexcept=delete |
Scaling of a vector of 32-bit unsigned integral complex SIMD values. More... | |
template<typename T1 , typename T2 > | |
BLAZE_ALWAYS_INLINE const SIMDcint32 | operator * (const SIMDint32 &a, const SIMDcint32 &b) noexcept=delete |
Scaling of a vector of 32-bit signed integral complex SIMD values. More... | |
template<typename T1 , typename T2 > | |
BLAZE_ALWAYS_INLINE const SIMDcuint32 | operator * (const SIMDuint32 &a, const SIMDcuint32 &b) noexcept=delete |
Scaling of a vector of 32-bit unsigned integral complex SIMD values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const T | operator * (const SIMDci32< T > &a, const SIMDci32< T > &b) noexcept=delete |
Multiplication of two vectors of 32-bit integral complex SIMD values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const T | operator * (const SIMDi64< T > &a, const SIMDi64< T > &b) noexcept=delete |
Multiplication of two vectors of 64-bit integral SIMD values of the same type. More... | |
template<typename T1 , typename T2 > | |
BLAZE_ALWAYS_INLINE const SIMDuint64 | operator * (const SIMDi64< T1 > &a, const SIMDi64< T2 > &b) noexcept=delete |
Multiplication of two vectors of 64-bit integral SIMD values of different type. More... | |
BLAZE_ALWAYS_INLINE const SIMDcint64 | operator * (const SIMDcint64 &a, const SIMDint64 &b) noexcept=delete |
Scaling of a vector of 64-bit signed integral complex SIMD values. More... | |
BLAZE_ALWAYS_INLINE const SIMDcuint64 | operator * (const SIMDcuint64 &a, const SIMDuint64 &b) noexcept=delete |
Scaling of a vector of 64-bit unsigned integral complex SIMD values. More... | |
template<typename T1 , typename T2 > | |
BLAZE_ALWAYS_INLINE const SIMDcint64 | operator * (const SIMDint64 &a, const SIMDcint64 &b) noexcept=delete |
Scaling of a vector of 64-bit signed integral complex SIMD values. More... | |
template<typename T1 , typename T2 > | |
BLAZE_ALWAYS_INLINE const SIMDcuint64 | operator * (const SIMDuint64 &a, const SIMDcuint64 &b) noexcept=delete |
Scaling of a vector of 64-bit unsigned integral complex SIMD values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const T | operator * (const SIMDci64< T > &a, const SIMDci64< T > &b) noexcept=delete |
Multiplication of two vectors of 64-bit integral complex SIMD values. More... | |
template<typename T1 , typename T2 > | |
BLAZE_ALWAYS_INLINE const SIMDf32MultExpr< T1, T2 > | operator * (const SIMDf32< T1 > &a, const SIMDf32< T2 > &b) noexcept |
Multiplication of two vectors of single precision floating point SIMD values. More... | |
BLAZE_ALWAYS_INLINE const SIMDcfloat | operator * (const SIMDcfloat &a, const SIMDfloat &b) noexcept=delete |
Scaling of a vector of single precision complex SIMD values. More... | |
BLAZE_ALWAYS_INLINE const SIMDcfloat | operator * (const SIMDfloat &a, const SIMDcfloat &b) noexcept=delete |
Scaling of a vector of single precision complex SIMD values. More... | |
BLAZE_ALWAYS_INLINE const SIMDcfloat | operator * (const SIMDcfloat &a, const SIMDcfloat &b) noexcept=delete |
Multiplication of two vectors of single precision complex SIMD values. More... | |
template<typename T1 , typename T2 > | |
BLAZE_ALWAYS_INLINE const SIMDf64MultExpr< T1, T2 > | operator * (const SIMDf64< T1 > &a, const SIMDf64< T2 > &b) noexcept |
Multiplication of two vectors of double precision floating point SIMD values. More... | |
BLAZE_ALWAYS_INLINE const SIMDcdouble | operator * (const SIMDcdouble &a, const SIMDdouble &b) noexcept=delete |
Scaling of a vector of double precision complex SIMD values. More... | |
BLAZE_ALWAYS_INLINE const SIMDcdouble | operator * (const SIMDdouble &a, const SIMDcdouble &b) noexcept=delete |
Scaling of a vector of double precision complex SIMD values. More... | |
BLAZE_ALWAYS_INLINE const SIMDcdouble | operator * (const SIMDcdouble &a, const SIMDcdouble &b) noexcept=delete |
Multiplication of two vectors of double precision complex SIMD values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const SIMDfloat | pow (const SIMDf32< T > &a, const SIMDf32< T > &b) noexcept=delete |
Computes the exponential value of a vector of single precision floating point values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const SIMDdouble | pow (const SIMDf64< T > &a, const SIMDf64< T > &b) noexcept=delete |
Computes the exponential value of a vector of double precision floating point values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE ValueType_t< T > | prod (const SIMDi8< T > &a) noexcept |
Returns the product of all elements in the 8-bit integral SIMD vector. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const ValueType_t< T > | prod (const SIMDci8< T > &a) noexcept |
Returns the product of all elements in the 8-bit integral complex SIMD vector. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE ValueType_t< T > | prod (const SIMDi16< T > &a) noexcept |
Returns the product of all elements in the 16-bit integral SIMD vector. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const ValueType_t< T > | prod (const SIMDci16< T > &a) noexcept |
Returns the product of all elements in the 16-bit integral complex SIMD vector. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE ValueType_t< T > | prod (const SIMDi32< T > &a) noexcept |
Returns the product of all elements in the 32-bit integral SIMD vector. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const ValueType_t< T > | prod (const SIMDci32< T > &a) noexcept |
Returns the product of all elements in the 32-bit integral complex SIMD vector. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE ValueType_t< T > | prod (const SIMDi64< T > &a) noexcept |
Returns the product of all elements in the 64-bit integral SIMD vector. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const ValueType_t< T > | prod (const SIMDci64< T > &a) noexcept |
Returns the product of all elements in the 64-bit integral complex SIMD vector. More... | |
BLAZE_ALWAYS_INLINE float | prod (const SIMDfloat &a) noexcept |
Returns the product of all elements in the single precision floating point SIMD vector. More... | |
BLAZE_ALWAYS_INLINE const complex< float > | prod (const SIMDcfloat &a) noexcept |
Returns the product of all elements in the single precision complex SIMD vector. More... | |
BLAZE_ALWAYS_INLINE double | prod (const SIMDdouble &a) noexcept |
Returns the product of all elements in the double precision floating point SIMD vector. More... | |
BLAZE_ALWAYS_INLINE const complex< double > | prod (const SIMDcdouble &a) noexcept |
Returns the product of all elements in the double precision complex SIMD vector. More... | |
template<typename T , typename OP > | |
decltype(auto) | reduce (const SIMDPack< T > &a, OP op) |
Reduces the elements in the given SIMD vector. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const SIMDfloat | round (const SIMDf32< T > &a) noexcept=delete |
Computes the nearest integers for a vector of single precision floating point values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const SIMDdouble | round (const SIMDf64< T > &a) noexcept=delete |
Computes the nearest integers for a vector of double precision floating point values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const EnableIf_t< IsIntegral_v< T > &&HasSize_v< T, 1UL >, If_t< IsSigned_v< T >, SIMDint8, SIMDuint8 > > | set (T value) noexcept |
Sets all values in the vector to the given 1-byte integral value. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const EnableIf_t< IsIntegral_v< T > &&HasSize_v< T, 1UL >, If_t< IsSigned_v< T >, SIMDcint8, SIMDcuint8 > > | set (complex< T > value) noexcept |
Sets all values in the vector to the given 1-byte integral complex value. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const EnableIf_t< IsIntegral_v< T > &&HasSize_v< T, 2UL >, If_t< IsSigned_v< T >, SIMDint16, SIMDuint16 > > | set (T value) noexcept |
Sets all values in the vector to the given 2-byte integral value. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const EnableIf_t< IsIntegral_v< T > &&HasSize_v< T, 2UL >, If_t< IsSigned_v< T >, SIMDcint16, SIMDcuint16 > > | set (complex< T > value) noexcept |
Sets all values in the vector to the given 2-byte integral complex value. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const EnableIf_t< IsIntegral_v< T > &&HasSize_v< T, 4UL >, If_t< IsSigned_v< T >, SIMDint32, SIMDuint32 > > | set (T value) noexcept |
Sets all values in the vector to the given 4-byte integral value. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const EnableIf_t< IsIntegral_v< T > &&HasSize_v< T, 4UL >, If_t< IsSigned_v< T >, SIMDcint32, SIMDcuint32 > > | set (complex< T > value) noexcept |
Sets all values in the vector to the given 4-byte integral complex value. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const EnableIf_t< IsIntegral_v< T > &&HasSize_v< T, 8UL >, If_t< IsSigned_v< T >, SIMDint64, SIMDuint64 > > | set (T value) noexcept |
Sets all values in the vector to the given 8-byte integral value. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const EnableIf_t< IsIntegral_v< T > &&HasSize_v< T, 8UL >, If_t< IsSigned_v< T >, SIMDcint64, SIMDcuint64 > > | set (complex< T > value) noexcept |
Sets all values in the vector to the given 8-byte integral complex value. More... | |
BLAZE_ALWAYS_INLINE const SIMDfloat | set (float value) noexcept |
Sets all values in the vector to the given 'float' value. More... | |
BLAZE_ALWAYS_INLINE const SIMDcfloat | set (const complex< float > &value) noexcept |
Sets all values in the vector to the given 'complex<float>' value. More... | |
BLAZE_ALWAYS_INLINE const SIMDdouble | set (double value) noexcept |
Sets all values in the vector to the given 'double' value. More... | |
BLAZE_ALWAYS_INLINE const SIMDcdouble | set (const complex< double > &value) noexcept |
Sets all values in the vector to the given 'complex<double>' value. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE void | setzero (SIMDi8< T > &value) noexcept |
Setting an integral SIMD type with 8-bit data values to zero. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE void | setzero (SIMDci8< T > &value) noexcept |
Setting an integral SIMD type with 8-bit complex values to zero. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE void | setzero (SIMDi16< T > &value) noexcept |
Setting an integral SIMD type with 16-bit data values to zero. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE void | setzero (SIMDci16< T > &value) noexcept |
Setting an integral SIMD type with 16-bit complex values to zero. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE void | setzero (SIMDi32< T > &value) noexcept |
Setting an integral SIMD type with 32-bit data values to zero. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE void | setzero (SIMDci32< T > &value) noexcept |
Setting an integral SIMD type with 32-bit complex values to zero. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE void | setzero (SIMDi64< T > &value) noexcept |
Setting an integral SIMD type with 64-bit data values to zero. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE void | setzero (SIMDci64< T > &value) noexcept |
Setting an integral SIMD type with 64-bit complex values to zero. More... | |
BLAZE_ALWAYS_INLINE void | setzero (SIMDfloat &value) noexcept |
Setting a floating point SIMD type with 32-bit single precision data values to zero. More... | |
BLAZE_ALWAYS_INLINE void | setzero (SIMDcfloat &value) noexcept |
Setting a floating point SIMD type with 32-bit single precision complex values to zero. More... | |
BLAZE_ALWAYS_INLINE void | setzero (SIMDdouble &value) noexcept |
Setting a floating point SIMD type with 64-bit double precision data values to zero. More... | |
BLAZE_ALWAYS_INLINE void | setzero (SIMDcdouble &value) noexcept |
Setting a floating point SIMD type with 32-bit double precision complex values to zero. More... | |
BLAZE_ALWAYS_INLINE const SIMDint16 | operator<< (const SIMDint16 &a, int count) noexcept=delete |
Uniform left-shift of a vector of 16-bit signed integral SIMD values. More... | |
BLAZE_ALWAYS_INLINE const SIMDuint16 | operator<< (const SIMDuint16 &a, int count) noexcept=delete |
Uniform left-shift of a vector of 16-bit unsigned integral SIMD values. More... | |
BLAZE_ALWAYS_INLINE const SIMDint32 | operator<< (const SIMDint32 &a, int count) noexcept=delete |
Uniform left-shift of a vector of 32-bit signed integral SIMD values. More... | |
BLAZE_ALWAYS_INLINE const SIMDuint32 | operator<< (const SIMDuint32 &a, int count) noexcept=delete |
Uniform left-shift of a vector of 32-bit unsigned integral SIMD values. More... | |
BLAZE_ALWAYS_INLINE const SIMDint64 | operator<< (const SIMDint64 &a, int count) noexcept=delete |
Uniform left-shift of a vector of 64-bit signed integral SIMD values. More... | |
BLAZE_ALWAYS_INLINE const SIMDuint64 | operator<< (const SIMDuint64 &a, int count) noexcept=delete |
Uniform left-shift of a vector of 64-bit unsigned integral SIMD values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const SIMDint16 | operator<< (const SIMDint16 &a, const SIMDi16< T > &b) noexcept=delete |
Elementwise left-shift of a vector of 16-bit signed integral SIMD values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const SIMDuint16 | operator<< (const SIMDuint16 &a, const SIMDi16< T > &b) noexcept=delete |
Elementwise left-shift of a vector of 16-bit unsigned integral SIMD values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const SIMDint32 | operator<< (const SIMDint32 &a, const SIMDi32< T > &b) noexcept=delete |
Elementwise left-shift of a vector of 32-bit signed integral SIMD values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const SIMDuint32 | operator<< (const SIMDuint32 &a, const SIMDi32< T > &b) noexcept=delete |
Elementwise left-shift of a vector of 32-bit unsigned integral SIMD values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const SIMDint64 | operator<< (const SIMDint64 &a, const SIMDi64< T > &b) noexcept=delete |
Elementwise left-shift of a vector of 64-bit signed integral SIMD values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const SIMDuint64 | operator<< (const SIMDuint64 &a, const SIMDi64< T > &b) noexcept=delete |
Elementwise left-shift of a vector of 64-bit unsigned integral SIMD values. More... | |
BLAZE_ALWAYS_INLINE const SIMDint16 | operator>> (const SIMDint16 &a, int count) noexcept=delete |
Uniform right-shift of a vector of 16-bit signed integral SIMD values. More... | |
BLAZE_ALWAYS_INLINE const SIMDuint16 | operator>> (const SIMDuint16 &a, int count) noexcept=delete |
Uniform right-shift of a vector of 16-bit unsigned integral SIMD values. More... | |
BLAZE_ALWAYS_INLINE const SIMDint32 | operator>> (const SIMDint32 &a, int count) noexcept=delete |
Uniform right-shift of a vector of 32-bit signed integral SIMD values. More... | |
BLAZE_ALWAYS_INLINE const SIMDuint32 | operator>> (const SIMDuint32 &a, int count) noexcept=delete |
Uniform right-shift of a vector of 32-bit unsigned integral SIMD values. More... | |
BLAZE_ALWAYS_INLINE const SIMDint64 | operator>> (const SIMDint64 &a, int count) noexcept=delete |
Uniform right-shift of a vector of 64-bit signed integral SIMD values. More... | |
BLAZE_ALWAYS_INLINE const SIMDuint64 | operator>> (const SIMDuint64 &a, int count) noexcept=delete |
Uniform right-shift of a vector of 64-bit unsigned integral SIMD values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const SIMDint16 | operator>> (const SIMDint16 &a, const SIMDi16< T > &b) noexcept=delete |
Elementwise right-shift of a vector of 16-bit signed integral SIMD values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const SIMDuint16 | operator>> (const SIMDuint16 &a, const SIMDi16< T > &b) noexcept=delete |
Elementwise right-shift of a vector of 16-bit unsigned integral SIMD values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const SIMDint32 | operator>> (const SIMDint32 &a, const SIMDi32< T > &b) noexcept=delete |
Elementwise right-shift of a vector of 32-bit signed integral SIMD values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const SIMDuint32 | operator>> (const SIMDuint32 &a, const SIMDi32< T > &b) noexcept=delete |
Elementwise right-shift of a vector of 32-bit unsigned integral SIMD values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const SIMDint64 | operator>> (const SIMDint64 &a, const SIMDi64< T > &b) noexcept=delete |
Elementwise right-shift of a vector of 64-bit signed integral SIMD values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const SIMDuint64 | operator>> (const SIMDuint64 &a, const SIMDi64< T > &b) noexcept=delete |
Elementwise right-shift of a vector of 64-bit unsigned integral SIMD values. More... | |
BLAZE_ALWAYS_INLINE SIMDint8 | sign (const SIMDint8 &a) noexcept=delete |
Sign function for a vector of 8-bit signed integral values. More... | |
BLAZE_ALWAYS_INLINE SIMDint16 | sign (const SIMDint16 &a) noexcept=delete |
Sign function for a vector of 16-bit signed integral values. More... | |
BLAZE_ALWAYS_INLINE SIMDint32 | sign (const SIMDint32 &a) noexcept=delete |
Sign function for a vector of 32-bit signed integral values. More... | |
BLAZE_ALWAYS_INLINE SIMDint64 | sign (const SIMDint64 &a) noexcept=delete |
Sign function for a vector of 64-bit signed integral values. More... | |
BLAZE_ALWAYS_INLINE SIMDfloat | sign (const SIMDfloat &a) noexcept=delete |
Sign function for a vector of single precision floating point values. More... | |
BLAZE_ALWAYS_INLINE SIMDdouble | sign (const SIMDdouble &a) noexcept=delete |
Sign function for a vector of double precision floating point values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const SIMDfloat | sin (const SIMDf32< T > &a) noexcept=delete |
Sine of a vector of single precision floating point values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const SIMDdouble | sin (const SIMDf64< T > &a) noexcept=delete |
Sine of a vector of double precision floating point values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const SIMDfloat | sinh (const SIMDf32< T > &a) noexcept=delete |
Hyperbolic sine of a vector of single precision floating point values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const SIMDdouble | sinh (const SIMDf64< T > &a) noexcept=delete |
Hyperbolic sine of a vector of double precision floating point values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const SIMDfloat | sqrt (const SIMDf32< T > &a) noexcept=delete |
Computes the square root for a vector of single precision floating point values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const SIMDdouble | sqrt (const SIMDf64< T > &a) noexcept=delete |
Computes the square root for a vector of double precision floating point values. More... | |
template<typename T1 , typename T2 > | |
BLAZE_ALWAYS_INLINE EnableIf_t< IsIntegral_v< T1 > &&HasSize_v< T1, 1UL > > | storea (T1 *address, const SIMDi8< T2 > &value) noexcept |
Aligned store of a vector of 1-byte integral values. More... | |
template<typename T1 , typename T2 > | |
BLAZE_ALWAYS_INLINE EnableIf_t< IsIntegral_v< T1 > &&HasSize_v< T1, 1UL > > | storea (complex< T1 > *address, const SIMDci8< T2 > &value) noexcept |
Aligned store of a vector of 1-byte integral complex values. More... | |
template<typename T1 , typename T2 > | |
BLAZE_ALWAYS_INLINE EnableIf_t< IsIntegral_v< T1 > &&HasSize_v< T1, 2UL > > | storea (T1 *address, const SIMDi16< T2 > &value) noexcept |
Aligned store of a vector of 2-byte integral values. More... | |
template<typename T1 , typename T2 > | |
BLAZE_ALWAYS_INLINE EnableIf_t< IsIntegral_v< T1 > &&HasSize_v< T1, 2UL > > | storea (complex< T1 > *address, const SIMDci16< T2 > &value) noexcept |
Aligned store of a vector of 2-byte integral complex values. More... | |
template<typename T1 , typename T2 > | |
BLAZE_ALWAYS_INLINE EnableIf_t< IsIntegral_v< T1 > &&HasSize_v< T1, 4UL > > | storea (T1 *address, const SIMDi32< T2 > &value) noexcept |
Aligned store of a vector of 4-byte integral values. More... | |
template<typename T1 , typename T2 > | |
BLAZE_ALWAYS_INLINE EnableIf_t< IsIntegral_v< T1 > &&HasSize_v< T1, 4UL > > | storea (complex< T1 > *address, const SIMDci32< T2 > &value) noexcept |
Aligned store of a vector of 4-byte integral complex values. More... | |
template<typename T1 , typename T2 > | |
BLAZE_ALWAYS_INLINE EnableIf_t< IsIntegral_v< T1 > &&HasSize_v< T1, 8UL > > | storea (T1 *address, const SIMDi64< T2 > &value) noexcept |
Aligned store of a vector of 8-byte integral values. More... | |
template<typename T1 , typename T2 > | |
BLAZE_ALWAYS_INLINE EnableIf_t< IsIntegral_v< T1 > &&HasSize_v< T1, 8UL > > | storea (complex< T1 > *address, const SIMDci64< T2 > &value) noexcept |
Aligned store of a vector of 8-byte integral complex values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE void | storea (float *address, const SIMDf32< T > &value) noexcept |
Aligned store of a vector of 'float' values. More... | |
BLAZE_ALWAYS_INLINE void | storea (complex< float > *address, const SIMDcfloat &value) noexcept |
Aligned store of a vector of 'complex<float>' values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE void | storea (double *address, const SIMDf64< T > &value) noexcept |
Aligned store of a vector of 'double' values. More... | |
BLAZE_ALWAYS_INLINE void | storea (complex< double > *address, const SIMDcdouble &value) noexcept |
Aligned store of a vector of 'complex<double>' values. More... | |
template<typename T1 , typename T2 > | |
BLAZE_ALWAYS_INLINE EnableIf_t< IsIntegral_v< T1 > &&HasSize_v< T1, 1UL > > | storeu (T1 *address, const SIMDi8< T2 > &value) noexcept |
Unaligned store of a vector of 1-byte integral values. More... | |
template<typename T1 , typename T2 > | |
BLAZE_ALWAYS_INLINE EnableIf_t< IsIntegral_v< T1 > &&HasSize_v< T1, 1UL > > | storeu (complex< T1 > *address, const SIMDci8< T2 > &value) noexcept |
Unaligned store of a vector of 1-byte integral complex values. More... | |
template<typename T1 , typename T2 > | |
BLAZE_ALWAYS_INLINE EnableIf_t< IsIntegral_v< T1 > &&HasSize_v< T1, 2UL > > | storeu (T1 *address, const SIMDi16< T2 > &value) noexcept |
Unaligned store of a vector of 2-byte integral values. More... | |
template<typename T1 , typename T2 > | |
BLAZE_ALWAYS_INLINE EnableIf_t< IsIntegral_v< T1 > &&HasSize_v< T1, 2UL > > | storeu (complex< T1 > *address, const SIMDci16< T2 > &value) noexcept |
Unaligned store of a vector of 2-byte integral complex values. More... | |
template<typename T1 , typename T2 > | |
BLAZE_ALWAYS_INLINE EnableIf_t< IsIntegral_v< T1 > &&HasSize_v< T1, 4UL > > | storeu (T1 *address, const SIMDi32< T2 > &value) noexcept |
Unaligned store of a vector of 4-byte integral values. More... | |
template<typename T1 , typename T2 > | |
BLAZE_ALWAYS_INLINE EnableIf_t< IsIntegral_v< T1 > &&HasSize_v< T1, 4UL > > | storeu (complex< T1 > *address, const SIMDci32< T2 > &value) noexcept |
Unaligned store of a vector of 4-byte integral complex values. More... | |
template<typename T1 , typename T2 > | |
BLAZE_ALWAYS_INLINE EnableIf_t< IsIntegral_v< T1 > &&HasSize_v< T1, 8UL > > | storeu (T1 *address, const SIMDi64< T2 > &value) noexcept |
Unaligned store of a vector of 8-byte integral values. More... | |
template<typename T1 , typename T2 > | |
BLAZE_ALWAYS_INLINE EnableIf_t< IsIntegral_v< T1 > &&HasSize_v< T1, 8UL > > | storeu (complex< T1 > *address, const SIMDci64< T2 > &value) noexcept |
Unaligned store of a vector of 8-byte integral complex values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE void | storeu (float *address, const SIMDf32< T > &value) noexcept |
Unaligned store of a vector of 'float' values. More... | |
BLAZE_ALWAYS_INLINE void | storeu (complex< float > *address, const SIMDcfloat &value) noexcept |
Unaligned store of a vector of 'complex<float>' values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE void | storeu (double *address, const SIMDf64< T > &value) noexcept |
Unaligned store of a vector of 'double' values. More... | |
BLAZE_ALWAYS_INLINE void | storeu (complex< double > *address, const SIMDcdouble &value) noexcept |
Unaligned store of a vector of 'complex<double>' values. More... | |
template<typename T1 , typename T2 > | |
BLAZE_ALWAYS_INLINE EnableIf_t< IsIntegral_v< T1 > &&HasSize_v< T1, 1UL > > | stream (T1 *address, const SIMDi8< T2 > &value) noexcept |
Aligned, non-temporal store of a vector of 1-byte integral values. More... | |
template<typename T1 , typename T2 > | |
BLAZE_ALWAYS_INLINE EnableIf_t< IsIntegral_v< T1 > &&HasSize_v< T1, 1UL > > | stream (complex< T1 > *address, const SIMDci8< T2 > &value) noexcept |
Aligned, non-temporal store of a vector of 1-byte integral complex values. More... | |
template<typename T1 , typename T2 > | |
BLAZE_ALWAYS_INLINE EnableIf_t< IsIntegral_v< T1 > &&HasSize_v< T1, 2UL > > | stream (T1 *address, const SIMDi16< T2 > &value) noexcept |
Aligned, non-temporal store of a vector of 2-byte integral values. More... | |
template<typename T1 , typename T2 > | |
BLAZE_ALWAYS_INLINE EnableIf_t< IsIntegral_v< T1 > &&HasSize_v< T1, 2UL > > | stream (complex< T1 > *address, const SIMDci16< T2 > &value) noexcept |
Aligned, non-temporal store of a vector of 2-byte integral complex values. More... | |
template<typename T1 , typename T2 > | |
BLAZE_ALWAYS_INLINE EnableIf_t< IsIntegral_v< T1 > &&HasSize_v< T1, 4UL > > | stream (T1 *address, const SIMDi32< T2 > &value) noexcept |
Aligned, non-temporal store of a vector of 4-byte integral values. More... | |
template<typename T1 , typename T2 > | |
BLAZE_ALWAYS_INLINE EnableIf_t< IsIntegral_v< T1 > &&HasSize_v< T1, 4UL > > | stream (complex< T1 > *address, const SIMDci32< T2 > &value) noexcept |
Aligned, non-temporal store of a vector of 4-byte integral complex values. More... | |
template<typename T1 , typename T2 > | |
BLAZE_ALWAYS_INLINE EnableIf_t< IsIntegral_v< T1 > &&HasSize_v< T1, 8UL > > | stream (T1 *address, const SIMDi64< T2 > &value) noexcept |
Aligned, non-temporal store of a vector of 8-byte integral values. More... | |
template<typename T1 , typename T2 > | |
BLAZE_ALWAYS_INLINE EnableIf_t< IsIntegral_v< T1 > &&HasSize_v< T1, 8UL > > | stream (complex< T1 > *address, const SIMDci64< T2 > &value) noexcept |
Aligned, non-temporal store of a vector of 8-byte integral complex values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE void | stream (float *address, const SIMDf32< T > &value) noexcept |
Aligned, non-temporal store of a vector of 'float' values. More... | |
BLAZE_ALWAYS_INLINE void | stream (complex< float > *address, const SIMDcfloat &value) noexcept |
Aligned, non-temporal store of a vector of 'complex<float>' values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE void | stream (double *address, const SIMDf64< T > &value) noexcept |
Aligned, non-temporal store of a vector of 'double' values. More... | |
BLAZE_ALWAYS_INLINE void | stream (complex< double > *address, const SIMDcdouble &value) noexcept |
Aligned, non-temporal store of a vector of 'complex<double>' values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const T | operator- (const SIMDi8< T > &a, const SIMDi8< T > &b) noexcept=delete |
Subtraction of two vectors of 8-bit integral SIMD values of the same type. More... | |
template<typename T1 , typename T2 > | |
BLAZE_ALWAYS_INLINE const SIMDuint8 | operator- (const SIMDi8< T1 > &a, const SIMDi8< T2 > &b) noexcept=delete |
Subtraction of two vectors of 8-bit integral SIMD values of different type. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const T | operator- (const SIMDci8< T > &a, const SIMDci8< T > &b) noexcept=delete |
Subtraction of two vectors of 8-bit integral complex SIMD values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const T | operator- (const SIMDi16< T > &a, const SIMDi16< T > &b) noexcept=delete |
Subtraction of two vectors of 16-bit integral SIMD values of the same type. More... | |
template<typename T1 , typename T2 > | |
BLAZE_ALWAYS_INLINE const SIMDuint16 | operator- (const SIMDi16< T1 > &a, const SIMDi16< T2 > &b) noexcept=delete |
Subtraction of two vectors of 16-bit integral SIMD values of different type. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const T | operator- (const SIMDci16< T > &a, const SIMDci16< T > &b) noexcept=delete |
Subtraction of two vectors of 16-bit integral complex SIMD values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const T | operator- (const SIMDi32< T > &a, const SIMDi32< T > &b) noexcept=delete |
Subtraction of two vectors of 32-bit integral SIMD values of the same type. More... | |
template<typename T1 , typename T2 > | |
BLAZE_ALWAYS_INLINE const SIMDuint32 | operator- (const SIMDi32< T1 > &a, const SIMDi32< T2 > &b) noexcept=delete |
Subtraction of two vectors of 32-bit integral SIMD values of different type. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const T | operator- (const SIMDci32< T > &a, const SIMDci32< T > &b) noexcept=delete |
Subtraction of two vectors of 32-bit integral complex SIMD values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const T | operator- (const SIMDi64< T > &a, const SIMDi64< T > &b) noexcept=delete |
Subtraction of two vectors of 64-bit integral SIMD values of the same type. More... | |
template<typename T1 , typename T2 > | |
BLAZE_ALWAYS_INLINE const SIMDuint64 | operator- (const SIMDi64< T1 > &a, const SIMDi64< T2 > &b) noexcept=delete |
Subtraction of two vectors of 64-bit integral SIMD values of different type. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const T | operator- (const SIMDci64< T > &a, const SIMDci64< T > &b) noexcept=delete |
Subtraction of two vectors of 64-bit integral complex SIMD values. More... | |
template<typename T1 , typename T2 > | |
BLAZE_ALWAYS_INLINE const SIMDfloat | operator- (const SIMDf32< T1 > &a, const SIMDf32< T2 > &b) noexcept=delete |
Subtraction of two vectors of single precision floating point SIMD values. More... | |
BLAZE_ALWAYS_INLINE const SIMDcfloat | operator- (const SIMDcfloat &a, const SIMDcfloat &b) noexcept=delete |
Subtraction of two vectors of single precision complex SIMD values. More... | |
template<typename T1 , typename T2 > | |
BLAZE_ALWAYS_INLINE const SIMDdouble | operator- (const SIMDf64< T1 > &a, const SIMDf64< T2 > &b) noexcept=delete |
Subtraction of two vectors of double precision floating point SIMD values. More... | |
BLAZE_ALWAYS_INLINE const SIMDcdouble | operator- (const SIMDcdouble &a, const SIMDcdouble &b) noexcept=delete |
Subtraction of two vectors of double precision complex SIMD values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE ValueType_t< T > | sum (const SIMDi8< T > &a) noexcept |
Returns the sum of all elements in the 8-bit integral SIMD vector. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const ValueType_t< T > | sum (const SIMDci8< T > &a) noexcept |
Returns the sum of all elements in the 8-bit integral complex SIMD vector. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE ValueType_t< T > | sum (const SIMDi16< T > &a) noexcept |
Returns the sum of all elements in the 16-bit integral SIMD vector. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const ValueType_t< T > | sum (const SIMDci16< T > &a) noexcept |
Returns the sum of all elements in the 16-bit integral complex SIMD vector. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE ValueType_t< T > | sum (const SIMDi32< T > &a) noexcept |
Returns the sum of all elements in the 32-bit integral SIMD vector. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const ValueType_t< T > | sum (const SIMDci32< T > &a) noexcept |
Returns the sum of all elements in the 32-bit integral complex SIMD vector. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE ValueType_t< T > | sum (const SIMDi64< T > &a) noexcept |
Returns the sum of all elements in the 64-bit integral SIMD vector. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const ValueType_t< T > | sum (const SIMDci64< T > &a) noexcept |
Returns the sum of all elements in the 64-bit integral complex SIMD vector. More... | |
BLAZE_ALWAYS_INLINE float | sum (const SIMDfloat &a) noexcept |
Returns the sum of all elements in the single precision floating point SIMD vector. More... | |
BLAZE_ALWAYS_INLINE const complex< float > | sum (const SIMDcfloat &a) noexcept |
Returns the sum of all elements in the single precision complex SIMD vector. More... | |
BLAZE_ALWAYS_INLINE double | sum (const SIMDdouble &a) noexcept |
Returns the sum of all elements in the double precision floating point SIMD vector. More... | |
BLAZE_ALWAYS_INLINE const complex< double > | sum (const SIMDcdouble &a) noexcept |
Returns the sum of all elements in the double precision complex SIMD vector. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const SIMDfloat | tan (const SIMDf32< T > &a) noexcept=delete |
Tangent of a vector of single precision floating point values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const SIMDdouble | tan (const SIMDf64< T > &a) noexcept=delete |
Tangent of a vector of double precision floating point values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const SIMDfloat | tanh (const SIMDf32< T > &a) noexcept=delete |
Hyperbolic tangent of a vector of single precision floating point values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const SIMDdouble | tanh (const SIMDf64< T > &a) noexcept=delete |
Hyperbolic tangent of a vector of double precision floating point values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const SIMDfloat | trunc (const SIMDf32< T > &a) noexcept=delete |
Computes the nearest integer not greater in magnitude than the given value for a vector of single precision floating point values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE const SIMDdouble | trunc (const SIMDf64< T > &a) noexcept=delete |
Computes the nearest integer not greater in magnitude than the given value for a vector of double precision floating point values. More... | |
template<typename MT , bool SO> | |
IdentityMatrix< ElementType_t< MT >, SO > | declid (const Matrix< MT, SO > &m) |
Declares the given matrix expression m as identity matrix. More... | |
template<typename T , bool SO = defaultStorageOrder> | |
decltype(auto) constexpr | zero (size_t m, size_t n) noexcept |
Creating a zero matrix. More... | |
template<typename MT , bool SO> | |
ZeroMatrix< ElementType_t< MT >, SO > | declzero (const Matrix< MT, SO > &m) |
Declares the given matrix expression m as zero matrix. More... | |
template<typename T , bool TF = defaultTransposeFlag> | |
decltype(auto) constexpr | zero (size_t n) noexcept |
Creating a zero vector. More... | |
template<typename VT , bool TF> | |
ZeroVector< ElementType_t< VT >, TF > | declzero (const Vector< VT, TF > &v) |
Declares the given vector expression v as zero vector. More... | |
BLAZE_CREATE_HAS_DATA_OR_FUNCTION_MEMBER_TYPE_TRAIT (HasLoad, load) | |
Compile time check for data types.This type trait provides the information whether the given data type T provides a load() operation (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. | |
template<ptrdiff_t I, typename MT , bool SO, typename... RBAs> | |
decltype(auto) | band (Matrix< MT, SO > &matrix, RBAs... args) |
Creating a view on a specific band of the given matrix. More... | |
template<ptrdiff_t I, typename MT , bool SO, typename... RBAs> | |
decltype(auto) | band (const Matrix< MT, SO > &matrix, RBAs... args) |
Creating a view on a specific band of the given constant matrix. More... | |
template<ptrdiff_t I, typename MT , bool SO, typename... RBAs> | |
decltype(auto) | band (Matrix< MT, SO > &&matrix, RBAs... args) |
Creating a view on a specific band of the given temporary matrix. More... | |
template<typename MT , bool SO, typename... RBAs> | |
decltype(auto) | band (Matrix< MT, SO > &matrix, ptrdiff_t index, RBAs... args) |
Creating a view on a specific band of the given matrix. More... | |
template<typename MT , bool SO, typename... RBAs> | |
decltype(auto) | band (const Matrix< MT, SO > &matrix, ptrdiff_t index, RBAs... args) |
Creating a view on a specific band of the given constant matrix. More... | |
template<typename MT , bool SO, typename... RBAs> | |
decltype(auto) | band (Matrix< MT, SO > &&matrix, ptrdiff_t index, RBAs... args) |
Creating a view on a specific band of the given temporary matrix. More... | |
template<typename MT , bool SO, typename... RDAs> | |
decltype(auto) | diagonal (Matrix< MT, SO > &matrix, RDAs... args) |
Creating a view on the diagonal of the given matrix. More... | |
template<typename MT , bool SO, typename... RDAs> | |
decltype(auto) | diagonal (const Matrix< MT, SO > &matrix, RDAs... args) |
Creating a view on the diagonal of the given constant matrix. More... | |
template<typename MT , bool SO, typename... RDAs> | |
decltype(auto) | diagonal (Matrix< MT, SO > &&matrix, RDAs... args) |
Creating a view on the diagonal of the given temporary matrix. More... | |
template<size_t I, typename MT , bool SO, typename... RCAs> | |
decltype(auto) | column (Matrix< MT, SO > &matrix, RCAs... args) |
Creating a view on a specific column of the given matrix. More... | |
template<size_t I, typename MT , bool SO, typename... RCAs> | |
decltype(auto) | column (const Matrix< MT, SO > &matrix, RCAs... args) |
Creating a view on a specific column of the given constant matrix. More... | |
template<size_t I, typename MT , bool SO, typename... RCAs> | |
decltype(auto) | column (Matrix< MT, SO > &&matrix, RCAs... args) |
Creating a view on a specific column of the given temporary matrix. More... | |
template<typename MT , bool SO, typename... RCAs> | |
decltype(auto) | column (Matrix< MT, SO > &matrix, size_t index, RCAs... args) |
Creating a view on a specific column of the given matrix. More... | |
template<typename MT , bool SO, typename... RCAs> | |
decltype(auto) | column (const Matrix< MT, SO > &matrix, size_t index, RCAs... args) |
Creating a view on a specific column of the given constant matrix. More... | |
template<typename MT , bool SO, typename... RCAs> | |
decltype(auto) | column (Matrix< MT, SO > &&matrix, size_t index, RCAs... args) |
Creating a view on a specific column of the given temporary matrix. More... | |
template<size_t I, size_t... Is, typename MT , bool SO, typename... RCAs> | |
decltype(auto) | columns (Matrix< MT, SO > &matrix, RCAs... args) |
Creating a view on a selection of columns of the given matrix. More... | |
template<size_t I, size_t... Is, typename MT , bool SO, typename... RCAs> | |
decltype(auto) | columns (const Matrix< MT, SO > &matrix, RCAs... args) |
Creating a view on a selection of columns of the given constant matrix. More... | |
template<size_t I, size_t... Is, typename MT , bool SO, typename... RCAs> | |
decltype(auto) | columns (Matrix< MT, SO > &&matrix, RCAs... args) |
Creating a view on a selection of columns of the given temporary matrix. More... | |
template<typename MT , bool SO, typename T , typename... RCAs> | |
decltype(auto) | columns (Matrix< MT, SO > &matrix, T *indices, size_t n, RCAs... args) |
Creating a view on a selection of columns of the given matrix. More... | |
template<typename MT , bool SO, typename T , typename... RCAs> | |
decltype(auto) | columns (const Matrix< MT, SO > &matrix, T *indices, size_t n, RCAs... args) |
Creating a view on a selection of columns of the given constant matrix. More... | |
template<typename MT , bool SO, typename T , typename... RCAs> | |
decltype(auto) | columns (Matrix< MT, SO > &&matrix, T *indices, size_t n, RCAs... args) |
Creating a view on a selection of columns of the given temporary matrix. More... | |
template<typename MT , bool SO, typename P , typename... RCAs> | |
decltype(auto) | columns (Matrix< MT, SO > &matrix, P p, size_t n, RCAs... args) |
Creating a view on a selection of columns of the given matrix. More... | |
template<typename MT , bool SO, typename P , typename... RCAs> | |
decltype(auto) | columns (const Matrix< MT, SO > &matrix, P p, size_t n, RCAs... args) |
Creating a view on a selection of columns of the given constant matrix. More... | |
template<typename MT , bool SO, typename P , typename... RCAs> | |
decltype(auto) | columns (Matrix< MT, SO > &&matrix, P p, size_t n, RCAs... args) |
Creating a view on a selection of columns of the given temporary matrix. More... | |
template<typename MT , size_t... Is, typename... RCAs> | |
decltype(auto) | columns (MT &&matrix, index_sequence< Is... > indices, RCAs... args) |
Creating a view on a selection of columns of the given matrix. More... | |
template<typename MT , typename T , typename... RCAs> | |
decltype(auto) | columns (MT &&matrix, initializer_list< T > indices, RCAs... args) |
Creating a view on a selection of columns of the given matrix. More... | |
template<typename MT , typename T , size_t N, typename... RCAs> | |
decltype(auto) | columns (MT &&matrix, const std::array< T, N > &indices, RCAs... args) |
Creating a view on a selection of columns of the given matrix. More... | |
template<typename MT , typename T , typename... RCAs> | |
decltype(auto) | columns (MT &&matrix, const std::vector< T > &indices, RCAs... args) |
Creating a view on a selection of columns of the given matrix. More... | |
template<size_t I, size_t... Is, typename VT , bool TF, typename... REAs> | |
decltype(auto) | elements (Vector< VT, TF > &vector, REAs... args) |
Creating a view on a selection of elements of the given vector. More... | |
template<size_t I, size_t... Is, typename VT , bool TF, typename... REAs> | |
decltype(auto) | elements (const Vector< VT, TF > &vector, REAs... args) |
Creating a view on a selection of elements of the given constant vector. More... | |
template<size_t I, size_t... Is, typename VT , bool TF, typename... REAs> | |
decltype(auto) | elements (Vector< VT, TF > &&vector, REAs... args) |
Creating a view on a selection of elements of the given temporary vector. More... | |
template<typename VT , bool TF, typename T , typename... REAs> | |
decltype(auto) | elements (Vector< VT, TF > &vector, T *indices, size_t n, REAs... args) |
Creating a view on a selection of elements of the given vector. More... | |
template<typename VT , bool TF, typename T , typename... REAs> | |
decltype(auto) | elements (const Vector< VT, TF > &vector, T *indices, size_t n, REAs... args) |
Creating a view on a selection of elements of the given constant vector. More... | |
template<typename VT , bool TF, typename T , typename... REAs> | |
decltype(auto) | elements (Vector< VT, TF > &&vector, T *indices, size_t n, REAs... args) |
Creating a view on a selection of elements of the given temporary vector. More... | |
template<typename VT , bool TF, typename P , typename... REAs> | |
decltype(auto) | elements (Vector< VT, TF > &vector, P p, size_t n, REAs... args) |
Creating a view on a selection of elements of the given vector. More... | |
template<typename VT , bool TF, typename P , typename... REAs> | |
decltype(auto) | elements (const Vector< VT, TF > &vector, P p, size_t n, REAs... args) |
Creating a view on a selection of elements of the given constant vector. More... | |
template<typename VT , bool TF, typename P , typename... REAs> | |
decltype(auto) | elements (Vector< VT, TF > &&vector, P p, size_t n, REAs... args) |
Creating a view on a selection of elements of the given temporary vector. More... | |
template<typename VT , typename T , typename... REAs> | |
decltype(auto) | elements (VT &&vector, initializer_list< T > indices, REAs... args) |
Creating a view on a selection of elements of the given vector. More... | |
template<typename VT , typename T , size_t N, typename... REAs> | |
decltype(auto) | elements (VT &&vector, const std::array< T, N > &indices, REAs... args) |
Creating a view on a selection of elements of the given vector. More... | |
template<typename VT , typename T , typename... REAs> | |
decltype(auto) | elements (VT &&vector, const std::vector< T > &indices, REAs... args) |
Creating a view on a selection of elements of the given vector. More... | |
template<typename VT , typename T , size_t N, typename... REAs> | |
decltype(auto) | elements (VT &&vector, const SmallArray< T, N > &indices, REAs... args) |
Creating a view on a selection of elements of the given vector. More... | |
template<size_t I, size_t N, typename VT , bool TF, typename... RSAs> | |
decltype(auto) | subvector (Vector< VT, TF > &vector, RSAs... args) |
Creating a view on a specific subvector of the given vector. More... | |
template<size_t I, size_t N, typename VT , bool TF, typename... RSAs> | |
decltype(auto) | subvector (const Vector< VT, TF > &vector, RSAs... args) |
Creating a view on a specific subvector of the given constant vector. More... | |
template<size_t I, size_t N, typename VT , bool TF, typename... RSAs> | |
decltype(auto) | subvector (Vector< VT, TF > &&vector, RSAs... args) |
Creating a view on a specific subvector of the given temporary vector. More... | |
template<AlignmentFlag AF, size_t I, size_t N, typename VT , bool TF, typename... RSAs> | |
decltype(auto) | subvector (Vector< VT, TF > &vector, RSAs... args) |
Creating a view on a specific subvector of the given vector. More... | |
template<AlignmentFlag AF, size_t I, size_t N, typename VT , bool TF, typename... RSAs> | |
decltype(auto) | subvector (const Vector< VT, TF > &vector, RSAs... args) |
Creating a view on a specific subvector of the given constant vector. More... | |
template<AlignmentFlag AF, size_t I, size_t N, typename VT , bool TF, typename... RSAs> | |
decltype(auto) | subvector (Vector< VT, TF > &&vector, RSAs... args) |
Creating a view on a specific subvector of the given temporary vector. More... | |
template<typename VT , bool TF, typename... RSAs> | |
decltype(auto) | subvector (Vector< VT, TF > &vector, size_t index, size_t size, RSAs... args) |
Creating a view on a specific subvector of the given vector. More... | |
template<typename VT , bool TF, typename... RSAs> | |
decltype(auto) | subvector (const Vector< VT, TF > &vector, size_t index, size_t size, RSAs... args) |
Creating a view on a specific subvector of the given constant vector. More... | |
template<typename VT , bool TF, typename... RSAs> | |
decltype(auto) | subvector (Vector< VT, TF > &&vector, size_t index, size_t size, RSAs... args) |
Creating a view on a specific subvector of the given temporary vector. More... | |
template<AlignmentFlag AF, typename VT , bool TF, typename... RSAs> | |
decltype(auto) | subvector (Vector< VT, TF > &vector, size_t index, size_t size, RSAs... args) |
Creating a view on a specific subvector of the given vector. More... | |
template<AlignmentFlag AF, typename VT , bool TF, typename... RSAs> | |
decltype(auto) | subvector (const Vector< VT, TF > &vector, size_t index, size_t size, RSAs... args) |
Creating a view on a specific subvector of the given constant vector. More... | |
template<AlignmentFlag AF, typename VT , bool TF, typename... RSAs> | |
decltype(auto) | subvector (Vector< VT, TF > &&vector, size_t index, size_t size, RSAs... args) |
Creating a view on a specific subvector of the given temporary vector. More... | |
template<size_t I, size_t J, size_t M, size_t N, typename MT , bool SO, typename... RSAs> | |
decltype(auto) | submatrix (Matrix< MT, SO > &matrix, RSAs... args) |
Creating a view on a specific submatrix of the given matrix. More... | |
template<size_t I, size_t J, size_t M, size_t N, typename MT , bool SO, typename... RSAs> | |
decltype(auto) | submatrix (const Matrix< MT, SO > &matrix, RSAs... args) |
Creating a view on a specific submatrix of the given constant matrix. More... | |
template<size_t I, size_t J, size_t M, size_t N, typename MT , bool SO, typename... RSAs> | |
decltype(auto) | submatrix (Matrix< MT, SO > &&matrix, RSAs... args) |
Creating a view on a specific submatrix of the given temporary matrix. More... | |
template<AlignmentFlag AF, size_t I, size_t J, size_t M, size_t N, typename MT , bool SO, typename... RSAs> | |
decltype(auto) | submatrix (Matrix< MT, SO > &matrix, RSAs... args) |
Creating a view on a specific submatrix of the given matrix. More... | |
template<AlignmentFlag AF, size_t I, size_t J, size_t M, size_t N, typename MT , bool SO, typename... RSAs> | |
decltype(auto) | submatrix (const Matrix< MT, SO > &matrix, RSAs... args) |
Creating a view on a specific submatrix of the given constant matrix. More... | |
template<AlignmentFlag AF, size_t I, size_t J, size_t M, size_t N, typename MT , bool SO, typename... RSAs> | |
decltype(auto) | submatrix (Matrix< MT, SO > &&matrix, RSAs... args) |
Creating a view on a specific submatrix of the given temporary matrix. More... | |
template<typename MT , bool SO, typename... RSAs> | |
decltype(auto) | submatrix (Matrix< MT, SO > &matrix, size_t row, size_t column, size_t m, size_t n, RSAs... args) |
Creating a view on a specific submatrix of the given matrix. More... | |
template<typename MT , bool SO, typename... RSAs> | |
decltype(auto) | submatrix (const Matrix< MT, SO > &matrix, size_t row, size_t column, size_t m, size_t n, RSAs... args) |
Creating a view on a specific submatrix of the given constant matrix. More... | |
template<typename MT , bool SO, typename... RSAs> | |
decltype(auto) | submatrix (Matrix< MT, SO > &&matrix, size_t row, size_t column, size_t m, size_t n, RSAs... args) |
Creating a view on a specific submatrix of the given temporary matrix. More... | |
template<AlignmentFlag AF, typename MT , bool SO, typename... RSAs> | |
decltype(auto) | submatrix (Matrix< MT, SO > &matrix, size_t row, size_t column, size_t m, size_t n, RSAs... args) |
Creating a view on a specific submatrix of the given matrix. More... | |
template<AlignmentFlag AF, typename MT , bool SO, typename... RSAs> | |
decltype(auto) | submatrix (const Matrix< MT, SO > &matrix, size_t row, size_t column, size_t m, size_t n, RSAs... args) |
Creating a view on a specific submatrix of the given constant matrix. More... | |
template<AlignmentFlag AF, typename MT , bool SO, typename... RSAs> | |
decltype(auto) | submatrix (Matrix< MT, SO > &&matrix, size_t row, size_t column, size_t m, size_t n, RSAs... args) |
Creating a view on a specific submatrix of the given temporary matrix. More... | |
template<size_t I, typename MT , bool SO, typename... RRAs> | |
decltype(auto) | row (Matrix< MT, SO > &matrix, RRAs... args) |
Creating a view on a specific row of the given matrix. More... | |
template<size_t I, typename MT , bool SO, typename... RRAs> | |
decltype(auto) | row (const Matrix< MT, SO > &matrix, RRAs... args) |
Creating a view on a specific row of the given constant matrix. More... | |
template<size_t I, typename MT , bool SO, typename... RRAs> | |
decltype(auto) | row (Matrix< MT, SO > &&matrix, RRAs... args) |
Creating a view on a specific row of the given temporary matrix. More... | |
template<typename MT , bool SO, typename... RRAs> | |
decltype(auto) | row (Matrix< MT, SO > &matrix, size_t index, RRAs... args) |
Creating a view on a specific row of the given matrix. More... | |
template<typename MT , bool SO, typename... RRAs> | |
decltype(auto) | row (const Matrix< MT, SO > &matrix, size_t index, RRAs... args) |
Creating a view on a specific row of the given constant matrix. More... | |
template<typename MT , bool SO, typename... RRAs> | |
decltype(auto) | row (Matrix< MT, SO > &&matrix, size_t index, RRAs... args) |
Creating a view on a specific row of the given temporary matrix. More... | |
template<size_t I, size_t... Is, typename MT , bool SO, typename... RRAs> | |
decltype(auto) | rows (Matrix< MT, SO > &matrix, RRAs... args) |
Creating a view on a selection of rows of the given matrix. More... | |
template<size_t I, size_t... Is, typename MT , bool SO, typename... RRAs> | |
decltype(auto) | rows (const Matrix< MT, SO > &matrix, RRAs... args) |
Creating a view on a selection of rows of the given constant matrix. More... | |
template<size_t I, size_t... Is, typename MT , bool SO, typename... RRAs> | |
decltype(auto) | rows (Matrix< MT, SO > &&matrix, RRAs... args) |
Creating a view on a selection of rows of the given temporary matrix. More... | |
template<typename MT , bool SO, typename T , typename... RRAs> | |
decltype(auto) | rows (Matrix< MT, SO > &matrix, T *indices, size_t n, RRAs... args) |
Creating a view on a selection of rows of the given matrix. More... | |
template<typename MT , bool SO, typename T , typename... RRAs> | |
decltype(auto) | rows (const Matrix< MT, SO > &matrix, T *indices, size_t n, RRAs... args) |
Creating a view on a selection of rows of the given constant matrix. More... | |
template<typename MT , bool SO, typename T , typename... RRAs> | |
decltype(auto) | rows (Matrix< MT, SO > &&matrix, T *indices, size_t n, RRAs... args) |
Creating a view on a selection of rows of the given temporary matrix. More... | |
template<typename MT , bool SO, typename P , typename... RRAs> | |
decltype(auto) | rows (Matrix< MT, SO > &matrix, P p, size_t n, RRAs... args) |
Creating a view on a selection of rows of the given matrix. More... | |
template<typename MT , bool SO, typename P , typename... RRAs> | |
decltype(auto) | rows (const Matrix< MT, SO > &matrix, P p, size_t n, RRAs... args) |
Creating a view on a selection of rows of the given constant matrix. More... | |
template<typename MT , bool SO, typename P , typename... RRAs> | |
decltype(auto) | rows (Matrix< MT, SO > &&matrix, P p, size_t n, RRAs... args) |
Creating a view on a selection of rows of the given temporary matrix. More... | |
template<typename MT , size_t... Is, typename... RRAs> | |
decltype(auto) | rows (MT &&matrix, index_sequence< Is... > indices, RRAs... args) |
Creating a view on a selection of rows of the given matrix. More... | |
template<typename MT , typename T , typename... RRAs> | |
decltype(auto) | rows (MT &&matrix, initializer_list< T > indices, RRAs... args) |
Creating a view on a selection of rows of the given matrix. More... | |
template<typename MT , typename T , size_t N, typename... RRAs> | |
decltype(auto) | rows (MT &&matrix, const std::array< T, N > &indices, RRAs... args) |
Creating a view on a selection of rows of the given matrix. More... | |
template<typename MT , typename T , typename... RRAs> | |
decltype(auto) | rows (MT &&matrix, const std::vector< T > &indices, RRAs... args) |
Creating a view on a selection of rows of the given matrix. More... | |
template<typename MT , typename T , size_t N, typename... RRAs> | |
decltype(auto) | rows (MT &&matrix, const SmallArray< T, N > &indices, RRAs... args) |
Creating a view on a selection of rows of the given matrix. More... | |
template<typename ForwardIt > | |
void | destroy (ForwardIt first, ForwardIt last) |
Destroys the given range of objects . More... | |
template<typename T > | |
void | destroy_at (T *p) noexcept |
Destroys the object at the given address. More... | |
template<typename T1 , typename T2 , typename = EnableIf_t< ( IsSigned_v<T1> && IsSigned_v<T2> ) || ( IsUnsigned_v<T1> && IsUnsigned_v<T2> ) >> | |
BLAZE_ALWAYS_INLINE constexpr auto | max (const T1 &a, const T2 &b) noexcept |
Maximum function for two values of builtin data type. More... | |
template<typename T1 , typename T2 , typename T3 > | |
BLAZE_ALWAYS_INLINEdecltype(auto) constexpr | max (const T1 &a, const T2 &b, const T3 &c) noexcept |
Maximum function for three values/objects. More... | |
template<typename T1 , typename T2 , typename T3 , typename... Ts> | |
BLAZE_ALWAYS_INLINEdecltype(auto) constexpr | max (const T1 &a, const T2 &b, const T3 &c, const Ts &... args) noexcept |
Maximum function for at least four values/objects. More... | |
template<typename T1 , typename T2 , typename = EnableIf_t< ( IsSigned_v<T1> && IsSigned_v<T2> ) || ( IsUnsigned_v<T1> && IsUnsigned_v<T2> ) >> | |
BLAZE_ALWAYS_INLINE constexpr auto | min (const T1 &a, const T2 &b) noexcept |
Minimum function for two values of builtin data type. More... | |
template<typename T1 , typename T2 , typename T3 > | |
BLAZE_ALWAYS_INLINEdecltype(auto) constexpr | min (const T1 &a, const T2 &b, const T3 &c) noexcept |
Minimum function for three values/objects. More... | |
template<typename T1 , typename T2 , typename T3 , typename... Ts> | |
BLAZE_ALWAYS_INLINEdecltype(auto) constexpr | min (const T1 &a, const T2 &b, const T3 &c, const Ts &... args) noexcept |
Minimum function for at least four values/objects. More... | |
template<typename InputIterator , typename OutputIterator > | |
OutputIterator | transfer (InputIterator first, InputIterator last, OutputIterator dest) |
Transfers the elements from the given source range to the destination range. More... | |
template<class ForwardIt > | |
void | uninitialized_default_construct (ForwardIt first, ForwardIt last) |
Default constructs elements in the given range. More... | |
template<typename InputIt , typename ForwardIt > | |
ForwardIt | uninitialized_move (InputIt first, InputIt last, ForwardIt dest) |
Move the elements from the given source range to the uninitialized destination range. More... | |
template<class ForwardIt > | |
void | uninitialized_value_construct (ForwardIt first, ForwardIt last) |
Value constructs elements in the given range. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE bool | checkAlignment (const T *address) |
Checks the alignment of the given address. More... | |
template<typename T > | |
constexpr AddConst_t< T > & | as_const (T &v) noexcept |
Adding 'const' to the given lvalue. More... | |
template<typename T > | |
void | as_const (const T &&)=delete |
Overload of the as_const() function for rvalues.This overload of the as_const() function disables its use on rvalues. This prevents potential misuse as in for instance the following example: More... | |
bool | ASSERT_MESSAGE (const char *) |
Assertion helper function.The ASSERT_MESSAGE function is a small helper function to assist in printing an informative message in case an assert fires. This function builds on the ideas of Matthew Wilson, who directly combines a C-string error message with the run time expression (Imperfect C++, ISBN: 0321228774): More... | |
template<typename T , size_t N> | |
constexpr size_t | dimensionof (T(&a)[N]) |
Static evaluation of array dimensions. More... | |
template<bool B> | |
constexpr BoolConstant<!B > | operator! (BoolConstant< B >) noexcept |
Logical NOT of a boolean constant. More... | |
template<bool B1, bool B2> | |
constexpr BoolConstant< B1 &&B2 > | operator && (BoolConstant< B1 >, BoolConstant< B2 >) noexcept |
Logical AND of two boolean constants. More... | |
template<bool B1, bool B2> | |
constexpr BoolConstant< B1||B2 > | operator|| (BoolConstant< B1 >, BoolConstant< B2 >) noexcept |
Logical OR of two boolean constants. More... | |
template<typename... Args> | |
constexpr void | MAYBE_UNUSED (const Args &...) |
Suppression of unused parameter warnings. More... | |
template<typename T > | |
EnableIf_t< IsBuiltin_v< T >, T * > | allocate (size_t size) |
Aligned array allocation for built-in data types. More... | |
template<typename T > | |
DisableIf_t< IsBuiltin_v< T >, T * > | allocate (size_t size) |
Aligned array allocation for user-specific class types. More... | |
template<typename T > | |
EnableIf_t< IsBuiltin_v< T > > | deallocate (T *address) noexcept |
Deallocation of memory for built-in data types. More... | |
template<typename T > | |
DisableIf_t< IsBuiltin_v< T > > | deallocate (T *address) |
Deallocation of memory for user-specific class types. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE size_t | misalignment (const T *address) |
Computes the misalignment of the given address. More... | |
NegativeAccuracy operators | |
template<typename A , typename T > | |
constexpr bool | 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 | 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 | 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 | 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 | 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 | 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 | 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 | 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 | operator== (const Accuracy &, const T &rhs) |
Equality comparison between an Accuracy object and a floating point value. More... | |
template<typename T > | |
constexpr bool | operator== (const T &lhs, const Accuracy &) |
Equality comparison between a floating point value and an Accuracy object. More... | |
template<typename T > | |
constexpr bool | operator!= (const Accuracy &, const T &rhs) |
Inequality comparison between an Accuracy object and a floating point value. More... | |
template<typename T > | |
constexpr bool | operator!= (const T &lhs, const Accuracy &) |
Inequality comparison between a floating point value and an Accuracy object. More... | |
template<typename T > | |
constexpr bool | operator< (const Accuracy &, const T &rhs) |
Less-than comparison between an Accuracy object and a floating point value. More... | |
template<typename T > | |
constexpr bool | operator< (const T &lhs, const Accuracy &) |
Less-than comparison between a floating point value and an Accuracy object. More... | |
template<typename T > | |
constexpr bool | operator> (const Accuracy &, const T &rhs) |
Greater-than comparison between an Accuracy object and a floating point value. More... | |
template<typename T > | |
constexpr bool | operator> (const T &lhs, const Accuracy &) |
Greater-than comparison between a floating point value and an Accuracy object. More... | |
template<typename T > | |
constexpr bool | 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 | 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 | 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 | operator>= (const T &lhs, const Accuracy &) |
Less-or-equal-than comparison between a floating point value and an Accuracy object. More... | |
DiagonalProxy global functions | |
template<typename MT > | |
void | reset (const DiagonalProxy< MT > &proxy) |
Resetting the represented element to the default initial values. More... | |
template<typename MT > | |
void | clear (const DiagonalProxy< MT > &proxy) |
Clearing the represented element. More... | |
template<bool RF, typename MT > | |
bool | isDefault (const DiagonalProxy< MT > &proxy) |
Returns whether the represented element is in default state. More... | |
template<bool RF, typename MT > | |
bool | isReal (const DiagonalProxy< MT > &proxy) |
Returns whether the matrix element represents a real number. More... | |
template<bool RF, typename MT > | |
bool | isZero (const DiagonalProxy< MT > &proxy) |
Returns whether the represented element is 0. More... | |
template<bool RF, typename MT > | |
bool | isOne (const DiagonalProxy< MT > &proxy) |
Returns whether the represented element is 1. More... | |
template<typename MT > | |
bool | isnan (const DiagonalProxy< MT > &proxy) |
Returns whether the represented element is not a number. More... | |
DiagonalMatrix operators | |
template<typename MT , bool SO, bool DF> | |
void | reset (DiagonalMatrix< MT, SO, DF > &m) |
Resetting the given diagonal matrix. More... | |
template<typename MT , bool SO, bool DF> | |
void | reset (DiagonalMatrix< MT, SO, DF > &m, size_t i) |
Resetting the specified row/column of the given diagonal matrix. More... | |
template<typename MT , bool SO, bool DF> | |
void | clear (DiagonalMatrix< MT, SO, DF > &m) |
Clearing the given diagonal matrix. More... | |
template<bool RF, typename MT , bool SO, bool DF> | |
bool | isDefault (const DiagonalMatrix< MT, SO, DF > &m) |
Returns whether the given diagonal matrix is in default state. More... | |
template<typename MT , bool SO, bool DF> | |
bool | isIntact (const DiagonalMatrix< MT, SO, DF > &m) |
Returns whether the invariants of the given diagonal matrix are intact. More... | |
template<typename MT , bool SO, bool DF> | |
void | swap (DiagonalMatrix< MT, SO, DF > &a, DiagonalMatrix< MT, SO, DF > &b) noexcept |
Swapping the contents of two matrices. More... | |
HermitianProxy global functions | |
template<typename MT > | |
void | reset (const HermitianProxy< MT > &proxy) |
Resetting the represented element to the default initial values. More... | |
template<typename MT > | |
void | clear (const HermitianProxy< MT > &proxy) |
Clearing the represented element. More... | |
template<typename MT > | |
void | invert (const HermitianProxy< MT > &proxy) |
In-place inversion of the represented element. More... | |
template<bool RF, typename MT > | |
bool | isDefault (const HermitianProxy< MT > &proxy) |
Returns whether the represented element is in default state. More... | |
template<bool RF, typename MT > | |
bool | isReal (const HermitianProxy< MT > &proxy) |
Returns whether the matrix element represents a real number. More... | |
template<bool RF, typename MT > | |
bool | isZero (const HermitianProxy< MT > &proxy) |
Returns whether the represented element is 0. More... | |
template<bool RF, typename MT > | |
bool | isOne (const HermitianProxy< MT > &proxy) |
Returns whether the represented element is 1. More... | |
template<typename MT > | |
bool | isnan (const HermitianProxy< MT > &proxy) |
Returns whether the represented element is not a number. More... | |
HermitianValue global functions | |
template<typename MT > | |
void | reset (const HermitianValue< MT > &value) |
Resetting the Hermitian value to the default initial values. More... | |
template<typename MT > | |
void | clear (const HermitianValue< MT > &value) |
Clearing the Hermitian value. More... | |
template<typename MT > | |
void | invert (const HermitianValue< MT > &value) |
In-place inversion of the Hermitian value. More... | |
template<bool RF, typename MT > | |
bool | isDefault (const HermitianValue< MT > &value) |
Returns whether the Hermitian value is in default state. More... | |
template<bool RF, typename MT > | |
bool | isReal (const HermitianValue< MT > &value) |
Returns whether the Hermitian value represents a real number. More... | |
template<bool RF, typename MT > | |
bool | isZero (const HermitianValue< MT > &value) |
Returns whether the Hermitian value is 0. More... | |
template<bool RF, typename MT > | |
bool | isOne (const HermitianValue< MT > &value) |
Returns whether the Hermitian value is 1. More... | |
template<typename MT > | |
bool | isnan (const HermitianValue< MT > &value) |
Returns whether the Hermitian value is not a number. More... | |
HermitianMatrix operators | |
template<typename MT , bool SO, bool DF> | |
void | reset (HermitianMatrix< MT, SO, DF > &m) |
Resetting the given Hermitian matrix. More... | |
template<typename MT , bool SO, bool DF> | |
void | reset (HermitianMatrix< MT, SO, DF > &m, size_t i) |
Resetting the specified row/column of the given Hermitian matrix. More... | |
template<typename MT , bool SO, bool DF> | |
void | clear (HermitianMatrix< MT, SO, DF > &m) |
Clearing the given Hermitian matrix. More... | |
template<bool RF, typename MT , bool SO, bool DF> | |
bool | isDefault (const HermitianMatrix< MT, SO, DF > &m) |
Returns whether the given Hermitian matrix is in default state. More... | |
template<typename MT , bool SO, bool DF> | |
bool | isIntact (const HermitianMatrix< MT, SO, DF > &m) |
Returns whether the invariants of the given Hermitian matrix are intact. More... | |
template<typename MT , bool SO, bool DF> | |
void | swap (HermitianMatrix< MT, SO, DF > &a, HermitianMatrix< MT, SO, DF > &b) noexcept |
Swapping the contents of two matrices. More... | |
LowerProxy global functions | |
template<typename MT > | |
void | reset (const LowerProxy< MT > &proxy) |
Resetting the represented element to the default initial values. More... | |
template<typename MT > | |
void | clear (const LowerProxy< MT > &proxy) |
Clearing the represented element. More... | |
template<bool RF, typename MT > | |
bool | isDefault (const LowerProxy< MT > &proxy) |
Returns whether the represented element is in default state. More... | |
template<bool RF, typename MT > | |
bool | isReal (const LowerProxy< MT > &proxy) |
Returns whether the matrix element represents a real number. More... | |
template<bool RF, typename MT > | |
bool | isZero (const LowerProxy< MT > &proxy) |
Returns whether the represented element is 0. More... | |
template<bool RF, typename MT > | |
bool | isOne (const LowerProxy< MT > &proxy) |
Returns whether the represented element is 1. More... | |
template<typename MT > | |
bool | isnan (const LowerProxy< MT > &proxy) |
Returns whether the represented element is not a number. More... | |
LowerMatrix operators | |
template<typename MT , bool SO, bool DF> | |
void | reset (LowerMatrix< MT, SO, DF > &m) |
Resetting the given lower matrix. More... | |
template<typename MT , bool SO, bool DF> | |
void | reset (LowerMatrix< MT, SO, DF > &m, size_t i) |
Resetting the specified row/column of the given lower matrix. More... | |
template<typename MT , bool SO, bool DF> | |
void | clear (LowerMatrix< MT, SO, DF > &m) |
Clearing the given lower matrix. More... | |
template<bool RF, typename MT , bool SO, bool DF> | |
bool | isDefault (const LowerMatrix< MT, SO, DF > &m) |
Returns whether the given lower matrix is in default state. More... | |
template<typename MT , bool SO, bool DF> | |
bool | isIntact (const LowerMatrix< MT, SO, DF > &m) |
Returns whether the invariants of the given lower matrix are intact. More... | |
template<typename MT , bool SO, bool DF> | |
void | swap (LowerMatrix< MT, SO, DF > &a, LowerMatrix< MT, SO, DF > &b) noexcept |
Swapping the contents of two matrices. More... | |
StrictlyLowerProxy global functions | |
template<typename MT > | |
void | reset (const StrictlyLowerProxy< MT > &proxy) |
Resetting the represented element to the default initial values. More... | |
template<typename MT > | |
void | clear (const StrictlyLowerProxy< MT > &proxy) |
Clearing the represented element. More... | |
template<bool RF, typename MT > | |
bool | isDefault (const StrictlyLowerProxy< MT > &proxy) |
Returns whether the represented element is in default state. More... | |
template<bool RF, typename MT > | |
bool | isReal (const StrictlyLowerProxy< MT > &proxy) |
Returns whether the matrix element represents a real number. More... | |
template<bool RF, typename MT > | |
bool | isZero (const StrictlyLowerProxy< MT > &proxy) |
Returns whether the represented element is 0. More... | |
template<bool RF, typename MT > | |
bool | isOne (const StrictlyLowerProxy< MT > &proxy) |
Returns whether the represented element is 1. More... | |
template<typename MT > | |
bool | isnan (const StrictlyLowerProxy< MT > &proxy) |
Returns whether the represented element is not a number. More... | |
StrictlyLowerMatrix operators | |
template<typename MT , bool SO, bool DF> | |
void | reset (StrictlyLowerMatrix< MT, SO, DF > &m) |
Resetting the given strictly lower matrix. More... | |
template<typename MT , bool SO, bool DF> | |
void | reset (StrictlyLowerMatrix< MT, SO, DF > &m, size_t i) |
Resetting the specified row/column of the given strictly lower matrix. More... | |
template<typename MT , bool SO, bool DF> | |
void | clear (StrictlyLowerMatrix< MT, SO, DF > &m) |
Clearing the given strictly lower matrix. More... | |
template<bool RF, typename MT , bool SO, bool DF> | |
bool | isDefault (const StrictlyLowerMatrix< MT, SO, DF > &m) |
Returns whether the given strictly lower matrix is in default state. More... | |
template<typename MT , bool SO, bool DF> | |
bool | isIntact (const StrictlyLowerMatrix< MT, SO, DF > &m) |
Returns whether the invariants of the given strictly lower matrix are intact. More... | |
template<typename MT , bool SO, bool DF> | |
void | swap (StrictlyLowerMatrix< MT, SO, DF > &a, StrictlyLowerMatrix< MT, SO, DF > &b) noexcept |
Swapping the contents of two matrices. More... | |
StrictlyUpperProxy global functions | |
template<typename MT > | |
void | reset (const StrictlyUpperProxy< MT > &proxy) |
Resetting the represented element to the default initial values. More... | |
template<typename MT > | |
void | clear (const StrictlyUpperProxy< MT > &proxy) |
Clearing the represented element. More... | |
template<bool RF, typename MT > | |
bool | isDefault (const StrictlyUpperProxy< MT > &proxy) |
Returns whether the represented element is in default state. More... | |
template<bool RF, typename MT > | |
bool | isReal (const StrictlyUpperProxy< MT > &proxy) |
Returns whether the matrix element represents a real number. More... | |
template<bool RF, typename MT > | |
bool | isZero (const StrictlyUpperProxy< MT > &proxy) |
Returns whether the represented element is 0. More... | |
template<bool RF, typename MT > | |
bool | isOne (const StrictlyUpperProxy< MT > &proxy) |
Returns whether the represented element is 1. More... | |
template<typename MT > | |
bool | isnan (const StrictlyUpperProxy< MT > &proxy) |
Returns whether the represented element is not a number. More... | |
StrictlyUpperMatrix operators | |
template<typename MT , bool SO, bool DF> | |
void | reset (StrictlyUpperMatrix< MT, SO, DF > &m) |
Resetting the given strictly upper matrix. More... | |
template<typename MT , bool SO, bool DF> | |
void | reset (StrictlyUpperMatrix< MT, SO, DF > &m, size_t i) |
Resetting the specified row/column of the given strictly upper matrix. More... | |
template<typename MT , bool SO, bool DF> | |
void | clear (StrictlyUpperMatrix< MT, SO, DF > &m) |
Clearing the given strictly upper matrix. More... | |
template<bool RF, typename MT , bool SO, bool DF> | |
bool | isDefault (const StrictlyUpperMatrix< MT, SO, DF > &m) |
Returns whether the given strictly upper matrix is in default state. More... | |
template<typename MT , bool SO, bool DF> | |
bool | isIntact (const StrictlyUpperMatrix< MT, SO, DF > &m) |
Returns whether the invariants of the given strictly upper matrix are intact. More... | |
template<typename MT , bool SO, bool DF> | |
void | swap (StrictlyUpperMatrix< MT, SO, DF > &a, StrictlyUpperMatrix< MT, SO, DF > &b) noexcept |
Swapping the contents of two matrices. More... | |
NonNumericProxy global functions | |
template<typename MT > | |
void | reset (const NonNumericProxy< MT > &proxy) |
Resetting the represented element to the default initial values. More... | |
template<typename MT > | |
void | clear (const NonNumericProxy< MT > &proxy) |
Clearing the represented element. More... | |
template<bool RF, typename MT > | |
bool | isDefault (const NonNumericProxy< MT > &proxy) |
Returns whether the represented element is in default state. More... | |
template<bool RF, typename MT > | |
bool | isReal (const NonNumericProxy< MT > &proxy) |
Returns whether the matrix element represents a real number. More... | |
template<bool RF, typename MT > | |
bool | isZero (const NonNumericProxy< MT > &proxy) |
Returns whether the represented element is 0. More... | |
template<bool RF, typename MT > | |
bool | isOne (const NonNumericProxy< MT > &proxy) |
Returns whether the represented element is 1. More... | |
template<typename MT > | |
bool | isnan (const NonNumericProxy< MT > &proxy) |
Returns whether the represented element is not a number. More... | |
NumericProxy global functions | |
template<typename MT > | |
void | reset (const NumericProxy< MT > &proxy) |
Resetting the represented element to the default initial values. More... | |
template<typename MT > | |
void | clear (const NumericProxy< MT > &proxy) |
Clearing the represented element. More... | |
template<typename MT > | |
void | invert (const NumericProxy< MT > &proxy) |
In-place inversion of the represented element. More... | |
template<bool RF, typename MT > | |
bool | isDefault (const NumericProxy< MT > &proxy) |
Returns whether the represented element is in default state. More... | |
template<bool RF, typename MT > | |
bool | isReal (const NumericProxy< MT > &proxy) |
Returns whether the matrix element represents a real number. More... | |
template<bool RF, typename MT > | |
bool | isZero (const NumericProxy< MT > &proxy) |
Returns whether the represented element is 0. More... | |
template<bool RF, typename MT > | |
bool | isOne (const NumericProxy< MT > &proxy) |
Returns whether the represented element is 1. More... | |
template<typename MT > | |
bool | isnan (const NumericProxy< MT > &proxy) |
Returns whether the represented element is not a number. More... | |
SharedValue operators | |
template<typename T1 , typename T2 > | |
bool | operator== (const SharedValue< T1 > &lhs, const SharedValue< T2 > &rhs) |
Equality comparison between two SharedValue objects. More... | |
template<typename T1 , typename T2 > | |
bool | operator!= (const SharedValue< T1 > &lhs, const SharedValue< T2 > &rhs) |
Inequality comparison between two SharedValue objects. More... | |
SharedValue global functions | |
template<bool RF, typename Type > | |
bool | isDefault (const SharedValue< Type > &value) |
Returns whether the shared value is in default state. More... | |
template<bool RF, typename T1 , typename T2 > | |
bool | equal (const SharedValue< T1 > &a, const SharedValue< T2 > &b) |
Equality check for a two shared values. More... | |
SymmetricValue global functions | |
template<typename MT > | |
void | reset (const SymmetricValue< MT > &value) |
Resetting the symmetric value to the default initial values. More... | |
template<typename MT > | |
void | clear (const SymmetricValue< MT > &value) |
Clearing the symmetric value. More... | |
template<typename MT > | |
void | invert (const SymmetricValue< MT > &value) |
In-place inversion of the symmetric value. More... | |
template<bool RF, typename MT > | |
bool | isDefault (const SymmetricValue< MT > &value) |
Returns whether the symmetric value is in default state. More... | |
template<bool RF, typename MT > | |
bool | isReal (const SymmetricValue< MT > &value) |
Returns whether the symmetric value represents a real number. More... | |
template<bool RF, typename MT > | |
bool | isZero (const SymmetricValue< MT > &value) |
Returns whether the symmetric value is 0. More... | |
template<bool RF, typename MT > | |
bool | isOne (const SymmetricValue< MT > &value) |
Returns whether the symmetric value is 1. More... | |
template<typename MT > | |
bool | isnan (const SymmetricValue< MT > &value) |
Returns whether the symmetric value is not a number. More... | |
SymmetricMatrix operators | |
template<typename MT , bool SO, bool DF, bool NF> | |
void | reset (SymmetricMatrix< MT, SO, DF, NF > &m) |
Resetting the given symmetric matrix. More... | |
template<typename MT , bool SO, bool DF, bool NF> | |
void | reset (SymmetricMatrix< MT, SO, DF, NF > &m, size_t i) |
Resetting the specified row/column of the given symmetric matrix. More... | |
template<typename MT , bool SO, bool DF, bool NF> | |
void | clear (SymmetricMatrix< MT, SO, DF, NF > &m) |
Clearing the given symmetric matrix. More... | |
template<bool RF, typename MT , bool SO, bool DF, bool NF> | |
bool | isDefault (const SymmetricMatrix< MT, SO, DF, NF > &m) |
Returns whether the given symmetric matrix is in default state. More... | |
template<typename MT , bool SO, bool DF, bool NF> | |
bool | isIntact (const SymmetricMatrix< MT, SO, DF, NF > &m) |
Returns whether the invariants of the given symmetric matrix are intact. More... | |
template<typename MT , bool SO, bool DF, bool NF> | |
void | swap (SymmetricMatrix< MT, SO, DF, NF > &a, SymmetricMatrix< MT, SO, DF, NF > &b) noexcept |
Swapping the contents of two matrices. More... | |
UniLowerProxy global functions | |
template<typename MT > | |
void | reset (const UniLowerProxy< MT > &proxy) |
Resetting the represented element to the default initial values. More... | |
template<typename MT > | |
void | clear (const UniLowerProxy< MT > &proxy) |
Clearing the represented element. More... | |
template<typename MT > | |
void | invert (const UniLowerProxy< MT > &proxy) |
In-place inversion of the represented element. More... | |
template<bool RF, typename MT > | |
bool | isDefault (const UniLowerProxy< MT > &proxy) |
Returns whether the represented element is in default state. More... | |
template<bool RF, typename MT > | |
bool | isReal (const UniLowerProxy< MT > &proxy) |
Returns whether the matrix element represents a real number. More... | |
template<bool RF, typename MT > | |
bool | isZero (const UniLowerProxy< MT > &proxy) |
Returns whether the represented element is 0. More... | |
template<bool RF, typename MT > | |
bool | isOne (const UniLowerProxy< MT > &proxy) |
Returns whether the represented element is 1. More... | |
template<typename MT > | |
bool | isnan (const UniLowerProxy< MT > &proxy) |
Returns whether the represented element is not a number. More... | |
UniLowerValue global functions | |
template<typename MT > | |
void | reset (const UniLowerValue< MT > &value) |
Resetting the unilower value to the default initial values. More... | |
template<typename MT > | |
void | clear (const UniLowerValue< MT > &value) |
Clearing the unilower value. More... | |
template<typename MT > | |
void | invert (const UniLowerValue< MT > &value) |
In-place inversion of the unilower value. More... | |
template<bool RF, typename MT > | |
bool | isDefault (const UniLowerValue< MT > &value) |
Returns whether the unilower value is in default state. More... | |
template<bool RF, typename MT > | |
bool | isReal (const UniLowerValue< MT > &value) |
Returns whether the unilower value represents a real number. More... | |
template<bool RF, typename MT > | |
bool | isZero (const UniLowerValue< MT > &value) |
Returns whether the unilower value is 0. More... | |
template<bool RF, typename MT > | |
bool | isOne (const UniLowerValue< MT > &value) |
Returns whether the unilower value is 1. More... | |
template<typename MT > | |
bool | isnan (const UniLowerValue< MT > &value) |
Returns whether the unilower value is not a number. More... | |
UniLowerMatrix operators | |
template<typename MT , bool SO, bool DF> | |
void | reset (UniLowerMatrix< MT, SO, DF > &m) |
Resetting the given unilower matrix. More... | |
template<typename MT , bool SO, bool DF> | |
void | reset (UniLowerMatrix< MT, SO, DF > &m, size_t i) |
Resetting the specified row/column of the given unilower matrix. More... | |
template<typename MT , bool SO, bool DF> | |
void | clear (UniLowerMatrix< MT, SO, DF > &m) |
Clearing the given unilower matrix. More... | |
template<bool RF, typename MT , bool SO, bool DF> | |
bool | isDefault (const UniLowerMatrix< MT, SO, DF > &m) |
Returns whether the given unilower matrix is in default state. More... | |
template<typename MT , bool SO, bool DF> | |
bool | isIntact (const UniLowerMatrix< MT, SO, DF > &m) |
Returns whether the invariants of the given unilower matrix are intact. More... | |
template<typename MT , bool SO, bool DF> | |
void | swap (UniLowerMatrix< MT, SO, DF > &a, UniLowerMatrix< MT, SO, DF > &b) noexcept |
Swapping the contents of two matrices. More... | |
UniUpperProxy global functions | |
template<typename MT > | |
void | reset (const UniUpperProxy< MT > &proxy) |
Resetting the represented element to the default initial values. More... | |
template<typename MT > | |
void | clear (const UniUpperProxy< MT > &proxy) |
Clearing the represented element. More... | |
template<typename MT > | |
void | invert (const UniUpperProxy< MT > &proxy) |
In-place inversion of the represented element. More... | |
template<bool RF, typename MT > | |
bool | isDefault (const UniUpperProxy< MT > &proxy) |
Returns whether the represented element is in default state. More... | |
template<bool RF, typename MT > | |
bool | isReal (const UniUpperProxy< MT > &proxy) |
Returns whether the matrix element represents a real number. More... | |
template<bool RF, typename MT > | |
bool | isZero (const UniUpperProxy< MT > &proxy) |
Returns whether the represented element is 0. More... | |
template<bool RF, typename MT > | |
bool | isOne (const UniUpperProxy< MT > &proxy) |
Returns whether the represented element is 1. More... | |
template<typename MT > | |
bool | isnan (const UniUpperProxy< MT > &proxy) |
Returns whether the represented element is not a number. More... | |
UniUpperValue global functions | |
template<typename MT > | |
void | reset (const UniUpperValue< MT > &value) |
Resetting the uniupper value to the default initial values. More... | |
template<typename MT > | |
void | clear (const UniUpperValue< MT > &value) |
Clearing the uniupper value. More... | |
template<typename MT > | |
void | invert (const UniUpperValue< MT > &value) |
In-place inversion of the uniupper value. More... | |
template<bool RF, typename MT > | |
bool | isDefault (const UniUpperValue< MT > &value) |
Returns whether the uniupper value is in default state. More... | |
template<bool RF, typename MT > | |
bool | isReal (const UniUpperValue< MT > &value) |
Returns whether the uniupper value represents a real number. More... | |
template<bool RF, typename MT > | |
bool | isZero (const UniUpperValue< MT > &value) |
Returns whether the uniupper value is 0. More... | |
template<bool RF, typename MT > | |
bool | isOne (const UniUpperValue< MT > &value) |
Returns whether the uniupper value is 1. More... | |
template<typename MT > | |
bool | isnan (const UniUpperValue< MT > &value) |
Returns whether the uniupper value is not a number. More... | |
UniUpperMatrix operators | |
template<typename MT , bool SO, bool DF> | |
void | reset (UniUpperMatrix< MT, SO, DF > &m) |
Resetting the given uniupper matrix. More... | |
template<typename MT , bool SO, bool DF> | |
void | reset (UniUpperMatrix< MT, SO, DF > &m, size_t i) |
Resetting the specified row/column of the given uniupper matrix. More... | |
template<typename MT , bool SO, bool DF> | |
void | clear (UniUpperMatrix< MT, SO, DF > &m) |
Clearing the given uniupper matrix. More... | |
template<bool RF, typename MT , bool SO, bool DF> | |
bool | isDefault (const UniUpperMatrix< MT, SO, DF > &m) |
Returns whether the given uniupper matrix is in default state. More... | |
template<typename MT , bool SO, bool DF> | |
bool | isIntact (const UniUpperMatrix< MT, SO, DF > &m) |
Returns whether the invariants of the given uniupper matrix are intact. More... | |
template<typename MT , bool SO, bool DF> | |
void | swap (UniUpperMatrix< MT, SO, DF > &a, UniUpperMatrix< MT, SO, DF > &b) noexcept |
Swapping the contents of two matrices. More... | |
UpperProxy global functions | |
template<typename MT > | |
void | reset (const UpperProxy< MT > &proxy) |
Resetting the represented element to the default initial values. More... | |
template<typename MT > | |
void | clear (const UpperProxy< MT > &proxy) |
Clearing the represented element. More... | |
template<bool RF, typename MT > | |
bool | isDefault (const UpperProxy< MT > &proxy) |
Returns whether the represented element is in default state. More... | |
template<bool RF, typename MT > | |
bool | isReal (const UpperProxy< MT > &proxy) |
Returns whether the matrix element represents a real number. More... | |
template<bool RF, typename MT > | |
bool | isZero (const UpperProxy< MT > &proxy) |
Returns whether the represented element is 0. More... | |
template<bool RF, typename MT > | |
bool | isOne (const UpperProxy< MT > &proxy) |
Returns whether the represented element is 1. More... | |
template<typename MT > | |
bool | isnan (const UpperProxy< MT > &proxy) |
Returns whether the represented element is not a number. More... | |
UpperMatrix operators | |
template<typename MT , bool SO, bool DF> | |
void | reset (UpperMatrix< MT, SO, DF > &m) |
Resetting the given upper matrix. More... | |
template<typename MT , bool SO, bool DF> | |
void | reset (UpperMatrix< MT, SO, DF > &m, size_t i) |
Resetting the specified row/column of the given upper matrix. More... | |
template<typename MT , bool SO, bool DF> | |
void | clear (UpperMatrix< MT, SO, DF > &m) |
Clearing the given upper matrix. More... | |
template<bool RF, typename MT , bool SO, bool DF> | |
bool | isDefault (const UpperMatrix< MT, SO, DF > &m) |
Returns whether the given upper matrix is in default state. More... | |
template<typename MT , bool SO, bool DF> | |
bool | isIntact (const UpperMatrix< MT, SO, DF > &m) |
Returns whether the invariants of the given lower matrix are intact. More... | |
template<typename MT , bool SO, bool DF> | |
void | swap (UpperMatrix< MT, SO, DF > &a, UpperMatrix< MT, SO, DF > &b) noexcept |
Swapping the contents of two matrices. More... | |
CustomMatrix operators | |
template<typename Type , bool AF, bool PF, bool SO, typename RT > | |
void | reset (CustomMatrix< Type, AF, PF, SO, RT > &m) |
Resetting the given custom matrix. More... | |
template<typename Type , bool AF, bool PF, bool SO, typename RT > | |
void | reset (CustomMatrix< Type, AF, PF, SO, RT > &m, size_t i) |
Reset the specified row/column of the given custom matrix. More... | |
template<typename Type , bool AF, bool PF, bool SO, typename RT > | |
void | clear (CustomMatrix< Type, AF, PF, SO, RT > &m) |
Clearing the given custom matrix. More... | |
template<bool RF, typename Type , bool AF, bool PF, bool SO, typename RT > | |
bool | isDefault (const CustomMatrix< Type, AF, PF, SO, RT > &m) |
Returns whether the given custom matrix is in default state. More... | |
template<typename Type , bool AF, bool PF, bool SO, typename RT > | |
bool | isIntact (const CustomMatrix< Type, AF, PF, SO, RT > &m) |
Returns whether the invariants of the given custom matrix are intact. More... | |
template<typename Type , bool AF, bool PF, bool SO, typename RT > | |
void | swap (CustomMatrix< Type, AF, PF, SO, RT > &a, CustomMatrix< Type, AF, PF, SO, RT > &b) noexcept |
Swapping the contents of two custom matrices. More... | |
CustomVector operators | |
template<typename Type , bool AF, bool PF, bool TF, typename RT > | |
void | reset (CustomVector< Type, AF, PF, TF, RT > &v) |
Resetting the given custom vector. More... | |
template<typename Type , bool AF, bool PF, bool TF, typename RT > | |
void | clear (CustomVector< Type, AF, PF, TF, RT > &v) |
Clearing the given custom vector. More... | |
template<bool RF, typename Type , bool AF, bool PF, bool TF, typename RT > | |
bool | isDefault (const CustomVector< Type, AF, PF, TF, RT > &v) |
Returns whether the given custom vector is in default state. More... | |
template<typename Type , bool AF, bool PF, bool TF, typename RT > | |
bool | isIntact (const CustomVector< Type, AF, PF, TF, RT > &v) noexcept |
Returns whether the invariants of the given custom vector are intact. More... | |
template<typename Type , bool AF, bool PF, bool TF, typename RT > | |
void | swap (CustomVector< Type, AF, PF, TF, RT > &a, CustomVector< Type, AF, PF, TF, RT > &b) noexcept |
Swapping the contents of two vectors. More... | |
DenseIterator operators | |
template<typename T1 , bool AF1, typename T2 , bool AF2> | |
constexpr bool | operator== (const DenseIterator< T1, AF1 > &lhs, const DenseIterator< T2, AF2 > &rhs) noexcept |
Equality comparison between two DenseIterator objects. More... | |
template<typename T1 , bool AF1, typename T2 , bool AF2> | |
constexpr bool | operator!= (const DenseIterator< T1, AF1 > &lhs, const DenseIterator< T2, AF2 > &rhs) noexcept |
Inequality comparison between two DenseIterator objects. More... | |
template<typename T1 , bool AF1, typename T2 , bool AF2> | |
constexpr bool | operator< (const DenseIterator< T1, AF1 > &lhs, const DenseIterator< T2, AF2 > &rhs) noexcept |
Less-than comparison between two DenseIterator objects. More... | |
template<typename T1 , bool AF1, typename T2 , bool AF2> | |
constexpr bool | operator> (const DenseIterator< T1, AF1 > &lhs, const DenseIterator< T2, AF2 > &rhs) noexcept |
Greater-than comparison between two DenseIterator objects. More... | |
template<typename T1 , bool AF1, typename T2 , bool AF2> | |
constexpr bool | operator<= (const DenseIterator< T1, AF1 > &lhs, const DenseIterator< T2, AF2 > &rhs) noexcept |
Less-or-equal-than comparison between two DenseIterator objects. More... | |
template<typename T1 , bool AF1, typename T2 , bool AF2> | |
constexpr bool | operator>= (const DenseIterator< T1, AF1 > &lhs, const DenseIterator< T2, AF2 > &rhs) noexcept |
Greater-or-equal-than comparison between two DenseIterator objects. More... | |
template<typename Type , bool AF> | |
constexpr const DenseIterator< Type, AF > | operator+ (const DenseIterator< Type, AF > &it, ptrdiff_t inc) noexcept |
Addition between a DenseIterator and an integral value. More... | |
template<typename Type , bool AF> | |
constexpr const DenseIterator< Type, AF > | operator+ (ptrdiff_t inc, const DenseIterator< Type, AF > &it) noexcept |
Addition between an integral value and a DenseIterator. More... | |
template<typename Type , bool AF> | |
constexpr const DenseIterator< Type, AF > | operator- (const DenseIterator< Type, AF > &it, ptrdiff_t dec) noexcept |
Subtraction between a DenseIterator and an integral value. More... | |
template<typename Type , bool AF> | |
constexpr ptrdiff_t | operator- (const DenseIterator< Type, AF > &lhs, const DenseIterator< Type, AF > &rhs) noexcept |
Calculating the number of elements between two DenseIterator objects. More... | |
DenseMatrix operators | |
template<typename T1 , typename T2 > | |
auto | operator== (const DenseMatrix< T1, false > &mat, T2 scalar) -> EnableIf_t< IsNumeric_v< T2 >, bool > |
Equality operator for the comparison of a row-major dense matrix and a scalar value. More... | |
template<typename T1 , typename T2 > | |
auto | operator== (const DenseMatrix< T1, true > &mat, T2 scalar) -> EnableIf_t< IsNumeric_v< T2 >, bool > |
Equality operator for the comparison of a column-major dense matrix and a scalar value. More... | |
template<typename T1 , typename T2 , bool SO> | |
auto | operator== (T1 scalar, const DenseMatrix< T2, SO > &mat) -> EnableIf_t< IsNumeric_v< T1 >, bool > |
Equality operator for the comparison of a scalar value and a dense matrix. More... | |
template<typename T1 , typename T2 , bool SO> | |
auto | operator!= (const DenseMatrix< T1, SO > &mat, T2 scalar) -> EnableIf_t< IsNumeric_v< T2 >, bool > |
Inequality operator for the comparison of a dense matrix and a scalar value. More... | |
template<typename T1 , typename T2 , bool SO> | |
auto | operator!= (T1 scalar, const DenseMatrix< T2, SO > &mat) -> EnableIf_t< IsNumeric_v< T1 >, bool > |
Inequality operator for the comparison of a scalar value and a dense matrix. More... | |
template<typename MT , bool SO, typename ST > | |
auto | operator+= (DenseMatrix< MT, SO > &mat, ST scalar) -> EnableIf_t< IsNumeric_v< ST >, MT & > |
Addition assignment operator for the addition of a dense matrix and a scalar value ( ![]() | |
template<typename MT , bool SO, typename ST > | |
auto | operator+= (DenseMatrix< MT, SO > &&mat, ST scalar) -> EnableIf_t< IsNumeric_v< ST >, MT & > |
Addition assignment operator for the addition of a temporary dense matrix and a scalar value ( ![]() | |
template<typename MT , bool SO, typename ST > | |
auto | operator-= (DenseMatrix< MT, SO > &mat, ST scalar) -> EnableIf_t< IsNumeric_v< ST >, MT & > |
Subtraction assignment operator for the subtraction of a dense matrix and a scalar value ( ![]() | |
template<typename MT , bool SO, typename ST > | |
auto | operator-= (DenseMatrix< MT, SO > &&mat, ST scalar) -> EnableIf_t< IsNumeric_v< ST >, MT & > |
Subtraction assignment operator for the subtraction of a temporary dense matrix and a scalar value ( ![]() | |
template<typename MT , bool SO, typename ST > | |
auto | operator *= (DenseMatrix< MT, SO > &mat, ST scalar) -> EnableIf_t< IsNumeric_v< ST >, MT & > |
Multiplication assignment operator for the multiplication of a dense matrix and a scalar value ( ![]() | |
template<typename MT , bool SO, typename ST > | |
auto | operator *= (DenseMatrix< MT, SO > &&mat, ST scalar) -> EnableIf_t< IsNumeric_v< ST >, MT & > |
Multiplication assignment operator for the multiplication of a temporary dense matrix and a scalar value ( ![]() | |
template<typename MT , bool SO, typename ST > | |
auto | operator/= (DenseMatrix< MT, SO > &mat, ST scalar) -> EnableIf_t< IsNumeric_v< ST >, MT & > |
Division assignment operator for the division of a dense matrix by a scalar value ( ![]() | |
template<typename MT , bool SO, typename ST > | |
auto | operator/= (DenseMatrix< MT, SO > &&mat, ST scalar) -> EnableIf_t< IsNumeric_v< ST >, MT & > |
Division assignment operator for the division of a temporary dense matrix by a scalar value ( ![]() | |
template<typename MT , bool SO> | |
MT & | operator<<= (DenseMatrix< MT, SO > &mat, int count) |
Left-shift assignment operator for the uniform left-shift of a dense matrix. More... | |
template<typename MT , bool SO> | |
MT & | operator<<= (DenseMatrix< MT, SO > &&mat, int count) |
Left-shift assignment operator for the uniform left-shift of a temporary dense matrix. More... | |
template<typename MT1 , bool SO1, typename MT2 , bool SO2> | |
MT1 & | operator<<= (DenseMatrix< MT1, SO1 > &lhs, const DenseMatrix< MT2, SO2 > &rhs) |
Left-shift assignment operator for the elementwise left-shift of a dense matrix. More... | |
template<typename MT1 , bool SO1, typename MT2 , bool SO2> | |
MT1 & | operator<<= (DenseMatrix< MT1, SO1 > &&lhs, const DenseMatrix< MT2, SO2 > &rhs) |
Left-shift assignment operator for the elementwise left-shift of a temporary dense matrix. More... | |
template<typename MT , bool SO> | |
MT & | operator>>= (DenseMatrix< MT, SO > &mat, int count) |
Right-shift assignment operator for the uniform right-shift of a dense matrix. More... | |
template<typename MT , bool SO> | |
MT & | operator>>= (DenseMatrix< MT, SO > &&mat, int count) |
Right-shift assignment operator for the uniform right-shift of a temporary dense matrix. More... | |
template<typename MT1 , bool SO1, typename MT2 , bool SO2> | |
MT1 & | operator>>= (DenseMatrix< MT1, SO1 > &lhs, const DenseMatrix< MT2, SO2 > &rhs) |
Right-shift assignment operator for the elementwise right-shift of a dense matrix. More... | |
template<typename MT1 , bool SO1, typename MT2 , bool SO2> | |
MT1 & | operator>>= (DenseMatrix< MT1, SO1 > &&lhs, const DenseMatrix< MT2, SO2 > &rhs) |
Right-shift assignment operator for the elementwise right-shift of a temporary dense. More... | |
template<typename MT , bool SO, typename ST > | |
auto | operator&= (DenseMatrix< MT, SO > &mat, ST scalar) -> EnableIf_t< IsNumeric_v< ST >, MT & > |
Bitwise AND assignment operator for the bitwise AND of a dense matrix and a scalar value. More... | |
template<typename MT , bool SO, typename ST > | |
auto | operator&= (DenseMatrix< MT, SO > &&mat, ST scalar) -> EnableIf_t< IsNumeric_v< ST >, MT & > |
Bitwise AND assignment operator for the bitwise AND of a temporary dense matrix and a scalar value. More... | |
template<typename MT1 , bool SO1, typename MT2 , bool SO2> | |
MT1 & | operator&= (DenseMatrix< MT1, SO1 > &lhs, const DenseMatrix< MT2, SO2 > &rhs) |
Bitwise AND assignment operator for the bitwise AND of a dense matrix. More... | |
template<typename MT1 , bool SO1, typename MT2 , bool SO2> | |
MT1 & | operator&= (DenseMatrix< MT1, SO1 > &&lhs, const DenseMatrix< MT2, SO2 > &rhs) |
Bitwise AND assignment operator for the bitwise AND of a temporary dense matrix. More... | |
template<typename MT , bool SO, typename ST > | |
auto | operator|= (DenseMatrix< MT, SO > &mat, ST scalar) -> EnableIf_t< IsNumeric_v< ST >, MT & > |
Bitwise OR assignment operator for the bitwise OR of a dense matrix and a scalar value. More... | |
template<typename MT , bool SO, typename ST > | |
auto | operator|= (DenseMatrix< MT, SO > &&mat, ST scalar) -> EnableIf_t< IsNumeric_v< ST >, MT & > |
Bitwise OR assignment operator for the bitwise OR of a temporary dense matrix and a scalar value. More... | |
template<typename MT1 , bool SO1, typename MT2 , bool SO2> | |
MT1 & | operator|= (DenseMatrix< MT1, SO1 > &lhs, const DenseMatrix< MT2, SO2 > &rhs) |
Bitwise OR assignment operator for the bitwise OR of a dense matrix. More... | |
template<typename MT1 , bool SO1, typename MT2 , bool SO2> | |
MT1 & | operator|= (DenseMatrix< MT1, SO1 > &&lhs, const DenseMatrix< MT2, SO2 > &rhs) |
Bitwise OR assignment operator for the bitwise OR of a temporary dense matrix. More... | |
template<typename MT , bool SO, typename ST > | |
auto | operator^= (DenseMatrix< MT, SO > &mat, ST scalar) -> EnableIf_t< IsNumeric_v< ST >, MT & > |
Bitwise XOR assignment operator for the bitwise XOR of a dense matrix and a scalar value. More... | |
template<typename MT , bool SO, typename ST > | |
auto | operator^= (DenseMatrix< MT, SO > &&mat, ST scalar) -> EnableIf_t< IsNumeric_v< ST >, MT & > |
Bitwise XOR assignment operator for the bitwise XOR of a temporary dense matrix and a scalar value. More... | |
template<typename MT1 , bool SO1, typename MT2 , bool SO2> | |
MT1 & | operator^= (DenseMatrix< MT1, SO1 > &lhs, const DenseMatrix< MT2, SO2 > &rhs) |
Bitwise XOR assignment operator for the bitwise XOR of a dense matrix. More... | |
template<typename MT1 , bool SO1, typename MT2 , bool SO2> | |
MT1 & | operator^= (DenseMatrix< MT1, SO1 > &&lhs, const DenseMatrix< MT2, SO2 > &rhs) |
Bitwise XOR assignment operator for the bitwise XOR of a temporary dense matrix. More... | |
DenseMatrix functions | |
template<typename MT , bool SO> | |
bool | isnan (const DenseMatrix< MT, SO > &dm) |
Checks the given dense matrix for not-a-number elements. More... | |
template<bool RF, typename MT , bool SO> | |
bool | isSymmetric (const DenseMatrix< MT, SO > &dm) |
Checks if the given dense matrix is symmetric. More... | |
template<bool RF, typename MT , bool SO> | |
bool | isHermitian (const DenseMatrix< MT, SO > &dm) |
Checks if the given dense matrix is Hermitian. More... | |
template<bool RF, typename MT , bool SO> | |
bool | isUniform (const DenseMatrix< MT, SO > &dm) |
Checks if the given dense matrix is a uniform matrix. More... | |
template<bool RF, typename MT , bool SO> | |
bool | isZero (const DenseMatrix< MT, SO > &dm) |
Checks if the given dense matrix is a zero matrix. More... | |
template<bool RF, typename MT , bool SO> | |
bool | isLower (const DenseMatrix< MT, SO > &dm) |
Checks if the given dense matrix is a lower triangular matrix. More... | |
template<bool RF, typename MT , bool SO> | |
bool | isUniLower (const DenseMatrix< MT, SO > &dm) |
Checks if the given dense matrix is a lower unitriangular matrix. More... | |
template<bool RF, typename MT , bool SO> | |
bool | isStrictlyLower (const DenseMatrix< MT, SO > &dm) |
Checks if the given dense matrix is a strictly lower triangular matrix. More... | |
template<bool RF, typename MT , bool SO> | |
bool | isUpper (const DenseMatrix< MT, SO > &dm) |
Checks if the given dense matrix is an upper triangular matrix. More... | |
template<bool RF, typename MT , bool SO> | |
bool | isUniUpper (const DenseMatrix< MT, SO > &dm) |
Checks if the given dense matrix is an upper unitriangular matrix. More... | |
template<bool RF, typename MT , bool SO> | |
bool | isStrictlyUpper (const DenseMatrix< MT, SO > &dm) |
Checks if the given dense matrix is a strictly upper triangular matrix. More... | |
template<bool RF, typename MT , bool SO> | |
bool | isDiagonal (const DenseMatrix< MT, SO > &dm) |
Checks if the give dense matrix is diagonal. More... | |
template<bool RF, typename MT , bool SO> | |
bool | isIdentity (const DenseMatrix< MT, SO > &dm) |
Checks if the give dense matrix is an identity matrix. More... | |
DenseVector operators | |
template<typename T1 , typename T2 , bool TF> | |
auto | operator== (const DenseVector< T1, TF > &vec, T2 scalar) -> EnableIf_t< IsNumeric_v< T2 >, bool > |
Equality operator for the comparison of a dense vector and a scalar value. More... | |
template<typename T1 , typename T2 , bool TF> | |
auto | operator== (T1 scalar, const DenseVector< T2, TF > &vec) -> EnableIf_t< IsNumeric_v< T1 >, bool > |
Equality operator for the comparison of a scalar value and a dense vector. More... | |
template<typename T1 , typename T2 , bool TF> | |
auto | operator!= (const DenseVector< T1, TF > &vec, T2 scalar) -> EnableIf_t< IsNumeric_v< T2 >, bool > |
Inequality operator for the comparison of a dense vector and a scalar value. More... | |
template<typename T1 , typename T2 , bool TF> | |
auto | operator!= (T1 scalar, const DenseVector< T2, TF > &vec) -> EnableIf_t< IsNumeric_v< T1 >, bool > |
Inequality operator for the comparison of a scalar value and a dense vector. More... | |
template<typename VT , bool TF, typename ST > | |
auto | operator+= (DenseVector< VT, TF > &vec, ST scalar) -> EnableIf_t< IsNumeric_v< ST >, VT & > |
Addition assignment operator for the addition of a dense vector and a scalar value ( ![]() | |
template<typename VT , bool TF, typename ST > | |
auto | operator+= (DenseVector< VT, TF > &&vec, ST scalar) -> EnableIf_t< IsNumeric_v< ST >, VT & > |
Addition assignment operator for the addition of a temporary dense vector and a scalar value ( ![]() | |
template<typename VT , bool TF, typename ST > | |
auto | operator-= (DenseVector< VT, TF > &vec, ST scalar) -> EnableIf_t< IsNumeric_v< ST >, VT & > |
Subtraction assignment operator for the subtraction of a dense vector and a scalar value ( ![]() | |
template<typename VT , bool TF, typename ST > | |
auto | operator-= (DenseVector< VT, TF > &&vec, ST scalar) -> EnableIf_t< IsNumeric_v< ST >, VT & > |
Subtraction assignment operator for the subtraction of a temporary dense vector and a scalar value ( ![]() | |
template<typename VT , bool TF, typename ST > | |
auto | operator *= (DenseVector< VT, TF > &vec, ST scalar) -> EnableIf_t< IsNumeric_v< ST >, VT & > |
Multiplication assignment operator for the multiplication of a dense vector and a scalar value ( ![]() | |
template<typename VT , bool TF, typename ST > | |
auto | operator *= (DenseVector< VT, TF > &&vec, ST scalar) -> EnableIf_t< IsNumeric_v< ST >, VT & > |
Multiplication assignment operator for the multiplication of a temporary dense vector and a scalar value ( ![]() | |
template<typename VT , bool TF, typename ST > | |
auto | operator/= (DenseVector< VT, TF > &vec, ST scalar) -> EnableIf_t< IsNumeric_v< ST >, VT & > |
Division assignment operator for the division of a dense vector by a scalar value ( ![]() | |
template<typename VT , bool TF, typename ST > | |
auto | operator/= (DenseVector< VT, TF > &&vec, ST scalar) -> EnableIf_t< IsNumeric_v< ST >, VT & > |
Division assignment operator for the division of a temporary dense vector by a scalar value ( ![]() | |
template<typename VT , bool TF> | |
VT & | operator<<= (DenseVector< VT, TF > &vec, int count) |
Left-shift assignment operator for the uniform left-shift of a dense vector. More... | |
template<typename VT , bool TF> | |
VT & | operator<<= (DenseVector< VT, TF > &&vec, int count) |
Left-shift assignment operator for the uniform shift of a temporary dense vector. More... | |
template<typename VT1 , typename VT2 , bool TF> | |
VT1 & | operator<<= (DenseVector< VT1, TF > &lhs, const DenseVector< VT2, TF > &rhs) |
Left-shift assignment operator for the elementwise left-shift of a dense vector. More... | |
template<typename VT1 , typename VT2 , bool TF> | |
VT1 & | operator<<= (DenseVector< VT1, TF > &&lhs, const DenseVector< VT2, TF > &rhs) |
Left-shift assignment operator for the elementwise left-shift of a temporary dense vector. More... | |
template<typename VT , bool TF> | |
VT & | operator>>= (DenseVector< VT, TF > &vec, int count) |
Right-shift assignment operator for the uniform right-shift of a dense vector. More... | |
template<typename VT , bool TF> | |
VT & | operator>>= (DenseVector< VT, TF > &&vec, int count) |
Right-shift assignment operator for the uniform shift of a temporary dense vector. More... | |
template<typename VT1 , typename VT2 , bool TF> | |
VT1 & | operator>>= (DenseVector< VT1, TF > &lhs, const DenseVector< VT2, TF > &rhs) |
Right-shift assignment operator for the elementwise right-shift of a dense vector. More... | |
template<typename VT1 , typename VT2 , bool TF> | |
VT1 & | operator>>= (DenseVector< VT1, TF > &&lhs, const DenseVector< VT2, TF > &rhs) |
Right-shift assignment operator for the elementwise right-shift of a temporary dense. More... | |
template<typename VT , bool TF, typename ST > | |
auto | operator&= (DenseVector< VT, TF > &vec, ST scalar) -> EnableIf_t< IsNumeric_v< ST >, VT & > |
Bitwise AND assignment operator for the bitwise AND of a dense vector and a scalar value. More... | |
template<typename VT , bool TF, typename ST > | |
auto | operator&= (DenseVector< VT, TF > &&vec, ST scalar) -> EnableIf_t< IsNumeric_v< ST >, VT & > |
Bitwise AND assignment operator for the bitwise AND of a temporary dense vector and a scalar value. More... | |
template<typename VT1 , typename VT2 , bool TF> | |
VT1 & | operator&= (DenseVector< VT1, TF > &lhs, const DenseVector< VT2, TF > &rhs) |
Bitwise AND assignment operator for the bitwise AND of a dense vector. More... | |
template<typename VT1 , typename VT2 , bool TF> | |
VT1 & | operator&= (DenseVector< VT1, TF > &&lhs, const DenseVector< VT2, TF > &rhs) |
Bitwise AND assignment operator for the bitwise AND of a temporary dense vector. More... | |
template<typename VT , bool TF, typename ST > | |
auto | operator|= (DenseVector< VT, TF > &vec, ST scalar) -> EnableIf_t< IsNumeric_v< ST >, VT & > |
Bitwise OR assignment operator for the bitwise OR of a dense vector and a scalar value. More... | |
template<typename VT , bool TF, typename ST > | |
auto | operator|= (DenseVector< VT, TF > &&vec, ST scalar) -> EnableIf_t< IsNumeric_v< ST >, VT & > |
Bitwise OR assignment operator for the bitwise OR of a temporary dense vector and a scalar value. More... | |
template<typename VT1 , typename VT2 , bool TF> | |
VT1 & | operator|= (DenseVector< VT1, TF > &lhs, const DenseVector< VT2, TF > &rhs) |
Bitwise OR assignment operator for the bitwise OR of a dense vector. More... | |
template<typename VT1 , typename VT2 , bool TF> | |
VT1 & | operator|= (DenseVector< VT1, TF > &&lhs, const DenseVector< VT2, TF > &rhs) |
Bitwise OR assignment operator for the bitwise OR of a temporary dense vector. More... | |
template<typename VT , bool TF, typename ST > | |
auto | operator^= (DenseVector< VT, TF > &vec, ST scalar) -> EnableIf_t< IsNumeric_v< ST >, VT & > |
Bitwise XOR assignment operator for the bitwise XOR of a dense vector and a scalar value. More... | |
template<typename VT , bool TF, typename ST > | |
auto | operator^= (DenseVector< VT, TF > &&vec, ST scalar) -> EnableIf_t< IsNumeric_v< ST >, VT & > |
Bitwise XOR assignment operator for the bitwise XOR of a temporary dense vector and a scalar value. More... | |
template<typename VT1 , typename VT2 , bool TF> | |
VT1 & | operator^= (DenseVector< VT1, TF > &lhs, const DenseVector< VT2, TF > &rhs) |
Bitwise XOR assignment operator for the bitwise XOR of a dense vector. More... | |
template<typename VT1 , typename VT2 , bool TF> | |
VT1 & | operator^= (DenseVector< VT1, TF > &&lhs, const DenseVector< VT2, TF > &rhs) |
Bitwise XOR assignment operator for the bitwise XOR of a temporary dense vector. More... | |
DenseVector functions | |
template<typename VT , bool TF> | |
bool | isnan (const DenseVector< VT, TF > &dv) |
Checks the given dense vector for not-a-number elements. More... | |
template<typename VT , bool TF> | |
bool | isDivisor (const DenseVector< VT, TF > &dv) |
Returns whether the given dense vector is a valid divisor. More... | |
template<bool RF, typename VT , bool TF> | |
bool | isUniform (const DenseVector< VT, TF > &dv) |
Checks if the given dense vector is a uniform vector. More... | |
DynamicMatrix operators | |
template<typename Type , bool SO> | |
void | reset (DynamicMatrix< Type, SO > &m) |
Resetting the given dynamic matrix. More... | |
template<typename Type , bool SO> | |
void | reset (DynamicMatrix< Type, SO > &m, size_t i) |
Reset the specified row/column of the given dynamic matrix. More... | |
template<typename Type , bool SO> | |
void | clear (DynamicMatrix< Type, SO > &m) |
Clearing the given dynamic matrix. More... | |
template<bool RF, typename Type , bool SO> | |
bool | isDefault (const DynamicMatrix< Type, SO > &m) |
Returns whether the given dynamic matrix is in default state. More... | |
template<typename Type , bool SO> | |
bool | isIntact (const DynamicMatrix< Type, SO > &m) noexcept |
Returns whether the invariants of the given dynamic matrix are intact. More... | |
template<typename Type , bool SO> | |
void | swap (DynamicMatrix< Type, SO > &a, DynamicMatrix< Type, SO > &b) noexcept |
Swapping the contents of two dynamic matrices. More... | |
DynamicVector operators | |
template<typename Type , bool TF> | |
void | reset (DynamicVector< Type, TF > &v) |
Resetting the given dynamic vector. More... | |
template<typename Type , bool TF> | |
void | clear (DynamicVector< Type, TF > &v) |
Clearing the given dynamic vector. More... | |
template<bool RF, typename Type , bool TF> | |
bool | isDefault (const DynamicVector< Type, TF > &v) |
Returns whether the given dynamic vector is in default state. More... | |
template<typename Type , bool TF> | |
bool | isIntact (const DynamicVector< Type, TF > &v) noexcept |
Returns whether the invariants of the given dynamic vector are intact. More... | |
template<typename Type , bool TF> | |
void | swap (DynamicVector< Type, TF > &a, DynamicVector< Type, TF > &b) noexcept |
Swapping the contents of two vectors. More... | |
Eigenvalue functions | |
template<typename MT , bool SO, typename VT , bool TF> | |
void | eigen (const DenseMatrix< MT, SO > &A, DenseVector< VT, TF > &w) |
Eigenvalue computation of the given dense matrix. More... | |
template<typename MT1 , bool SO1, typename VT , bool TF, typename MT2 , bool SO2> | |
void | eigen (const DenseMatrix< MT1, SO1 > &A, DenseVector< VT, TF > &w, DenseMatrix< MT2, SO2 > &V) |
Eigenvalue computation of the given dense matrix. More... | |
HybridMatrix operators | |
template<typename Type , size_t M, size_t N, bool SO> | |
void | reset (HybridMatrix< Type, M, N, SO > &m) |
Resetting the given hybrid matrix. More... | |
template<typename Type , size_t M, size_t N, bool SO> | |
void | reset (HybridMatrix< Type, M, N, SO > &m, size_t i) |
Reset the specified row/column of the given hybrid matrix. More... | |
template<typename Type , size_t M, size_t N, bool SO> | |
void | clear (HybridMatrix< Type, M, N, SO > &m) |
Clearing the given hybrid matrix. More... | |
template<bool RF, typename Type , size_t M, size_t N, bool SO> | |
bool | isDefault (const HybridMatrix< Type, M, N, SO > &m) |
Returns whether the given hybrid matrix is in default state. More... | |
template<typename Type , size_t M, size_t N, bool SO> | |
bool | isIntact (const HybridMatrix< Type, M, N, SO > &m) noexcept |
Returns whether the invariants of the given hybrid matrix are intact. More... | |
template<typename Type , size_t M, size_t N, bool SO> | |
void | swap (HybridMatrix< Type, M, N, SO > &a, HybridMatrix< Type, M, N, SO > &b) noexcept |
Swapping the contents of two hybrid matrices. More... | |
HybridVector operators | |
template<typename Type , size_t N, bool TF> | |
void | reset (HybridVector< Type, N, TF > &v) |
Resetting the given hybrid vector. More... | |
template<typename Type , size_t N, bool TF> | |
void | clear (HybridVector< Type, N, TF > &v) |
Clearing the given hybrid vector. More... | |
template<bool RF, typename Type , size_t N, bool TF> | |
bool | isDefault (const HybridVector< Type, N, TF > &v) |
Returns whether the given hybrid vector is in default state. More... | |
template<typename Type , size_t N, bool TF> | |
bool | isIntact (const HybridVector< Type, N, TF > &v) |
Returns whether the invariants of the given hybrid vector are intact. More... | |
template<typename Type , size_t N, bool TF> | |
void | swap (HybridVector< Type, N, TF > &a, HybridVector< Type, N, TF > &b) noexcept |
Swapping the contents of two hybrid vectors. More... | |
InitializerIterator operators | |
template<typename Type > | |
bool | operator== (const InitializerIterator< Type > &lhs, const InitializerIterator< Type > &rhs) noexcept |
Equality comparison between two InitializerIterator objects. More... | |
template<typename Type > | |
bool | operator!= (const InitializerIterator< Type > &lhs, const InitializerIterator< Type > &rhs) noexcept |
Inequality comparison between two InitializerIterator objects. More... | |
template<typename Type > | |
bool | operator< (const InitializerIterator< Type > &lhs, const InitializerIterator< Type > &rhs) noexcept |
Less-than comparison between two InitializerIterator objects. More... | |
template<typename Type > | |
bool | operator> (const InitializerIterator< Type > &lhs, const InitializerIterator< Type > &rhs) noexcept |
Greater-than comparison between two InitializerIterator objects. More... | |
template<typename Type > | |
bool | operator<= (const InitializerIterator< Type > &lhs, const InitializerIterator< Type > &rhs) noexcept |
Less-than comparison between two InitializerIterator objects. More... | |
template<typename Type > | |
bool | operator>= (const InitializerIterator< Type > &lhs, const InitializerIterator< Type > &rhs) noexcept |
Greater-than comparison between two InitializerIterator objects. More... | |
template<typename Type > | |
const InitializerIterator< Type > | operator+ (const InitializerIterator< Type > &it, ptrdiff_t inc) noexcept |
Addition between a InitializerIterator and an integral value. More... | |
template<typename Type > | |
const InitializerIterator< Type > | operator+ (ptrdiff_t inc, const InitializerIterator< Type > &it) noexcept |
Addition between an integral value and a InitializerIterator. More... | |
template<typename Type > | |
const InitializerIterator< Type > | operator- (const InitializerIterator< Type > &it, ptrdiff_t dec) noexcept |
Subtraction between a InitializerIterator and an integral value. More... | |
template<typename Type > | |
ptrdiff_t | operator- (const InitializerIterator< Type > &lhs, const InitializerIterator< Type > &rhs) noexcept |
Calculating the number of elements between two iterators. More... | |
InitializerMatrix operators | |
template<typename Type > | |
bool | isIntact (const InitializerMatrix< Type > &m) noexcept |
Returns whether the invariants of the given initializer matrix are intact. More... | |
template<typename Type > | |
void | swap (InitializerMatrix< Type > &a, InitializerMatrix< Type > &b) noexcept |
Swapping the contents of two initializer matrices. More... | |
InitializerVector operators | |
template<typename Type , bool TF> | |
bool | isIntact (const InitializerVector< Type, TF > &v) noexcept |
Returns whether the invariants of the given initializer vector are intact. More... | |
template<typename Type , bool TF> | |
void | swap (InitializerVector< Type, TF > &a, InitializerVector< Type, TF > &b) noexcept |
Swapping the contents of two vectors. More... | |
Inversion functions | |
template<typename MT , bool SO> | |
void | invert (DenseMatrix< MT, SO > &dm) |
In-place inversion of the given dense matrix. More... | |
template<InversionFlag IF, typename MT , bool SO> | |
void | invert (DenseMatrix< MT, SO > &dm) |
In-place inversion of the given dense matrix. More... | |
LLH decomposition functions | |
template<typename MT1 , bool SO1, typename MT2 , bool SO2> | |
void | llh (const DenseMatrix< MT1, SO1 > &A, DenseMatrix< MT2, SO2 > &L) |
Cholesky (LLH) decomposition of the given dense matrix. More... | |
LQ decomposition functions | |
template<typename MT1 , bool SO1, typename MT2 , bool SO2, typename MT3 , bool SO3> | |
void | lq (const DenseMatrix< MT1, SO1 > &A, DenseMatrix< MT2, SO2 > &L, DenseMatrix< MT3, SO3 > &Q) |
LQ decomposition of the given dense matrix. More... | |
LU decomposition functions | |
template<typename MT1 , bool SO1, typename MT2 , typename MT3 , typename MT4 , bool SO2> | |
void | lu (const DenseMatrix< MT1, SO1 > &A, DenseMatrix< MT2, SO1 > &L, DenseMatrix< MT3, SO1 > &U, Matrix< MT4, SO2 > &P) |
LU decomposition of the given dense matrix. More... | |
QL decomposition functions | |
template<typename MT1 , bool SO1, typename MT2 , bool SO2, typename MT3 , bool SO3> | |
void | ql (const DenseMatrix< MT1, SO1 > &A, DenseMatrix< MT2, SO2 > &Q, DenseMatrix< MT3, SO3 > &L) |
QL decomposition of the given dense matrix. More... | |
QR decomposition functions | |
template<typename MT1 , bool SO1, typename MT2 , bool SO2, typename MT3 , bool SO3> | |
void | qr (const DenseMatrix< MT1, SO1 > &A, DenseMatrix< MT2, SO2 > &Q, DenseMatrix< MT3, SO3 > &R) |
QR decomposition of the given dense matrix. More... | |
RQ decomposition functions | |
template<typename MT1 , bool SO1, typename MT2 , bool SO2, typename MT3 , bool SO3> | |
void | rq (const DenseMatrix< MT1, SO1 > &A, DenseMatrix< MT2, SO2 > &R, DenseMatrix< MT3, SO3 > &Q) |
RQ decomposition of the given dense matrix. More... | |
StaticMatrix operators | |
template<typename Type , size_t M, size_t N, bool SO> | |
void | reset (StaticMatrix< Type, M, N, SO > &m) |
Resetting the given static matrix. More... | |
template<typename Type , size_t M, size_t N, bool SO> | |
void | reset (StaticMatrix< Type, M, N, SO > &m, size_t i) |
Reset the specified row/column of the given static matrix. More... | |
template<typename Type , size_t M, size_t N, bool SO> | |
void | clear (StaticMatrix< Type, M, N, SO > &m) |
Clearing the given static matrix. More... | |
template<bool RF, typename Type , size_t M, size_t N, bool SO> | |
bool | isDefault (const StaticMatrix< Type, M, N, SO > &m) |
Returns whether the given dynamic matrix is in default state. More... | |
template<typename Type , size_t M, size_t N, bool SO> | |
bool | isIntact (const StaticMatrix< Type, M, N, SO > &m) noexcept |
Returns whether the invariants of the given static matrix are intact. More... | |
template<typename Type , size_t M, size_t N, bool SO> | |
void | swap (StaticMatrix< Type, M, N, SO > &a, StaticMatrix< Type, M, N, SO > &b) noexcept |
Swapping the contents of two static matrices. More... | |
StaticVector operators | |
template<typename Type , size_t N, bool TF> | |
constexpr void | reset (StaticVector< Type, N, TF > &v) |
Resetting the given static vector. More... | |
template<typename Type , size_t N, bool TF> | |
constexpr void | clear (StaticVector< Type, N, TF > &v) |
Clearing the given static vector. More... | |
template<bool RF, typename Type , size_t N, bool TF> | |
bool | isDefault (const StaticVector< Type, N, TF > &v) |
Returns whether the given static vector is in default state. More... | |
template<typename Type , size_t N, bool TF> | |
constexpr bool | isIntact (const StaticVector< Type, N, TF > &v) noexcept |
Returns whether the invariants of the given static vector are intact. More... | |
template<typename Type , bool TF> | |
const StaticVector< Type, 2UL, TF > | perp (const StaticVector< Type, 2UL, TF > &v) |
Unary perp dot product operator for the calculation of a perpendicular vector ( ![]() | |
template<typename Type , bool TF> | |
const StaticVector< Type, 3UL, TF > | perp (const StaticVector< Type, 3UL, TF > &v) |
Creates a perpendicular vector b which satisfies ![]() | |
template<typename Type , size_t N, bool TF> | |
void | swap (StaticVector< Type, N, TF > &a, StaticVector< Type, N, TF > &b) noexcept |
Swapping the contents of two static vectors. More... | |
template<size_t I, typename Type , size_t N, bool TF> | |
constexpr Type & | get (StaticVector< Type, N, TF > &v) noexcept |
Tuple-like index-based access the contents of a static vector. More... | |
template<size_t I, typename Type , size_t N, bool TF> | |
constexpr Type && | get (StaticVector< Type, N, TF > &&v) noexcept |
Tuple-like index-based access the contents of a temporary static vector. More... | |
template<size_t I, typename Type , size_t N, bool TF> | |
constexpr const Type & | get (const StaticVector< Type, N, TF > &v) noexcept |
Tuple-like index-based access the contents of a constant static vector. More... | |
template<size_t I, typename Type , size_t N, bool TF> | |
constexpr const Type && | get (const StaticVector< Type, N, TF > &&v) noexcept |
Tuple-like index-based access the contents of a constant temporary static vector. More... | |
Singular value decomposition functions | |
template<typename MT , bool SO, typename VT , bool TF> | |
void | svd (const DenseMatrix< MT, SO > &A, DenseVector< VT, TF > &s) |
Singular value decomposition (SVD) of the given dense general matrix. More... | |
template<typename MT1 , bool SO, typename VT , bool TF, typename MT2 , typename MT3 > | |
void | svd (const DenseMatrix< MT1, SO > &A, DenseMatrix< MT2, SO > &U, DenseVector< VT, TF > &s, DenseMatrix< MT3, SO > &V) |
Singular value decomposition (SVD) of the given dense general matrix. More... | |
template<typename MT , bool SO, typename VT , bool TF, typename ST > | |
size_t | svd (const DenseMatrix< MT, SO > &A, DenseVector< VT, TF > &s, ST low, ST upp) |
Singular value decomposition (SVD) of the given dense general matrix. More... | |
template<typename MT1 , bool SO, typename VT , bool TF, typename MT2 , typename MT3 , typename ST > | |
size_t | svd (const DenseMatrix< MT1, SO > &A, DenseMatrix< MT2, SO > &U, DenseVector< VT, TF > &s, DenseMatrix< MT3, SO > &V, ST low, ST upp) |
Singular value decomposition (SVD) of the given dense general matrix. More... | |
UniformIterator operators | |
template<typename T1 , bool AF1, typename T2 , bool AF2> | |
constexpr bool | operator== (const UniformIterator< T1, AF1 > &lhs, const UniformIterator< T2, AF2 > &rhs) noexcept |
Equality comparison between two UniformIterator objects. More... | |
template<typename T1 , bool AF1, typename T2 , bool AF2> | |
constexpr bool | operator!= (const UniformIterator< T1, AF1 > &lhs, const UniformIterator< T2, AF2 > &rhs) noexcept |
Inequality comparison between two UniformIterator objects. More... | |
template<typename T1 , bool AF1, typename T2 , bool AF2> | |
constexpr bool | operator< (const UniformIterator< T1, AF1 > &lhs, const UniformIterator< T2, AF2 > &rhs) noexcept |
Less-than comparison between two UniformIterator objects. More... | |
template<typename T1 , bool AF1, typename T2 , bool AF2> | |
constexpr bool | operator> (const UniformIterator< T1, AF1 > &lhs, const UniformIterator< T2, AF2 > &rhs) noexcept |
Greater-than comparison between two UniformIterator objects. More... | |
template<typename T1 , bool AF1, typename T2 , bool AF2> | |
constexpr bool | operator<= (const UniformIterator< T1, AF1 > &lhs, const UniformIterator< T2, AF2 > &rhs) noexcept |
Less-or-equal-than comparison between two UniformIterator objects. More... | |
template<typename T1 , bool AF1, typename T2 , bool AF2> | |
constexpr bool | operator>= (const UniformIterator< T1, AF1 > &lhs, const UniformIterator< T2, AF2 > &rhs) noexcept |
Greater-or-equal-than comparison between two UniformIterator objects. More... | |
template<typename Type , bool AF> | |
constexpr const UniformIterator< Type, AF > | operator+ (const UniformIterator< Type, AF > &it, ptrdiff_t inc) noexcept |
Addition between a UniformIterator and an integral value. More... | |
template<typename Type , bool AF> | |
constexpr const UniformIterator< Type, AF > | operator+ (ptrdiff_t inc, const UniformIterator< Type, AF > &it) noexcept |
Addition between an integral value and a UniformIterator. More... | |
template<typename Type , bool AF> | |
constexpr const UniformIterator< Type, AF > | operator- (const UniformIterator< Type, AF > &it, ptrdiff_t dec) noexcept |
Subtraction between a UniformIterator and an integral value. More... | |
template<typename Type , bool AF> | |
constexpr ptrdiff_t | operator- (const UniformIterator< Type, AF > &lhs, const UniformIterator< Type, AF > &rhs) noexcept |
Calculating the number of elements between two UniformIterator objects. More... | |
UniformMatrix operators | |
template<typename Type , bool SO> | |
constexpr void | reset (UniformMatrix< Type, SO > &m) |
Resetting the given uniform matrix. More... | |
template<typename Type , bool SO> | |
constexpr void | clear (UniformMatrix< Type, SO > &m) |
Clearing the given dynamic matrix. More... | |
template<bool RF, typename Type , bool SO> | |
constexpr bool | isDefault (const UniformMatrix< Type, SO > &m) |
Returns whether the given uniform matrix is in default state. More... | |
template<typename Type , bool SO> | |
constexpr bool | isIntact (const UniformMatrix< Type, SO > &m) noexcept |
Returns whether the invariants of the given uniform matrix are intact. More... | |
template<typename Type , bool SO> | |
constexpr void | swap (UniformMatrix< Type, SO > &a, UniformMatrix< Type, SO > &b) noexcept |
Swapping the contents of two uniform matrices. More... | |
UniformVector operators | |
template<typename Type , bool TF> | |
constexpr void | reset (UniformVector< Type, TF > &v) |
Resetting the given uniform vector. More... | |
template<typename Type , bool TF> | |
constexpr void | clear (UniformVector< Type, TF > &v) |
Clearing the given uniform vector. More... | |
template<bool RF, typename Type , bool TF> | |
constexpr bool | isDefault (const UniformVector< Type, TF > &v) |
Returns whether the given uniform vector is in default state. More... | |
template<typename Type , bool TF> | |
constexpr bool | isIntact (const UniformVector< Type, TF > &v) noexcept |
Returns whether the invariants of the given uniform vector are intact. More... | |
template<typename Type , bool TF> | |
constexpr void | swap (UniformVector< Type, TF > &a, UniformVector< Type, TF > &b) noexcept |
Swapping the contents of two vectors. More... | |
NegativeEpsilon operators | |
template<typename E , typename T > | |
constexpr bool | 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 | 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 | 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 | 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 | 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 | 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 | 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 | 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 | operator== (const Epsilon &, const T &rhs) |
Equality comparison between an Epsilon object and a floating point value. More... | |
template<typename T > | |
constexpr bool | operator== (const T &lhs, const Epsilon &) |
Equality comparison between a floating point value and an Epsilon object. More... | |
template<typename T > | |
constexpr bool | operator!= (const Epsilon &, const T &rhs) |
Inequality comparison between an Epsilon object and a floating point value. More... | |
template<typename T > | |
constexpr bool | operator!= (const T &lhs, const Epsilon &) |
Inequality comparison between a floating point value and an Epsilon object. More... | |
template<typename T > | |
constexpr bool | operator< (const Epsilon &, const T &rhs) |
Less-than comparison between an Epsilon object and a floating point value. More... | |
template<typename T > | |
constexpr bool | operator< (const T &lhs, const Epsilon &) |
Less-than comparison between a floating point value and an Epsilon object. More... | |
template<typename T > | |
constexpr bool | operator> (const Epsilon &, const T &rhs) |
Greater-than comparison between an Epsilon object and a floating point value. More... | |
template<typename T > | |
constexpr bool | operator> (const T &lhs, const Epsilon &) |
Greater-than comparison between a floating point value and an Epsilon object. More... | |
template<typename T > | |
constexpr bool | 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 | 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 | 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 | operator>= (const T &lhs, const Epsilon &) |
Less-or-equal-than comparison between a floating point value and an Epsilon object. More... | |
DenseMatrix global functions | |
template<typename MT , bool SO> | |
MT::ElementType * | data (DenseMatrix< MT, SO > &dm) noexcept |
Low-level data access to the dense matrix elements. More... | |
template<typename MT , bool SO> | |
const MT::ElementType * | data (const DenseMatrix< MT, SO > &dm) noexcept |
Low-level data access to the dense matrix elements. More... | |
template<typename MT , bool SO> | |
size_t | spacing (const DenseMatrix< MT, SO > &dm) noexcept |
Returns the spacing between the beginning of two rows/columns. More... | |
DenseVector global functions | |
template<typename VT , bool TF> | |
VT::ElementType * | data (DenseVector< VT, TF > &dv) noexcept |
Low-level data access to the dense vector elements. More... | |
template<typename VT , bool TF> | |
const VT::ElementType * | data (const DenseVector< VT, TF > &dv) noexcept |
Low-level data access to the dense vector elements. More... | |
Determinant functions | |
template<typename MT , bool SO> | |
ElementType_t< MT > | det (const DenseMatrix< MT, SO > &dm) |
Computation of the determinant of the given dense square matrix. More... | |
Matrix global functions | |
template<typename MT , bool SO> | |
MT::Iterator | begin (Matrix< MT, SO > &matrix, size_t i) |
Returns an iterator to the first element of row/column i. More... | |
template<typename MT , bool SO> | |
MT::ConstIterator | begin (const Matrix< MT, SO > &matrix, size_t i) |
Returns an iterator to the first element of row/column i. More... | |
template<typename MT , bool SO> | |
MT::ConstIterator | cbegin (const Matrix< MT, SO > &matrix, size_t i) |
Returns an iterator to the first element of row/column i. More... | |
template<typename MT , bool SO> | |
MT::Iterator | end (Matrix< MT, SO > &matrix, size_t i) |
Returns an iterator just past the last element of row/column i. More... | |
template<typename MT , bool SO> | |
MT::ConstIterator | end (const Matrix< MT, SO > &matrix, size_t i) |
Returns an iterator just past the last element of row/column i. More... | |
template<typename MT , bool SO> | |
MT::ConstIterator | cend (const Matrix< MT, SO > &matrix, size_t i) |
Returns an iterator just past the last element of row/column i. More... | |
template<typename MT , bool SO> | |
constexpr size_t | rows (const Matrix< MT, SO > &matrix) noexcept |
Returns the current number of rows of the matrix. More... | |
template<typename MT , bool SO> | |
constexpr size_t | columns (const Matrix< MT, SO > &matrix) noexcept |
Returns the current number of columns of the matrix. More... | |
template<typename MT , bool SO> | |
constexpr size_t | size (const Matrix< MT, SO > &matrix) noexcept |
Returns the total number of elements of the matrix. More... | |
template<typename MT , bool SO> | |
size_t | capacity (const Matrix< MT, SO > &matrix) noexcept |
Returns the maximum capacity of the matrix. More... | |
template<typename MT , bool SO> | |
size_t | capacity (const Matrix< MT, SO > &matrix, size_t i) noexcept |
Returns the current capacity of the specified row/column. More... | |
template<typename MT , bool SO> | |
size_t | nonZeros (const Matrix< MT, SO > &matrix) |
Returns the total number of non-zero elements in the matrix. More... | |
template<typename MT , bool SO> | |
size_t | nonZeros (const Matrix< MT, SO > &matrix, size_t i) |
Returns the number of non-zero elements in the specified row/column. More... | |
template<typename MT , bool SO> | |
void | resize (Matrix< MT, SO > &matrix, size_t rows, size_t columns, bool preserve=true) |
Changing the size of the matrix. More... | |
template<typename MT , bool SO> | |
void | shrinkToFit (Matrix< MT, SO > &matrix) |
Requesting the removal of unused capacity. More... | |
template<typename MT , bool SO> | |
void | transpose (Matrix< MT, SO > &matrix) |
In-place transpose of the given matrix. More... | |
template<typename MT , bool SO> | |
void | ctranspose (Matrix< MT, SO > &matrix) |
In-place conjugate transpose of the given matrix. More... | |
template<typename MT , bool SO> | |
const MT::ResultType | evaluate (const Matrix< MT, SO > &matrix) |
Evaluates the given matrix expression. More... | |
template<typename MT , bool SO> | |
constexpr bool | isEmpty (const Matrix< MT, SO > &matrix) noexcept |
Checks if the given matrix is empty. More... | |
template<typename MT , bool SO> | |
bool | isSquare (const Matrix< MT, SO > &matrix) noexcept |
Checks if the given matrix is a square matrix. More... | |
template<typename MT1 , bool SO1, typename MT2 , bool SO2> | |
bool | isSame (const Matrix< MT1, SO1 > &a, const Matrix< MT2, SO2 > &b) noexcept |
Returns whether the two given matrices represent the same observable state. More... | |
Vector global functions | |
template<typename VT , bool TF> | |
VT::Iterator | begin (Vector< VT, TF > &vector) |
Returns an iterator to the first element of the given vector. More... | |
template<typename VT , bool TF> | |
VT::ConstIterator | begin (const Vector< VT, TF > &vector) |
Returns an iterator to the first element of the given vector. More... | |
template<typename VT , bool TF> | |
VT::ConstIterator | cbegin (const Vector< VT, TF > &vector) |
Returns an iterator to the first element of the given vector. More... | |
template<typename VT , bool TF> | |
VT::Iterator | end (Vector< VT, TF > &vector) |
Returns an iterator just past the last element of the given vector. More... | |
template<typename VT , bool TF> | |
VT::ConstIterator | end (const Vector< VT, TF > &vector) |
Returns an iterator just past the last element of the given vector. More... | |
template<typename VT , bool TF> | |
VT::ConstIterator | cend (const Vector< VT, TF > &vector) |
Returns an iterator just past the last element of the given vector. More... | |
template<typename VT , bool TF> | |
constexpr size_t | size (const Vector< VT, TF > &vector) noexcept |
Returns the current size/dimension of the vector. More... | |
template<typename VT , bool TF> | |
size_t | capacity (const Vector< VT, TF > &vector) noexcept |
Returns the maximum capacity of the vector. More... | |
template<typename VT , bool TF> | |
size_t | nonZeros (const Vector< VT, TF > &vector) |
Returns the number of non-zero elements in the vector. More... | |
template<typename VT , bool TF> | |
void | resize (Vector< VT, TF > &vector, size_t n, bool preserve=true) |
Changing the size of the vector. More... | |
template<typename VT , bool TF> | |
void | shrinkToFit (Vector< VT, TF > &vector) |
Requesting the removal of unused capacity. More... | |
template<typename VT , bool TF> | |
const VT::ResultType | evaluate (const Vector< VT, TF > &vector) |
Evaluates the given vector expression. More... | |
template<typename VT , bool TF> | |
constexpr bool | isEmpty (const Vector< VT, TF > &vector) noexcept |
Checks if the given vector is empty. More... | |
template<typename VT1 , bool TF1, typename VT2 , bool TF2> | |
bool | isSame (const Vector< VT1, TF1 > &a, const Vector< VT2, TF2 > &b) noexcept |
Returns whether the two given vectors represent the same observable state. More... | |
NegativeInfinity operators | |
template<typename I1 , typename I2 > | |
constexpr bool | operator== (const NegativeInfinity< I1 > &, const NegativeInfinity< I2 > &) |
Equality comparison between two NegativeInfinity objects. More... | |
template<typename I , typename T > | |
constexpr bool | 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 | 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 | operator!= (const NegativeInfinity< I1 > &, const NegativeInfinity< I2 > &) |
Inequality comparison between two NegativeInfinity objects. More... | |
template<typename I , typename T > | |
constexpr bool | 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 | 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 | operator== (const Infinity &, const Infinity &) |
Equality comparison between two Infinity objects. More... | |
template<typename I > | |
constexpr bool | operator== (const Infinity &, const NegativeInfinity< I > &) |
Equality comparison between an Infinity object and a NegativeInfinity object. More... | |
template<typename I > | |
constexpr bool | operator== (const NegativeInfinity< I > &, const Infinity &) |
Equality comparison between a NegativeInfinity object and an Infinity object. More... | |
template<typename T > | |
constexpr bool | 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 | operator== (const T &lhs, const Infinity &rhs) |
Equality comparison between a built-in data type and an Infinity object. More... | |
constexpr bool | operator!= (const Infinity &, const Infinity &) |
Inequality comparison between two Infinity objects. More... | |
template<typename I > | |
constexpr bool | operator!= (const Infinity &, const NegativeInfinity< I > &) |
Inequality comparison between an Infinity object and a NegativeInfinity object. More... | |
template<typename I > | |
constexpr bool | operator!= (const NegativeInfinity< I > &, const Infinity &) |
Inequality comparison between a NegativeInfinity object and an Infinity object. More... | |
template<typename T > | |
constexpr bool | 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 | operator!= (const T &lhs, const Infinity &rhs) |
Inequality comparison between a built-in data type and an Infinity object. More... | |
LAPACK general matrix eigenvalue functions (geev) | |
void | geev (char jobvl, char jobvr, int n, float *A, int lda, float *wr, float *wi, float *VL, int ldvl, float *VR, int ldvr, float *work, int lwork, int *info) |
LAPACK kernel for computing the eigenvalues of the given dense general single precision column-major matrix. More... | |
void | geev (char jobvl, char jobvr, int n, double *A, int lda, double *wr, double *wi, double *VL, int ldvl, double *VR, int ldvr, double *work, int lwork, int *info) |
LAPACK kernel for computing the eigenvalues of the given dense general double precision column-major matrix. More... | |
void | geev (char jobvl, char jobvr, int n, complex< float > *A, int lda, complex< float > *w, complex< float > *VL, int ldvl, complex< float > *VR, int ldvr, complex< float > *work, int lwork, float *rwork, int *info) |
LAPACK kernel for computing the eigenvalues of the given dense general single precision complex column-major matrix. More... | |
void | geev (char jobvl, char jobvr, int n, complex< double > *A, int lda, complex< double > *w, complex< double > *VL, int ldvl, complex< double > *VR, int ldvr, complex< double > *work, int lwork, double *rwork, int *info) |
LAPACK kernel for computing the eigenvalues of the given dense general double precision complex column-major matrix. More... | |
template<typename MT , bool SO, typename VT , bool TF> | |
void | geev (DenseMatrix< MT, SO > &A, DenseVector< VT, TF > &w) |
LAPACK kernel for computing the eigenvalues of the given dense general matrix. More... | |
template<typename MT1 , bool SO1, typename MT2 , bool SO2, typename VT , bool TF> | |
void | geev (DenseMatrix< MT1, SO1 > &A, DenseMatrix< MT2, SO2 > &VL, DenseVector< VT, TF > &w) |
LAPACK kernel for computing the eigenvalues of the given dense general matrix. More... | |
template<typename MT1 , bool SO1, typename VT , bool TF, typename MT2 , bool SO2> | |
void | geev (DenseMatrix< MT1, SO1 > &A, DenseVector< VT, TF > &w, DenseMatrix< MT2, SO2 > &VR) |
LAPACK kernel for computing the eigenvalues of the given dense general matrix. More... | |
template<typename MT1 , bool SO1, typename MT2 , bool SO2, typename VT , bool TF, typename MT3 , bool SO3> | |
void | geev (DenseMatrix< MT1, SO1 > &A, DenseMatrix< MT2, SO2 > &VL, DenseVector< VT, TF > &w, DenseMatrix< MT3, SO3 > &VR) |
LAPACK kernel for computing the eigenvalues of the given dense general matrix. More... | |
LAPACK LQ decomposition functions (gelqf) | |
void | gelqf (int m, int n, float *A, int lda, float *tau, float *work, int lwork, int *info) |
LAPACK kernel for the LQ decomposition of the given dense single precision column-major matrix. More... | |
void | gelqf (int m, int n, double *A, int lda, double *tau, double *work, int lwork, int *info) |
LAPACK kernel for the LQ decomposition of the given dense double precision column-major matrix. More... | |
void | gelqf (int m, int n, complex< float > *A, int lda, complex< float > *tau, complex< float > *work, int lwork, int *info) |
LAPACK kernel for the LQ decomposition of the given dense single precision complex column-major matrix. More... | |
void | gelqf (int m, int n, complex< double > *A, int lda, complex< double > *tau, complex< double > *work, int lwork, int *info) |
LAPACK kernel for the LQ decomposition of the given dense double precision complex column-major matrix. More... | |
template<typename MT , bool SO> | |
void | gelqf (DenseMatrix< MT, SO > &A, ElementType_t< MT > *tau) |
LAPACK kernel for the LQ decomposition of the given dense matrix. More... | |
LAPACK QL decomposition functions (geqlf) | |
void | geqlf (int m, int n, float *A, int lda, float *tau, float *work, int lwork, int *info) |
LAPACK kernel for the QL decomposition of the given dense single precision column-major matrix. More... | |
void | geqlf (int m, int n, double *A, int lda, double *tau, double *work, int lwork, int *info) |
LAPACK kernel for the QL decomposition of the given dense double precision column-major matrix. More... | |
void | geqlf (int m, int n, complex< float > *A, int lda, complex< float > *tau, complex< float > *work, int lwork, int *info) |
LAPACK kernel for the QL decomposition of the given dense single precision complex column-major matrix. More... | |
void | geqlf (int m, int n, complex< double > *A, int lda, complex< double > *tau, complex< double > *work, int lwork, int *info) |
LAPACK kernel for the QL decomposition of the given dense double precision complex column-major matrix. More... | |
template<typename MT , bool SO> | |
void | geqlf (DenseMatrix< MT, SO > &A, ElementType_t< MT > *tau) |
LAPACK kernel for the QL decomposition of the given dense matrix. More... | |
LAPACK QR decomposition functions (geqp3) | |
void | geqp3 (int m, int n, float *A, int lda, int *jpvt, float *tau, float *work, int lwork, int *info) |
LAPACK kernel for the QR decomposition of the given dense single precision column-major matrix. More... | |
void | geqp3 (int m, int n, double *A, int lda, int *jpvt, double *tau, double *work, int lwork, int *info) |
LAPACK kernel for the QR decomposition of the given dense double precision column-major matrix. More... | |
LAPACK QR decomposition functions (geqrf) | |
void | geqrf (int m, int n, float *A, int lda, float *tau, float *work, int lwork, int *info) |
LAPACK kernel for the QR decomposition of the given dense single precision column-major matrix. More... | |
void | geqrf (int m, int n, double *A, int lda, double *tau, double *work, int lwork, int *info) |
LAPACK kernel for the QR decomposition of the given dense double precision column-major matrix. More... | |
void | geqrf (int m, int n, complex< float > *A, int lda, complex< float > *tau, complex< float > *work, int lwork, int *info) |
LAPACK kernel for the QR decomposition of the given dense single precision complex column-major matrix. More... | |
void | geqrf (int m, int n, complex< double > *A, int lda, complex< double > *tau, complex< double > *work, int lwork, int *info) |
LAPACK kernel for the QR decomposition of the given dense double precision complex column-major matrix. More... | |
template<typename MT , bool SO> | |
void | geqrf (DenseMatrix< MT, SO > &A, ElementType_t< MT > *tau) |
LAPACK kernel for the QR decomposition of the given dense matrix. More... | |
LAPACK RQ decomposition functions (gerqf) | |
void | gerqf (int m, int n, float *A, int lda, float *tau, float *work, int lwork, int *info) |
LAPACK kernel for the RQ decomposition of the given dense single precision column-major matrix. More... | |
void | gerqf (int m, int n, double *A, int lda, double *tau, double *work, int lwork, int *info) |
LAPACK kernel for the RQ decomposition of the given dense single precision column-major matrix. More... | |
void | gerqf (int m, int n, complex< float > *A, int lda, complex< float > *tau, complex< float > *work, int lwork, int *info) |
LAPACK kernel for the RQ decomposition of the given dense single precision complex column-major matrix. More... | |
void | gerqf (int m, int n, complex< double > *A, int lda, complex< double > *tau, complex< double > *work, int lwork, int *info) |
LAPACK kernel for the RQ decomposition of the given dense double precision complex column-major matrix. More... | |
template<typename MT , bool SO> | |
void | gerqf (DenseMatrix< MT, SO > &A, ElementType_t< MT > *tau) |
LAPACK kernel for the RQ decomposition of the given dense matrix. More... | |
LAPACK SVD functions (gesdd) | |
void | gesdd (char jobz, int m, int n, float *A, int lda, float *s, float *U, int ldu, float *V, int ldv, float *work, int lwork, int *iwork, int *info) |
LAPACK kernel for the singular value decomposition (SVD) of the given dense general single precision column-major matrix. More... | |
void | gesdd (char jobz, int m, int n, double *A, int lda, double *s, double *U, int ldu, double *V, int ldv, double *work, int lwork, int *iwork, int *info) |
LAPACK kernel for the singular value decomposition (SVD) of the given dense general double precision column-major matrix. More... | |
void | gesdd (char jobz, int m, int n, complex< float > *A, int lda, float *s, complex< float > *U, int ldu, complex< float > *V, int ldv, complex< float > *work, int lwork, float *rwork, int *iwork, int *info) |
LAPACK kernel for the singular value decomposition (SVD) of the given dense general single precision complex column-major matrix. More... | |
void | gesdd (char jobz, int m, int n, complex< double > *A, int lda, double *s, complex< double > *U, int ldu, complex< double > *V, int ldv, complex< double > *work, int lwork, double *rwork, int *iwork, int *info) |
LAPACK kernel for the singular value decomposition (SVD) of the given dense general double precision complex column-major matrix. More... | |
template<typename MT , bool SO, typename VT , bool TF> | |
void | gesdd (DenseMatrix< MT, SO > &A, DenseVector< VT, TF > &s) |
LAPACK kernel for the singular value decomposition (SVD) of the given dense general matrix. More... | |
template<typename MT1 , bool SO, typename MT2 , typename VT , bool TF> | |
void | gesdd (DenseMatrix< MT1, SO > &A, DenseMatrix< MT2, SO > &U, DenseVector< VT, TF > &s, char jobz) |
LAPACK kernel for the singular value decomposition (SVD) of the given dense general matrix. More... | |
template<typename MT1 , bool SO, typename MT2 , typename VT , bool TF> | |
void | gesdd (DenseMatrix< MT1, SO > &A, DenseVector< VT, TF > &s, DenseMatrix< MT2, SO > &V, char jobz) |
LAPACK kernel for the singular value decomposition (SVD) of the given dense general matrix. More... | |
template<typename MT1 , bool SO, typename MT2 , typename VT , bool TF, typename MT3 > | |
void | gesdd (DenseMatrix< MT1, SO > &A, DenseMatrix< MT2, SO > &U, DenseVector< VT, TF > &s, DenseMatrix< MT3, SO > &V, char jobz) |
LAPACK kernel for the singular value decomposition (SVD) of the given dense general matrix. More... | |
LAPACK general linear system functions (gesv) | |
void | gesv (int n, int nrhs, float *A, int lda, int *ipiv, float *B, int ldb, int *info) |
LAPACK kernel for solving a general single precision linear system of equations ( ![]() | |
void | gesv (int n, int nrhs, double *A, int lda, int *ipiv, double *B, int ldb, int *info) |
LAPACK kernel for solving a general double precision linear system of equations ( ![]() | |
void | gesv (int n, int nrhs, complex< float > *A, int lda, int *ipiv, complex< float > *B, int ldb, int *info) |
LAPACK kernel for solving a general single precision complex linear system of equations ( ![]() | |
void | gesv (int n, int nrhs, complex< double > *A, int lda, int *ipiv, complex< double > *B, int ldb, int *info) |
LAPACK kernel for solving a general double precision complex linear system of equations ( ![]() | |
template<typename MT , bool SO, typename VT , bool TF> | |
void | gesv (DenseMatrix< MT, SO > &A, DenseVector< VT, TF > &b, int *ipiv) |
LAPACK kernel for solving a general linear system of equations ( ![]() | |
template<typename MT1 , bool SO1, typename MT2 , bool SO2> | |
void | gesv (DenseMatrix< MT1, SO1 > &A, DenseMatrix< MT2, SO2 > &B, int *ipiv) |
LAPACK kernel for solving a general linear system of equations ( ![]() | |
LAPACK SVD functions (gesvd) | |
void | gesvd (char jobu, char jobv, int m, int n, float *A, int lda, float *s, float *U, int ldu, float *V, int ldv, float *work, int lwork, int *info) |
LAPACK kernel for the singular value decomposition (SVD) of the given dense general single precision column-major matrix. More... | |
void | gesvd (char jobu, char jobv, int m, int n, double *A, int lda, double *s, double *U, int ldu, double *V, int ldv, double *work, int lwork, int *info) |
LAPACK kernel for the singular value decomposition (SVD) of the given dense general double precision column-major matrix. More... | |
void | gesvd (char jobu, char jobv, int m, int n, complex< float > *A, int lda, float *s, complex< float > *U, int ldu, complex< float > *V, int ldv, complex< float > *work, int lwork, float *rwork, int *info) |
LAPACK kernel for the singular value decomposition (SVD) of the given dense general single precision complex column-major matrix. More... | |
void | gesvd (char jobu, char jobv, int m, int n, complex< double > *A, int lda, double *s, complex< double > *U, int ldu, complex< double > *V, int ldv, complex< double > *work, int lwork, double *rwork, int *info) |
LAPACK kernel for the singular value decomposition (SVD) of the given dense general double precision complex column-major matrix. More... | |
template<typename MT , bool SO, typename VT , bool TF> | |
void | gesvd (DenseMatrix< MT, SO > &A, DenseVector< VT, TF > &s, char jobu, char jobv) |
LAPACK kernel for the singular value decomposition (SVD) of the given dense general matrix. More... | |
template<typename MT1 , bool SO, typename MT2 , typename VT , bool TF> | |
void | gesvd (DenseMatrix< MT1, SO > &A, DenseMatrix< MT2, SO > &U, DenseVector< VT, TF > &s, char jobu, char jobv) |
LAPACK kernel for the singular value decomposition (SVD) of the given dense general matrix. More... | |
template<typename MT1 , bool SO, typename VT , bool TF, typename MT2 > | |
void | gesvd (DenseMatrix< MT1, SO > &A, DenseVector< VT, TF > &s, DenseMatrix< MT2, SO > &V, char jobu, char jobv) |
LAPACK kernel for the singular value decomposition (SVD) of the given dense general matrix. More... | |
template<typename MT1 , bool SO, typename MT2 , typename VT , bool TF, typename MT3 > | |
void | gesvd (DenseMatrix< MT1, SO > &A, DenseMatrix< MT2, SO > &U, DenseVector< VT, TF > &s, DenseMatrix< MT3, SO > &V, char jobu, char jobv) |
LAPACK kernel for the singular value decomposition (SVD) of the given dense general matrix. More... | |
LAPACK SVD functions (gesvdx) | |
void | gesvdx (char jobu, char jobv, char range, int m, int n, float *A, int lda, float vl, float vu, int il, int iu, int *ns, float *s, float *U, int ldu, float *V, int ldv, float *work, int lwork, int *iwork, int *info) |
LAPACK kernel for the singular value decomposition (SVD) of the given dense general single precision column-major matrix. More... | |
void | gesvdx (char jobu, char jobv, char range, int m, int n, double *A, int lda, double vl, double vu, int il, int iu, int *ns, double *s, double *U, int ldu, double *V, int ldv, double *work, int lwork, int *iwork, int *info) |
LAPACK kernel for the singular value decomposition (SVD) of the given dense general double precision column-major matrix. More... | |
void | gesvdx (char jobu, char jobv, char range, int m, int n, complex< float > *A, int lda, float vl, float vu, int il, int iu, int *ns, float *s, complex< float > *U, int ldu, complex< float > *V, int ldv, complex< float > *work, int lwork, float *rwork, int *iwork, int *info) |
LAPACK kernel for the singular value decomposition (SVD) of the given dense general single precision complex column-major matrix. More... | |
void | gesvdx (char jobu, char jobv, char range, int m, int n, complex< double > *A, int lda, double vl, double vu, int il, int iu, int *ns, double *s, complex< double > *U, int ldu, complex< double > *V, int ldv, complex< double > *work, int lwork, double *rwork, int *iwork, int *info) |
LAPACK kernel for the singular value decomposition (SVD) of the given dense general double precision complex column-major matrix. More... | |
template<typename MT , bool SO, typename VT , bool TF> | |
size_t | gesvdx (DenseMatrix< MT, SO > &A, DenseVector< VT, TF > &s) |
LAPACK kernel for the singular value decomposition (SVD) of the given dense general matrix. More... | |
template<typename MT , bool SO, typename VT , bool TF, typename ST > | |
size_t | gesvdx (DenseMatrix< MT, SO > &A, DenseVector< VT, TF > &s, ST low, ST upp) |
LAPACK kernel for the singular value decomposition (SVD) of the given dense general matrix. More... | |
template<typename MT1 , bool SO, typename MT2 , typename VT , bool TF> | |
size_t | gesvdx (DenseMatrix< MT1, SO > &A, DenseMatrix< MT2, SO > &U, DenseVector< VT, TF > &s) |
LAPACK kernel for the singular value decomposition (SVD) of the given dense general matrix. More... | |
template<typename MT1 , bool SO, typename MT2 , typename VT , bool TF, typename ST > | |
size_t | gesvdx (DenseMatrix< MT1, SO > &A, DenseMatrix< MT2, SO > &U, DenseVector< VT, TF > &s, ST low, ST upp) |
LAPACK kernel for the singular value decomposition (SVD) of the given dense general matrix. More... | |
template<typename MT1 , bool SO, typename VT , bool TF, typename MT2 > | |
size_t | gesvdx (DenseMatrix< MT1, SO > &A, DenseVector< VT, TF > &s, DenseMatrix< MT2, SO > &V) |
LAPACK kernel for the singular value decomposition (SVD) of the given dense general matrix. More... | |
template<typename MT1 , bool SO, typename VT , bool TF, typename MT2 , typename ST > | |
size_t | gesvdx (DenseMatrix< MT1, SO > &A, DenseVector< VT, TF > &s, DenseMatrix< MT2, SO > &V, ST low, ST upp) |
LAPACK kernel for the singular value decomposition (SVD) of the given dense general matrix. More... | |
template<typename MT1 , bool SO, typename MT2 , typename VT , bool TF, typename MT3 > | |
size_t | gesvdx (DenseMatrix< MT1, SO > &A, DenseMatrix< MT2, SO > &U, DenseVector< VT, TF > &s, DenseMatrix< MT3, SO > &V) |
LAPACK kernel for the singular value decomposition (SVD) of the given dense general matrix. More... | |
template<typename MT1 , bool SO, typename MT2 , typename VT , bool TF, typename MT3 , typename ST > | |
size_t | gesvdx (DenseMatrix< MT1, SO > &A, DenseMatrix< MT2, SO > &U, DenseVector< VT, TF > &s, DenseMatrix< MT3, SO > &V, ST low, ST upp) |
LAPACK kernel for the singular value decomposition (SVD) of the given dense general matrix. More... | |
LAPACK LU decomposition functions (getrf) | |
void | getrf (int m, int n, float *A, int lda, int *ipiv, int *info) |
LAPACK kernel for the LU decomposition of the given dense general single precision column-major matrix. More... | |
void | getrf (int m, int n, double *A, int lda, int *ipiv, int *info) |
LAPACK kernel for the LU decomposition of the given dense general double precision column-major matrix. More... | |
void | getrf (int m, int n, complex< float > *A, int lda, int *ipiv, int *info) |
LAPACK kernel for the LU decomposition of the given dense general single precision complex column-major matrix. More... | |
void | getrf (int m, int n, complex< double > *A, int lda, int *ipiv, int *info) |
LAPACK kernel for the LU decomposition of the given dense general double precision complex column-major matrix. More... | |
template<typename MT , bool SO> | |
void | getrf (DenseMatrix< MT, SO > &A, int *ipiv) |
LAPACK kernel for the LU decomposition of the given dense general matrix. More... | |
LAPACK LU-based inversion functions (getri) | |
void | getri (int n, float *A, int lda, const int *ipiv, float *work, int lwork, int *info) |
LAPACK kernel for the inversion of the given dense general single precision column-major square matrix. More... | |
void | getri (int n, double *A, int lda, const int *ipiv, double *work, int lwork, int *info) |
LAPACK kernel for the inversion of the given dense general double precision column-major square matrix. More... | |
void | getri (int n, complex< float > *A, int lda, const int *ipiv, complex< float > *work, int lwork, int *info) |
LAPACK kernel for the inversion of the given dense general single precision complex column-major square matrix. More... | |
void | getri (int n, complex< double > *A, int lda, const int *ipiv, complex< double > *work, int lwork, int *info) |
LAPACK kernel for the inversion of the given dense general double precision complex column-major square matrix. More... | |
template<typename MT , bool SO> | |
void | getri (DenseMatrix< MT, SO > &A, const int *ipiv) |
LAPACK kernel for the inversion of the given dense general matrix. More... | |
LAPACK LU-based substitution functions (getrs) | |
void | getrs (char trans, int n, int nrhs, const float *A, int lda, const int *ipiv, float *B, int ldb, int *info) |
LAPACK kernel for the substitution step of solving a general single precision linear system of equations ( ![]() | |
void | getrs (char trans, int n, int nrhs, const double *A, int lda, const int *ipiv, double *B, int ldb, int *info) |
LAPACK kernel for the substitution step of solving a general double precision linear system of equations ( ![]() | |
void | getrs (char trans, int n, int nrhs, const complex< float > *A, int lda, const int *ipiv, complex< float > *B, int ldb, int *info) |
LAPACK kernel for the substitution step of solving a general single precision complex linear system of equations ( ![]() | |
void | getrs (char trans, int n, int nrhs, const complex< double > *A, int lda, const int *ipiv, complex< double > *B, int ldb, int *info) |
LAPACK kernel for the substitution step of solving a general double precision complex linear system of equations ( ![]() | |
template<typename MT , bool SO, typename VT , bool TF> | |
void | getrs (const DenseMatrix< MT, SO > &A, DenseVector< VT, TF > &b, char trans, const int *ipiv) |
LAPACK kernel for the substitution step of solving a general linear system of equations ( ![]() | |
template<typename MT1 , bool SO1, typename MT2 , bool SO2> | |
void | getrs (const DenseMatrix< MT1, SO1 > &A, DenseMatrix< MT2, SO2 > &B, char trans, const int *ipiv) |
LAPACK kernel for the substitution step of solving a general linear system of equations ( ![]() | |
LAPACK Hermitian matrix eigenvalue functions (heev) | |
void | heev (char jobz, char uplo, int n, complex< float > *A, int lda, float *w, complex< float > *work, int lwork, float *rwork, int *info) |
LAPACK kernel for computing the eigenvalues of the given dense Hermitian single precision column-major matrix. More... | |
void | heev (char jobz, char uplo, int n, complex< double > *A, int lda, double *w, complex< double > *work, int lwork, double *rwork, int *info) |
LAPACK kernel for computing the eigenvalues of the given dense Hermitian double precision column-major matrix. More... | |
template<typename MT , bool SO, typename VT , bool TF> | |
void | heev (DenseMatrix< MT, SO > &A, DenseVector< VT, TF > &w, char jobz, char uplo) |
LAPACK kernel for computing the eigenvalues of the given dense Hermitian matrix. More... | |
LAPACK Hermitian matrix eigenvalue functions (heevd) | |
void | heevd (char jobz, char uplo, int n, complex< float > *A, int lda, float *w, complex< float > *work, int lwork, float *rwork, int lrwork, int *iwork, int liwork, int *info) |
LAPACK kernel for computing the eigenvalues of the given dense Hermitian single precision column-major matrix. More... | |
void | heevd (char jobz, char uplo, int n, complex< double > *A, int lda, double *w, complex< double > *work, int lwork, double *rwork, int lrwork, int *iwork, int liwork, int *info) |
LAPACK kernel for computing the eigenvalues of the given dense Hermitian double precision column-major matrix. More... | |
template<typename MT , bool SO, typename VT , bool TF> | |
void | heevd (DenseMatrix< MT, SO > &A, DenseVector< VT, TF > &w, char jobz, char uplo) |
LAPACK kernel for computing the eigenvalues of the given dense Hermitian matrix. More... | |
LAPACK Hermitian matrix eigenvalue functions (heevx) | |
void | heevx (char jobz, char range, char uplo, int n, complex< float > *A, int lda, float vl, float vu, int il, int iu, float abstol, int *m, float *w, complex< float > *Z, int ldz, complex< float > *work, int lwork, float *rwork, int *iwork, int *ifail, int *info) |
LAPACK kernel for computing the eigenvalues of the given dense Hermitian single precision complex column-major matrix. More... | |
void | heevx (char jobz, char range, char uplo, int n, complex< double > *A, int lda, double vl, double vu, int il, int iu, double abstol, int *m, double *w, complex< double > *Z, int ldz, complex< double > *work, int lwork, double *rwork, int *iwork, int *ifail, int *info) |
LAPACK kernel for computing the eigenvalues of the given dense Hermitian double precision complex column-major matrix. More... | |
template<typename MT , bool SO, typename VT , bool TF> | |
size_t | heevx (DenseMatrix< MT, SO > &A, DenseVector< VT, TF > &w, char uplo) |
LAPACK kernel for the eigenvalue computation of the given dense Hermitian matrix. More... | |
template<typename MT , bool SO, typename VT , bool TF, typename ST > | |
size_t | heevx (DenseMatrix< MT, SO > &A, DenseVector< VT, TF > &w, char uplo, ST low, ST upp) |
LAPACK kernel for computing the eigenvalues of the given dense Hermitian matrix. More... | |
template<typename MT1 , bool SO1, typename VT , bool TF, typename MT2 , bool SO2> | |
size_t | heevx (DenseMatrix< MT1, SO1 > &A, DenseVector< VT, TF > &w, DenseMatrix< MT2, SO2 > &Z, char uplo) |
LAPACK kernel for computing the eigenvalues of the given dense Hermitian matrix. More... | |
template<typename MT1 , bool SO1, typename VT , bool TF, typename MT2 , bool SO2, typename ST > | |
size_t | heevx (DenseMatrix< MT1, SO1 > &A, DenseVector< VT, TF > &w, DenseMatrix< MT2, SO2 > &Z, char uplo, ST low, ST upp) |
LAPACK kernel for computing the eigenvalues of the given dense Hermitian matrix. More... | |
LAPACK Hermitian indefinite linear system functions (hesv) | |
void | hesv (char uplo, int n, int nrhs, complex< float > *A, int lda, int *ipiv, complex< float > *B, int ldb, complex< float > *work, int lwork, int *info) |
LAPACK kernel for solving a Hermitian indefinite single precision complex linear system of equations ( ![]() | |
void | hesv (char uplo, int n, int nrhs, complex< double > *A, int lda, int *ipiv, complex< double > *B, int ldb, complex< double > *work, int lwork, int *info) |
LAPACK kernel for solving a Hermitian indefinite double precision complex linear system of equations ( ![]() | |
template<typename MT , bool SO, typename VT , bool TF> | |
void | hesv (DenseMatrix< MT, SO > &A, DenseVector< VT, TF > &b, char uplo, int *ipiv) |
LAPACK kernel for solving a Hermitian indefinite linear system of equations ( ![]() | |
template<typename MT1 , bool SO1, typename MT2 , bool SO2> | |
void | hesv (DenseMatrix< MT1, SO1 > &A, DenseMatrix< MT2, SO2 > &B, char uplo, int *ipiv) |
LAPACK kernel for solving a Hermitian indefinite linear system of equations ( ![]() | |
LAPACK LDLH decomposition functions (hetrf) | |
void | hetrf (char uplo, int n, complex< float > *A, int lda, int *ipiv, complex< float > *work, int lwork, int *info) |
LAPACK kernel for the decomposition of the given dense Hermitian indefinite single precision complex column-major matrix. More... | |
void | hetrf (char uplo, int n, complex< double > *A, int lda, int *ipiv, complex< double > *work, int lwork, int *info) |
LAPACK kernel for the decomposition of the given dense Hermitian indefinite double precision complex column-major matrix. More... | |
template<typename MT , bool SO> | |
void | hetrf (DenseMatrix< MT, SO > &A, char uplo, int *ipiv) |
LAPACK kernel for the decomposition of the given dense Hermitian indefinite matrix. More... | |
LAPACK LDLH-based inversion functions (hetri) | |
void | hetri (char uplo, int n, complex< float > *A, int lda, const int *ipiv, complex< float > *work, int *info) |
LAPACK kernel for the inversion of the given dense Hermitian indefinite single precision complex column-major square matrix. More... | |
void | hetri (char uplo, int n, complex< double > *A, int lda, const int *ipiv, complex< double > *work, int *info) |
LAPACK kernel for the inversion of the given dense Hermitian indefinite double precision complex column-major square matrix. More... | |
template<typename MT , bool SO> | |
void | hetri (DenseMatrix< MT, SO > &A, char uplo, const int *ipiv) |
LAPACK kernel for the inversion of the given dense Hermitian indefinite matrix. More... | |
LAPACK LDLH-based substitution functions (hetrs) | |
void | hetrs (char uplo, int n, int nrhs, const complex< float > *A, int lda, const int *ipiv, complex< float > *B, int ldb, int *info) |
LAPACK kernel for the substitution step of solving a symmetric indefinite single precision complex linear system of equations ( ![]() | |
void | hetrs (char uplo, int n, int nrhs, const complex< double > *A, int lda, const int *ipiv, complex< double > *B, int ldb, int *info) |
LAPACK kernel for the substitution step of solving a symmetric indefinite double precision complex linear system of equations ( ![]() | |
template<typename MT , bool SO, typename VT , bool TF> | |
void | hetrs (const DenseMatrix< MT, SO > &A, DenseVector< VT, TF > &b, char uplo, const int *ipiv) |
LAPACK kernel for the substitution step of solving a symmetric indefinite linear system of equations ( ![]() | |
template<typename MT1 , bool SO1, typename MT2 , bool SO2> | |
void | hetrs (const DenseMatrix< MT1, SO1 > &A, DenseMatrix< MT2, SO2 > &B, char uplo, const int *ipiv) |
LAPACK kernel for the substitution step of solving a symmetric indefinite linear system of equations ( ![]() | |
LAPACK functions to reconstruct Q from a QL decomposition (org2l) | |
void | org2l (int m, int n, int k, float *A, int lda, const float *tau, float *work, int *info) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a QL decomposition. More... | |
void | org2l (int m, int n, int k, double *A, int lda, const double *tau, double *work, int *info) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a QL decomposition. More... | |
template<typename MT , bool SO> | |
void | org2l (DenseMatrix< MT, SO > &A, const ElementType_t< MT > *tau) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a QL decomposition. More... | |
LAPACK functions to reconstruct Q from a QR decomposition (org2r) | |
void | org2r (int m, int n, int k, float *A, int lda, const float *tau, float *work, int *info) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a QR decomposition. More... | |
void | org2r (int m, int n, int k, double *A, int lda, const double *tau, double *work, int *info) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a QR decomposition. More... | |
template<typename MT , bool SO> | |
void | org2r (DenseMatrix< MT, SO > &A, const ElementType_t< MT > *tau) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a QR decomposition. More... | |
LAPACK functions to reconstruct Q from a LQ decomposition (orgl2) | |
void | orgl2 (int m, int n, int k, float *A, int lda, const float *tau, float *work, int *info) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a LQ decomposition. More... | |
void | orgl2 (int m, int n, int k, double *A, int lda, const double *tau, double *work, int *info) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a LQ decomposition. More... | |
template<typename MT , bool SO> | |
void | orgl2 (DenseMatrix< MT, SO > &A, const ElementType_t< MT > *tau) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a LQ decomposition. More... | |
LAPACK functions to reconstruct Q from a LQ decomposition (orglq) | |
void | orglq (int m, int n, int k, float *A, int lda, const float *tau, float *work, int lwork, int *info) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a LQ decomposition. More... | |
void | orglq (int m, int n, int k, double *A, int lda, const double *tau, double *work, int lwork, int *info) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a LQ decomposition. More... | |
template<typename MT , bool SO> | |
void | orglq (DenseMatrix< MT, SO > &A, const ElementType_t< MT > *tau) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a LQ decomposition. More... | |
LAPACK functions to reconstruct Q from a QL decomposition (orgql) | |
void | orgql (int m, int n, int k, float *A, int lda, const float *tau, float *work, int lwork, int *info) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a QL decomposition. More... | |
void | orgql (int m, int n, int k, double *A, int lda, const double *tau, double *work, int lwork, int *info) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a QL decomposition. More... | |
template<typename MT , bool SO> | |
void | orgql (DenseMatrix< MT, SO > &A, const ElementType_t< MT > *tau) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a QL decomposition. More... | |
LAPACK functions to reconstruct Q from a QR decomposition (orgqr) | |
void | orgqr (int m, int n, int k, float *A, int lda, const float *tau, float *work, int lwork, int *info) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a QR decomposition. More... | |
void | orgqr (int m, int n, int k, double *A, int lda, const double *tau, double *work, int lwork, int *info) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a QR decomposition. More... | |
template<typename MT , bool SO> | |
void | orgqr (DenseMatrix< MT, SO > &A, const ElementType_t< MT > *tau) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a QR decomposition. More... | |
LAPACK functions to reconstruct Q from a RQ decomposition (orgr2) | |
void | orgr2 (int m, int n, int k, float *A, int lda, const float *tau, float *work, int *info) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a RQ decomposition. More... | |
void | orgr2 (int m, int n, int k, double *A, int lda, const double *tau, double *work, int *info) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a RQ decomposition. More... | |
template<typename MT , bool SO> | |
void | orgr2 (DenseMatrix< MT, SO > &A, const ElementType_t< MT > *tau) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a RQ decomposition. More... | |
LAPACK functions to reconstruct Q from a RQ decomposition (orgrq) | |
void | orgrq (int m, int n, int k, float *A, int lda, const float *tau, float *work, int lwork, int *info) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a RQ decomposition. More... | |
void | orgrq (int m, int n, int k, double *A, int lda, const double *tau, double *work, int lwork, int *info) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a RQ decomposition. More... | |
template<typename MT , bool SO> | |
void | orgrq (DenseMatrix< MT, SO > &A, const ElementType_t< MT > *tau) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a RQ decomposition. More... | |
LAPACK functions to multiply Q from a LQ decomposition with a matrix (ormlq) | |
void | ormlq (char side, char trans, int m, int n, int k, const float *A, int lda, const float *tau, float *C, int ldc, float *work, int lwork, int *info) |
LAPACK kernel for the multiplication of the single precision Q from a LQ decomposition with another matrix. More... | |
void | ormlq (char side, char trans, int m, int n, int k, const double *A, int lda, const double *tau, double *C, int ldc, double *work, int lwork, int *info) |
LAPACK kernel for the multiplication of the double precision Q from a LQ decomposition with another matrix. More... | |
template<typename MT1 , bool SO1, typename MT2 , bool SO2> | |
void | ormlq (DenseMatrix< MT1, SO1 > &C, const DenseMatrix< MT2, SO2 > &A, char side, char trans, const ElementType_t< MT2 > *tau) |
LAPACK kernel for the multiplication of the double precision Q from a LQ decomposition with another matrix. More... | |
LAPACK functions to multiply Q from a QL decomposition with a matrix (ormql) | |
void | ormql (char side, char trans, int m, int n, int k, const float *A, int lda, const float *tau, float *C, int ldc, float *work, int lwork, int *info) |
LAPACK kernel for the multiplication of the single precision Q from a QL decomposition with another matrix. More... | |
void | ormql (char side, char trans, int m, int n, int k, const double *A, int lda, const double *tau, double *C, int ldc, double *work, int lwork, int *info) |
LAPACK kernel for the multiplication of the double precision Q from a QL decomposition with another matrix. More... | |
template<typename MT1 , bool SO1, typename MT2 , bool SO2> | |
void | ormql (DenseMatrix< MT1, SO1 > &C, const DenseMatrix< MT2, SO2 > &A, char side, char trans, const ElementType_t< MT2 > *tau) |
LAPACK kernel for the multiplication of the double precision Q from a QL decomposition with another matrix. More... | |
LAPACK functions to multiply Q from a QR decomposition with a matrix (ormqr) | |
void | ormqr (char side, char trans, int m, int n, int k, const float *A, int lda, const float *tau, float *C, int ldc, float *work, int lwork, int *info) |
LAPACK kernel for the multiplication of the single precision Q from a QR decomposition with another matrix. More... | |
void | ormqr (char side, char trans, int m, int n, int k, const double *A, int lda, const double *tau, double *C, int ldc, double *work, int lwork, int *info) |
LAPACK kernel for the multiplication of the double precision Q from a QR decomposition with another matrix. More... | |
template<typename MT1 , bool SO1, typename MT2 , bool SO2> | |
void | ormqr (DenseMatrix< MT1, SO1 > &C, const DenseMatrix< MT2, SO2 > &A, char side, char trans, const ElementType_t< MT2 > *tau) |
LAPACK kernel for the multiplication of the double precision Q from a QR decomposition with another matrix. More... | |
LAPACK functions to multiply Q from a RQ decomposition with a matrix (ormrq) | |
void | ormrq (char side, char trans, int m, int n, int k, const float *A, int lda, const float *tau, float *C, int ldc, float *work, int lwork, int *info) |
LAPACK kernel for the multiplication of the single precision Q from a RQ decomposition with another matrix. More... | |
void | ormrq (char side, char trans, int m, int n, int k, const double *A, int lda, const double *tau, double *C, int ldc, double *work, int lwork, int *info) |
LAPACK kernel for the multiplication of the double precision Q from a RQ decomposition with another matrix. More... | |
template<typename MT1 , bool SO1, typename MT2 , bool SO2> | |
void | ormrq (DenseMatrix< MT1, SO1 > &C, const DenseMatrix< MT2, SO2 > &A, char side, char trans, const ElementType_t< MT2 > *tau) |
LAPACK kernel for the multiplication of the double precision Q from a RQ decomposition with another matrix. More... | |
LAPACK positive definite linear system functions (posv) | |
void | posv (char uplo, int n, int nrhs, float *A, int lda, float *B, int ldb, int *info) |
LAPACK kernel for solving a positive definite single precision linear system of equations ( ![]() | |
void | posv (char uplo, int n, int nrhs, double *A, int lda, double *B, int ldb, int *info) |
LAPACK kernel for solving a positive definite double precision linear system of equations ( ![]() | |
void | posv (char uplo, int n, int nrhs, complex< float > *A, int lda, complex< float > *B, int ldb, int *info) |
LAPACK kernel for solving a positive definite single precision complex linear system of equations ( ![]() | |
void | posv (char uplo, int n, int nrhs, complex< double > *A, int lda, complex< double > *B, int ldb, int *info) |
LAPACK kernel for solving a positive definite double precision complex linear system of equations ( ![]() | |
template<typename MT , bool SO, typename VT , bool TF> | |
void | posv (DenseMatrix< MT, SO > &A, DenseVector< VT, TF > &b, char uplo) |
LAPACK kernel for solving a positive definite linear system of equations ( ![]() | |
template<typename MT1 , bool SO1, typename MT2 , bool SO2> | |
void | posv (DenseMatrix< MT1, SO1 > &A, DenseMatrix< MT2, SO2 > &B, char uplo) |
LAPACK kernel for solving a positive definite linear system of equations ( ![]() | |
LAPACK LLH (Cholesky) decomposition functions (potrf) | |
void | potrf (char uplo, int n, float *A, int lda, int *info) |
LAPACK kernel for the Cholesky decomposition of the given dense positive definite single precision column-major matrix. More... | |
void | potrf (char uplo, int n, double *A, int lda, int *info) |
LAPACK kernel for the Cholesky decomposition of the given dense positive definite double precision column-major matrix. More... | |
void | potrf (char uplo, int n, complex< float > *A, int lda, int *info) |
LAPACK kernel for the Cholesky decomposition of the given dense positive definite single precision complex column-major matrix. More... | |
void | potrf (char uplo, int n, complex< double > *A, int lda, int *info) |
LAPACK kernel for the Cholesky decomposition of the given dense positive definite double precision complex column-major matrix. More... | |
template<typename MT , bool SO> | |
void | potrf (DenseMatrix< MT, SO > &A, char uplo) |
LAPACK kernel for the Cholesky decomposition of the given dense positive definite matrix. More... | |
LAPACK LLH-based inversion functions (potri) | |
void | potri (char uplo, int n, float *A, int lda, int *info) |
LAPACK kernel for the inversion of the given dense positive definite single precision column-major square matrix. More... | |
void | potri (char uplo, int n, double *A, int lda, int *info) |
LAPACK kernel for the inversion of the given dense positive definite double precision column-major square matrix. More... | |
void | potri (char uplo, int n, complex< float > *A, int lda, int *info) |
LAPACK kernel for the inversion of the given dense positive definite single precision complex column-major square matrix. More... | |
void | potri (char uplo, int n, complex< double > *A, int lda, int *info) |
LAPACK kernel for the inversion of the given dense positive definite double precision complex column-major square matrix. More... | |
template<typename MT , bool SO> | |
void | potri (DenseMatrix< MT, SO > &A, char uplo) |
LAPACK kernel for the inversion of the given dense positive definite matrix. More... | |
LAPACK LLH-based substitution functions (potrs) | |
void | potrs (char uplo, int n, int nrhs, const float *A, int lda, float *B, int ldb, int *info) |
LAPACK kernel for the substitution step of solving a positive definite single precision linear system of equations ( ![]() | |
void | potrs (char uplo, int n, int nrhs, const double *A, int lda, double *B, int ldb, int *info) |
LAPACK kernel for the substitution step of solving a positive definite double precision linear system of equations ( ![]() | |
void | potrs (char uplo, int n, int nrhs, const complex< float > *A, int lda, complex< float > *B, int ldb, int *info) |
LAPACK kernel for the substitution step of solving a positive definite single precision complex linear system of equations ( ![]() | |
void | potrs (char uplo, int n, int nrhs, const complex< double > *A, int lda, complex< double > *B, int ldb, int *info) |
LAPACK kernel for the substitution step of solving a positive definite double precision complex linear system of equations ( ![]() | |
template<typename MT , bool SO, typename VT , bool TF> | |
void | potrs (const DenseMatrix< MT, SO > &A, DenseVector< VT, TF > &b, char uplo) |
LAPACK kernel for the substitution step of solving a positive definite linear system of equations ( ![]() | |
template<typename MT1 , bool SO1, typename MT2 , bool SO2> | |
void | potrs (const DenseMatrix< MT1, SO1 > &A, DenseMatrix< MT2, SO2 > &B, char uplo) |
LAPACK kernel for the substitution step of solving a positive definite linear system of equations ( ![]() | |
LAPACK symmetric matrix eigenvalue functions (syev) | |
void | syev (char jobz, char uplo, int n, float *A, int lda, float *w, float *work, int lwork, int *info) |
LAPACK kernel for computing the eigenvalues of the given dense symmetric single precision column-major matrix. More... | |
void | syev (char jobz, char uplo, int n, double *A, int lda, double *w, double *work, int lwork, int *info) |
LAPACK kernel for computing the eigenvalues of the given dense symmetric double precision column-major matrix. More... | |
template<typename MT , bool SO, typename VT , bool TF> | |
void | syev (DenseMatrix< MT, SO > &A, DenseVector< VT, TF > &w, char jobz, char uplo) |
LAPACK kernel for computing the eigenvalues of the given dense symmetric matrix. More... | |
LAPACK symmetric matrix eigenvalue functions (syevd) | |
void | syevd (char jobz, char uplo, int n, float *A, int lda, float *w, float *work, int lwork, int *iwork, int liwork, int *info) |
LAPACK kernel for computing the eigenvalues of the given dense symmetric single precision column-major matrix. More... | |
void | syevd (char jobz, char uplo, int n, double *A, int lda, double *w, double *work, int lwork, int *iwork, int liwork, int *info) |
LAPACK kernel for computing the eigenvalues of the given dense symmetric double precision column-major matrix. More... | |
template<typename MT , bool SO, typename VT , bool TF> | |
void | syevd (DenseMatrix< MT, SO > &A, DenseVector< VT, TF > &w, char jobz, char uplo) |
LAPACK kernel for computing the eigenvalues of the given dense symmetric matrix. More... | |
LAPACK symmetric matrix eigenvalue functions (syevx) | |
void | syevx (char jobz, char range, char uplo, int n, float *A, int lda, float vl, float vu, int il, int iu, float abstol, int *m, float *w, float *Z, int ldz, float *work, int lwork, int *iwork, int *ifail, int *info) |
LAPACK kernel for computing the eigenvalues of the given dense symmetric single precision column-major matrix. More... | |
void | syevx (char jobz, char range, char uplo, int n, double *A, int lda, double vl, double vu, int il, int iu, double abstol, int *m, double *w, double *Z, int ldz, double *work, int lwork, int *iwork, int *ifail, int *info) |
LAPACK kernel for computing the eigenvalues of the given dense symmetric double precision column-major matrix. More... | |
template<typename MT , bool SO, typename VT , bool TF> | |
size_t | syevx (DenseMatrix< MT, SO > &A, DenseVector< VT, TF > &w, char uplo) |
LAPACK kernel for computing the eigenvalues of the given dense symmetric matrix. More... | |
template<typename MT , bool SO, typename VT , bool TF, typename ST > | |
size_t | syevx (DenseMatrix< MT, SO > &A, DenseVector< VT, TF > &w, char uplo, ST low, ST upp) |
LAPACK kernel for computing the eigenvalues of the given dense symmetric matrix. More... | |
template<typename MT1 , bool SO1, typename VT , bool TF, typename MT2 , bool SO2> | |
size_t | syevx (DenseMatrix< MT1, SO1 > &A, DenseVector< VT, TF > &w, DenseMatrix< MT2, SO2 > &Z, char uplo) |
LAPACK kernel for computing the eigenvalues of the given dense symmetric matrix. More... | |
template<typename MT1 , bool SO1, typename VT , bool TF, typename MT2 , bool SO2, typename ST > | |
size_t | syevx (DenseMatrix< MT1, SO1 > &A, DenseVector< VT, TF > &w, DenseMatrix< MT2, SO2 > &Z, char uplo, ST low, ST upp) |
LAPACK kernel for computing the eigenvalues of the given dense symmetric matrix. More... | |
LAPACK symmetric indefinite linear system functions (sysv) | |
void | sysv (char uplo, int n, int nrhs, float *A, int lda, int *ipiv, float *B, int ldb, float *work, int lwork, int *info) |
LAPACK kernel for solving a symmetric indefinite single precision linear system of equations ( ![]() | |
void | sysv (char uplo, int n, int nrhs, double *A, int lda, int *ipiv, double *B, int ldb, double *work, int lwork, int *info) |
LAPACK kernel for solving a symmetric indefinite double precision linear system of equations ( ![]() | |
void | sysv (char uplo, int n, int nrhs, complex< float > *A, int lda, int *ipiv, complex< float > *B, int ldb, complex< float > *work, int lwork, int *info) |
LAPACK kernel for solving a symmetric indefinite single precision complex linear system of equations ( ![]() | |
void | sysv (char uplo, int n, int nrhs, complex< double > *A, int lda, int *ipiv, complex< double > *B, int ldb, complex< double > *work, int lwork, int *info) |
LAPACK kernel for solving a symmetric indefinite double precision complex linear system of equations ( ![]() | |
template<typename MT , bool SO, typename VT , bool TF> | |
void | sysv (DenseMatrix< MT, SO > &A, DenseVector< VT, TF > &b, char uplo, int *ipiv) |
LAPACK kernel for solving a symmetric indefinite linear system of equations ( ![]() | |
template<typename MT1 , bool SO1, typename MT2 , bool SO2> | |
void | sysv (DenseMatrix< MT1, SO1 > &A, DenseMatrix< MT2, SO2 > &B, char uplo, int *ipiv) |
LAPACK kernel for solving a symmetric indefinite linear system of equations ( ![]() | |
LAPACK LDLT decomposition functions (sytrf) | |
void | sytrf (char uplo, int n, float *A, int lda, int *ipiv, float *work, int lwork, int *info) |
LAPACK kernel for the decomposition of the given dense symmetric indefinite single precision column-major matrix. More... | |
void | sytrf (char uplo, int n, double *A, int lda, int *ipiv, double *work, int lwork, int *info) |
LAPACK kernel for the decomposition of the given dense symmetric indefinite double precision column-major matrix. More... | |
void | sytrf (char uplo, int n, complex< float > *A, int lda, int *ipiv, complex< float > *work, int lwork, int *info) |
LAPACK kernel for the decomposition of the given dense symmetric indefinite single precision complex column-major matrix. More... | |
void | sytrf (char uplo, int n, complex< double > *A, int lda, int *ipiv, complex< double > *work, int lwork, int *info) |
LAPACK kernel for the decomposition of the given dense symmetric indefinite double precision complex column-major matrix. More... | |
template<typename MT , bool SO> | |
void | sytrf (DenseMatrix< MT, SO > &A, char uplo, int *ipiv) |
LAPACK kernel for the decomposition of the given dense symmetric indefinite matrix. More... | |
LAPACK LDLT-based inversion functions (sytri) | |
void | sytri (char uplo, int n, float *A, int lda, const int *ipiv, float *work, int *info) |
LAPACK kernel for the inversion of the given dense symmetric indefinite single precision column-major square matrix. More... | |
void | sytri (char uplo, int n, double *A, int lda, const int *ipiv, double *work, int *info) |
LAPACK kernel for the inversion of the given dense symmetric indefinite double precision column-major square matrix. More... | |
void | sytri (char uplo, int n, complex< float > *A, int lda, const int *ipiv, complex< float > *work, int *info) |
LAPACK kernel for the inversion of the given dense symmetric indefinite single precision complex column-major square matrix. More... | |
void | sytri (char uplo, int n, complex< double > *A, int lda, const int *ipiv, complex< double > *work, int *info) |
LAPACK kernel for the inversion of the given dense symmetric indefinite double precision complex column-major square matrix. More... | |
template<typename MT , bool SO> | |
void | sytri (DenseMatrix< MT, SO > &A, char uplo, const int *ipiv) |
LAPACK kernel for the inversion of the given dense symmetric indefinite matrix. More... | |
LAPACK LDLT-based substitution functions (sytrs) | |
void | sytrs (char uplo, int n, int nrhs, const float *A, int lda, const int *ipiv, float *B, int ldb, int *info) |
LAPACK kernel for the substitution step of solving a symmetric indefinite single precision linear system of equations ( ![]() | |
void | sytrs (char uplo, int n, int nrhs, const double *A, int lda, const int *ipiv, double *B, int ldb, int *info) |
LAPACK kernel for the substitution step of solving a symmetric indefinite double precision linear system of equations ( ![]() | |
void | sytrs (char uplo, int n, int nrhs, const complex< float > *A, int lda, const int *ipiv, complex< float > *B, int ldb, int *info) |
LAPACK kernel for the substitution step of solving a symmetric indefinite single precision complex linear system of equations ( ![]() | |
void | sytrs (char uplo, int n, int nrhs, const complex< double > *A, int lda, const int *ipiv, complex< double > *B, int ldb, int *info) |
LAPACK kernel for the substitution step of solving a symmetric indefinite double precision complex linear system of equations ( ![]() | |
template<typename MT , bool SO, typename VT , bool TF> | |
void | sytrs (const DenseMatrix< MT, SO > &A, DenseVector< VT, TF > &b, char uplo, const int *ipiv) |
LAPACK kernel for the substitution step of solving a symmetric indefinite linear system of equations ( ![]() | |
template<typename MT1 , bool SO1, typename MT2 , bool SO2> | |
void | sytrs (const DenseMatrix< MT1, SO1 > &A, DenseMatrix< MT2, SO2 > &B, char uplo, const int *ipiv) |
LAPACK kernel for the substitution step of solving a symmetric indefinite linear system of equations ( ![]() | |
LAPACK triangular linear system functions (trsv) | |
void | trsv (char uplo, char trans, char diag, int n, const float *A, int lda, float *x, int incX) |
LAPACK kernel for solving a triangular single precision linear system of equations ( ![]() | |
void | trsv (char uplo, char trans, char diag, int n, const double *A, int lda, double *x, int incX) |
LAPACK kernel for solving a triangular double precision linear system of equations ( ![]() | |
void | trsv (char uplo, char trans, char diag, int n, const complex< float > *A, int lda, complex< float > *x, int incX) |
LAPACK kernel for solving a triangular single precision complex linear system of equations ( ![]() | |
void | trsv (char uplo, char trans, char diag, int n, const complex< double > *A, int lda, complex< double > *x, int incX) |
LAPACK kernel for solving a triangular double precision complex linear system of equations ( ![]() | |
template<typename MT , bool SO, typename VT , bool TF> | |
void | trsv (const DenseMatrix< MT, SO > &A, DenseVector< VT, TF > &b, char uplo, char trans, char diag) |
LAPACK kernel for solving a triangular linear system of equations ( ![]() ![]() | |
LAPACK triangular matrix inversion functions (trtri) | |
void | trtri (char uplo, char diag, int n, float *A, int lda, int *info) |
LAPACK kernel for the inversion of the given dense triangular single precision column-major matrix. More... | |
void | trtri (char uplo, char diag, int n, double *A, int lda, int *info) |
LAPACK kernel for the inversion of the given dense triangular double precision column-major matrix. More... | |
void | trtri (char uplo, char diag, int n, complex< float > *A, int lda, int *info) |
LAPACK kernel for the inversion of the given dense triangular single precision complex column-major matrix. More... | |
void | trtri (char uplo, char diag, int n, complex< double > *A, int lda, int *info) |
LAPACK kernel for the inversion of the given dense triangular double precision complex column-major matrix. More... | |
template<typename MT , bool SO> | |
void | trtri (DenseMatrix< MT, SO > &A, char uplo, char diag) |
LAPACK kernel for the inversion of the given dense triangular matrix. More... | |
LAPACK triangular substitution functions (trtrs) | |
void | trtrs (char uplo, char trans, char diag, int n, int nrhs, const float *A, int lda, float *B, int ldb, int *info) |
LAPACK kernel for the substitution step of solving a triangular single precision linear system of equations ( ![]() | |
void | trtrs (char uplo, char trans, char diag, int n, int nrhs, const double *A, int lda, double *B, int ldb, int *info) |
LAPACK kernel for the substitution step of solving a triangular double precision linear system of equations ( ![]() | |
void | trtrs (char uplo, char trans, char diag, int n, int nrhs, const complex< float > *A, int lda, complex< float > *B, int ldb, int *info) |
LAPACK kernel for the substitution step of solving a triangular single precision complex linear system of equations ( ![]() | |
void | trtrs (char uplo, char trans, char diag, int n, int nrhs, const complex< double > *A, int lda, complex< double > *B, int ldb, int *info) |
LAPACK kernel for the substitution step of solving a triangular double precision complex linear system of equations ( ![]() | |
template<typename MT , bool SO, typename VT , bool TF> | |
void | trtrs (const DenseMatrix< MT, SO > &A, DenseVector< VT, TF > &b, char uplo, char trans, char diag) |
LAPACK kernel for the substitution step of solving a triangular linear system of equations ( ![]() | |
template<typename MT1 , bool SO1, typename MT2 , bool SO2> | |
void | trtrs (const DenseMatrix< MT1, SO1 > &A, DenseMatrix< MT2, SO2 > &B, char uplo, char trans, char diag) |
LAPACK kernel for the substitution step of solving a triangular linear system of equations ( ![]() | |
LAPACK functions to reconstruct Q from a QL decomposition (ung2l) | |
void | ung2l (int m, int n, int k, complex< float > *A, int lda, const complex< float > *tau, complex< float > *work, int *info) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a QL decomposition. More... | |
void | ung2l (int m, int n, int k, complex< double > *A, int lda, const complex< double > *tau, complex< double > *work, int *info) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a QL decomposition. More... | |
template<typename MT , bool SO> | |
void | ung2l (DenseMatrix< MT, SO > &A, const ElementType_t< MT > *tau) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a QL decomposition. More... | |
LAPACK functions to reconstruct Q from a QR decomposition (ung2r) | |
void | ung2r (int m, int n, int k, complex< float > *A, int lda, const complex< float > *tau, complex< float > *work, int *info) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a QR decomposition. More... | |
void | ung2r (int m, int n, int k, complex< double > *A, int lda, const complex< double > *tau, complex< double > *work, int *info) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a QR decomposition. More... | |
template<typename MT , bool SO> | |
void | ung2r (DenseMatrix< MT, SO > &A, const ElementType_t< MT > *tau) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a QR decomposition. More... | |
LAPACK functions to reconstruct Q from a LQ decomposition (ungl2) | |
void | ungl2 (int m, int n, int k, complex< float > *A, int lda, const complex< float > *tau, complex< float > *work, int *info) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a LQ decomposition. More... | |
void | ungl2 (int m, int n, int k, complex< double > *A, int lda, const complex< double > *tau, complex< double > *work, int *info) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a LQ decomposition. More... | |
template<typename MT , bool SO> | |
void | ungl2 (DenseMatrix< MT, SO > &A, const ElementType_t< MT > *tau) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a LQ decomposition. More... | |
LAPACK functions to reconstruct Q from a LQ decomposition (unglq) | |
void | unglq (int m, int n, int k, complex< float > *A, int lda, const complex< float > *tau, complex< float > *work, int lwork, int *info) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a LQ decomposition. More... | |
void | unglq (int m, int n, int k, complex< double > *A, int lda, const complex< double > *tau, complex< double > *work, int lwork, int *info) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a LQ decomposition. More... | |
template<typename MT , bool SO> | |
void | unglq (DenseMatrix< MT, SO > &A, const ElementType_t< MT > *tau) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a LQ decomposition. More... | |
LAPACK functions to reconstruct Q from a QL decomposition (ungql) | |
void | ungql (int m, int n, int k, complex< float > *A, int lda, const complex< float > *tau, complex< float > *work, int lwork, int *info) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a QL decomposition. More... | |
void | ungql (int m, int n, int k, complex< double > *A, int lda, const complex< double > *tau, complex< double > *work, int lwork, int *info) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a QL decomposition. More... | |
template<typename MT , bool SO> | |
void | ungql (DenseMatrix< MT, SO > &A, const ElementType_t< MT > *tau) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a QL decomposition. More... | |
LAPACK functions to reconstruct Q from a QR decomposition (ungqr) | |
void | ungqr (int m, int n, int k, complex< float > *A, int lda, const complex< float > *tau, complex< float > *work, int lwork, int *info) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a QR decomposition. More... | |
void | ungqr (int m, int n, int k, complex< double > *A, int lda, const complex< double > *tau, complex< double > *work, int lwork, int *info) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a QR decomposition. More... | |
template<typename MT , bool SO> | |
void | ungqr (DenseMatrix< MT, SO > &A, const ElementType_t< MT > *tau) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a QR decomposition. More... | |
LAPACK functions to reconstruct Q from a RQ decomposition (ungr2) | |
void | ungr2 (int m, int n, int k, complex< float > *A, int lda, const complex< float > *tau, complex< float > *work, int *info) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a RQ decomposition. More... | |
void | ungr2 (int m, int n, int k, complex< double > *A, int lda, const complex< double > *tau, complex< double > *work, int *info) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a RQ decomposition. More... | |
template<typename MT , bool SO> | |
void | ungr2 (DenseMatrix< MT, SO > &A, const ElementType_t< MT > *tau) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a RQ decomposition. More... | |
LAPACK functions to reconstruct Q from a RQ decomposition (ungrq) | |
void | ungrq (int m, int n, int k, complex< float > *A, int lda, const complex< float > *tau, complex< float > *work, int lwork, int *info) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a RQ decomposition. More... | |
void | ungrq (int m, int n, int k, complex< double > *A, int lda, const complex< double > *tau, complex< double > *work, int lwork, int *info) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a RQ decomposition. More... | |
template<typename MT , bool SO> | |
void | ungrq (DenseMatrix< MT, SO > &A, const ElementType_t< MT > *tau) |
LAPACK kernel for the reconstruction of the orthogonal matrix Q from a RQ decomposition. More... | |
LAPACK functions to multiply Q from a LQ decomposition with a matrix (unmlq) | |
void | unmlq (char side, char trans, int m, int n, int k, const complex< float > *A, int lda, const complex< float > *tau, complex< float > *C, int ldc, complex< float > *work, int lwork, int *info) |
LAPACK kernel for the multiplication of the single precision complex Q from a LQ decomposition with another matrix. More... | |
void | unmlq (char side, char trans, int m, int n, int k, const complex< double > *A, int lda, const complex< double > *tau, complex< double > *C, int ldc, complex< double > *work, int lwork, int *info) |
LAPACK kernel for the multiplication of the double precision complex Q from a LQ decomposition with another matrix. More... | |
template<typename MT1 , bool SO, typename MT2 > | |
void | unmlq (DenseMatrix< MT1, SO > &C, const DenseMatrix< MT2, SO > &A, char side, char trans, const ElementType_t< MT2 > *tau) |
LAPACK kernel for the multiplication of the double precision Q from a LQ decomposition with another matrix. More... | |
LAPACK functions to multiply Q from a QL decomposition with a matrix (unmql) | |
void | unmql (char side, char trans, int m, int n, int k, const complex< float > *A, int lda, const complex< float > *tau, complex< float > *C, int ldc, complex< float > *work, int lwork, int *info) |
LAPACK kernel for the multiplication of the single precision Q from a QL decomposition with another matrix. More... | |
void | unmql (char side, char trans, int m, int n, int k, const complex< double > *A, int lda, const complex< double > *tau, complex< double > *C, int ldc, complex< double > *work, int lwork, int *info) |
LAPACK kernel for the multiplication of the double precision Q from a QL decomposition with another matrix. More... | |
template<typename MT1 , bool SO, typename MT2 > | |
void | unmql (DenseMatrix< MT1, SO > &C, const DenseMatrix< MT2, SO > &A, char side, char trans, const ElementType_t< MT2 > *tau) |
LAPACK kernel for the multiplication of the double precision Q from a QL decomposition with another matrix. More... | |
LAPACK functions to multiply Q from a QR decomposition with a matrix (unmqr) | |
void | unmqr (char side, char trans, int m, int n, int k, const complex< float > *A, int lda, const complex< float > *tau, complex< float > *C, int ldc, complex< float > *work, int lwork, int *info) |
LAPACK kernel for the multiplication of the single precision Q from a QR decomposition with another matrix. More... | |
void | unmqr (char side, char trans, int m, int n, int k, const complex< double > *A, int lda, const complex< double > *tau, complex< double > *C, int ldc, complex< double > *work, int lwork, int *info) |
LAPACK kernel for the multiplication of the double precision Q from a QR decomposition with another matrix. More... | |
template<typename MT1 , bool SO, typename MT2 > | |
void | unmqr (DenseMatrix< MT1, SO > &C, DenseMatrix< MT2, SO > &A, char side, char trans, ElementType_t< MT2 > *tau) |
LAPACK kernel for the multiplication of the double precision Q from a QR decomposition with another matrix. More... | |
LAPACK functions to multiply Q from a RQ decomposition with a matrix (unmrq) | |
void | unmrq (char side, char trans, int m, int n, int k, const complex< float > *A, int lda, const complex< float > *tau, complex< float > *C, int ldc, complex< float > *work, int lwork, int *info) |
LAPACK kernel for the multiplication of the single precision Q from a RQ decomposition with another matrix. More... | |
void | unmrq (char side, char trans, int m, int n, int k, const complex< double > *A, int lda, const complex< double > *tau, complex< double > *C, int ldc, complex< double > *work, int lwork, int *info) |
LAPACK kernel for the multiplication of the double precision Q from a RQ decomposition with another matrix. More... | |
template<typename MT1 , bool SO, typename MT2 > | |
void | unmrq (DenseMatrix< MT1, SO > &C, const DenseMatrix< MT2, SO > &A, char side, char trans, const ElementType_t< MT2 > *tau) |
LAPACK kernel for the multiplication of the double precision Q from a RQ decomposition with another matrix. More... | |
Matrix functions | |
template<typename MT , bool SO> | |
bool | isSymmetric (const Matrix< MT, SO > &m) |
Checks if the given matrix is symmetric. More... | |
template<typename MT , bool SO> | |
bool | isHermitian (const Matrix< MT, SO > &m) |
Checks if the given matrix is Hermitian. More... | |
template<typename MT , bool SO> | |
bool | isUniform (const Matrix< MT, SO > &m) |
Checks if the given matrix is a uniform matrix. More... | |
template<typename MT , bool SO> | |
bool | isLower (const Matrix< MT, SO > &m) |
Checks if the given matrix is a lower triangular matrix. More... | |
template<typename MT , bool SO> | |
bool | isUniLower (const Matrix< MT, SO > &m) |
Checks if the given matrix is a lower unitriangular matrix. More... | |
template<typename MT , bool SO> | |
bool | isStrictlyLower (const Matrix< MT, SO > &m) |
Checks if the given matrix is a strictly lower triangular matrix. More... | |
template<typename MT , bool SO> | |
bool | isUpper (const Matrix< MT, SO > &m) |
Checks if the given matrix is an upper triangular matrix. More... | |
template<typename MT , bool SO> | |
bool | isUniUpper (const Matrix< MT, SO > &m) |
Checks if the given matrix is an upper unitriangular matrix. More... | |
template<typename MT , bool SO> | |
bool | isStrictlyUpper (const Matrix< MT, SO > &m) |
Checks if the given matrix is a strictly upper triangular matrix. More... | |
template<typename MT , bool SO> | |
bool | isDiagonal (const Matrix< MT, SO > &m) |
Checks if the give matrix is diagonal. More... | |
template<typename MT , bool SO> | |
bool | isIdentity (const Matrix< MT, SO > &m) |
Checks if the give matrix is an identity matrix. More... | |
template<typename MT , bool SO> | |
auto | trace (const Matrix< MT, SO > &m) |
Computes the trace of the given square matrix. More... | |
template<bool RF, typename MT , bool SO> | |
decltype(auto) | reverse (const Matrix< MT, SO > &m) |
Reverse the rows or columns of a matrix. More... | |
Matrix operators | |
template<typename MT , bool SO> | |
std::ostream & | operator<< (std::ostream &os, const Matrix< MT, SO > &m) |
Global output operator for dense and sparse matrices. More... | |
DenseMatrixProxy global functions | |
template<typename PT , typename MT > | |
DenseMatrixProxy< PT, MT >::Iterator | 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 > | |
DenseMatrixProxy< PT, MT >::ConstIterator | 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 > | |
DenseMatrixProxy< PT, MT >::Iterator | 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 > | |
DenseMatrixProxy< PT, MT >::ConstIterator | 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 > | |
size_t | rows (const DenseMatrixProxy< PT, MT > &proxy) |
Returns the current number of rows of the represented matrix. More... | |
template<typename PT , typename MT > | |
size_t | columns (const DenseMatrixProxy< PT, MT > &proxy) |
Returns the current number of columns of the represented matrix. More... | |
template<typename PT , typename MT > | |
size_t | capacity (const DenseMatrixProxy< PT, MT > &proxy) |
Returns the maximum capacity of the represented matrix. More... | |
template<typename PT , typename MT > | |
size_t | 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 > | |
size_t | nonZeros (const DenseMatrixProxy< PT, MT > &proxy) |
Returns the number of non-zero elements in the represented matrix. More... | |
template<typename PT , typename MT > | |
size_t | 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 > | |
void | resize (const DenseMatrixProxy< PT, MT > &proxy, size_t m, size_t n, bool preserve=true) |
Changing the size of the represented matrix. More... | |
template<typename PT , typename MT > | |
void | reset (const DenseMatrixProxy< PT, MT > &proxy) |
Resetting the represented element to the default initial values. More... | |
template<typename PT , typename MT > | |
void | reset (const DenseMatrixProxy< PT, MT > &proxy, size_t i) |
Reset the specified row/column of the represented matrix. More... | |
template<typename PT , typename MT > | |
void | clear (const DenseMatrixProxy< PT, MT > &proxy) |
Clearing the represented matrix. More... | |
DenseVectorProxy global functions | |
template<typename PT , typename VT > | |
DenseVectorProxy< PT, VT >::Iterator | begin (const DenseVectorProxy< PT, VT > &proxy) |
Returns an iterator to the first element of the represented vector. More... | |
template<typename PT , typename VT > | |
DenseVectorProxy< PT, VT >::ConstIterator | cbegin (const DenseVectorProxy< PT, VT > &proxy) |
Returns an iterator to the first element of the represented vector. More... | |
template<typename PT , typename VT > | |
DenseVectorProxy< PT, VT >::Iterator | end (const DenseVectorProxy< PT, VT > &proxy) |
Returns an iterator just past the last element of the represented vector. More... | |
template<typename PT , typename VT > | |
DenseVectorProxy< PT, VT >::ConstIterator | cend (const DenseVectorProxy< PT, VT > &proxy) |
Returns an iterator just past the last element of the represented vector. More... | |
template<typename PT , typename VT > | |
size_t | size (const DenseVectorProxy< PT, VT > &proxy) |
Returns the current size/dimension of the represented vector. More... | |
template<typename PT , typename VT > | |
size_t | capacity (const DenseVectorProxy< PT, VT > &proxy) |
Returns the maximum capacity of the represented vector. More... | |
template<typename PT , typename VT > | |
size_t | nonZeros (const DenseVectorProxy< PT, VT > &proxy) |
Returns the number of non-zero elements in the represented vector. More... | |
template<typename PT , typename VT > | |
void | resize (const DenseVectorProxy< PT, VT > &proxy, size_t n, bool preserve=true) |
Changing the size of the represented vector. More... | |
template<typename PT , typename VT > | |
void | reset (const DenseVectorProxy< PT, VT > &proxy) |
Resetting the represented vector to the default initial values. More... | |
template<typename PT , typename VT > | |
void | clear (const DenseVectorProxy< PT, VT > &proxy) |
Clearing the represented vector. More... | |
Proxy operators | |
template<typename PT1 , typename RT1 , typename PT2 , typename RT2 > | |
decltype(auto) | 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) | 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) | 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) | 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) | 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) | 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) | 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) | 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) | 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) | 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) | 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) | 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 | 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 | 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 | 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 | 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 | 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 | 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 | 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 | 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 | 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 | 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 | 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 | 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 | 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 | 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 | 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 | 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 | 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 | 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 & | 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) | abs (const Proxy< PT, RT > &proxy) |
Computing the absolute value of the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | sign (const Proxy< PT, RT > &proxy) |
Evaluating the sign of the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | 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) | 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) | 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) | round (const Proxy< PT, RT > &proxy) |
Computes the nearest integral value to the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | conj (const Proxy< PT, RT > &proxy) |
Computing the complex conjugate of the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | trans (const Proxy< PT, RT > &proxy) |
Computing the transpose of the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | ctrans (const Proxy< PT, RT > &proxy) |
Computing the conjugate transpose of the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | real (const Proxy< PT, RT > &proxy) |
Computing the real part of the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | imag (const Proxy< PT, RT > &proxy) |
Computing the imaginary part of the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | sqrt (const Proxy< PT, RT > &proxy) |
Computing the square root of the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | invsqrt (const Proxy< PT, RT > &proxy) |
Computing the inverse square root of the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | cbrt (const Proxy< PT, RT > &proxy) |
Computing the cubic root of the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | 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) | 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) | 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) | 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) | 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) | pow2 (const Proxy< PT, RT > &proxy) |
Computing the square value of the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | pow3 (const Proxy< PT, RT > &proxy) |
Computing the cube value of the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | pow4 (const Proxy< PT, RT > &proxy) |
Computing the quadruple value of the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | exp (const Proxy< PT, RT > &proxy) |
Computing the base-e exponential of the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | exp2 (const Proxy< PT, RT > &proxy) |
Computing the base-2 exponential of the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | exp10 (const Proxy< PT, RT > &proxy) |
Computing the base-10 exponential of the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | log (const Proxy< PT, RT > &proxy) |
Computing the natural logarithm of the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | log2 (const Proxy< PT, RT > &proxy) |
Computing the binary logarithm of the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | log10 (const Proxy< PT, RT > &proxy) |
Computing the common logarithm of the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | sin (const Proxy< PT, RT > &proxy) |
Computing the sine of the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | asin (const Proxy< PT, RT > &proxy) |
Computing the inverse sine of the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | sinh (const Proxy< PT, RT > &proxy) |
Computing the hyperbolic sine of the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | asinh (const Proxy< PT, RT > &proxy) |
Computing the inverse hyperbolic sine of the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | cos (const Proxy< PT, RT > &proxy) |
Computing the cosine of the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | acos (const Proxy< PT, RT > &proxy) |
Computing the inverse cosine of the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | cosh (const Proxy< PT, RT > &proxy) |
Computing the hyperbolic cosine of the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | acosh (const Proxy< PT, RT > &proxy) |
Computing the inverse hyperbolic cosine of the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | tan (const Proxy< PT, RT > &proxy) |
Computing the tangent of the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | atan (const Proxy< PT, RT > &proxy) |
Computing the inverse tangent of the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | tanh (const Proxy< PT, RT > &proxy) |
Computing the hyperbolic tangent of the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | 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) | 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) | 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) | 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) | erf (const Proxy< PT, RT > &proxy) |
Computing the error function of the represented element. More... | |
template<typename PT , typename RT > | |
decltype(auto) | 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) | 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) | 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) | 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) | 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) | 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) | 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 | transpose (const Proxy< PT, RT > &proxy) |
In-place transpose of the represented matrix element. More... | |
template<typename PT , typename RT > | |
void | ctranspose (const Proxy< PT, RT > &proxy) |
In-place conjugate transpose of the represented matrix element. More... | |
template<typename PT , typename RT > | |
void | invert (const Proxy< PT, RT > &proxy) |
In-place inversion of the represented element. More... | |
template<InversionFlag IF, typename PT , typename RT > | |
void | invert (const Proxy< PT, RT > &proxy) |
In-place inversion of the represented element. More... | |
template<bool RF, typename PT , typename RT > | |
bool | isReal (const Proxy< PT, RT > &proxy) |
Returns whether the element represents a real number. More... | |
template<bool RF, typename PT , typename RT > | |
bool | isZero (const Proxy< PT, RT > &proxy) |
Returns whether the represented element is 0. More... | |
template<bool RF, typename PT , typename RT > | |
bool | isOne (const Proxy< PT, RT > &proxy) |
Returns whether the represented element is 1. More... | |
template<typename PT , typename RT > | |
bool | 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 | 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 | 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 | equal (const T &lhs, const Proxy< PT, RT > &rhs) |
Equality comparison between an object of different type and a Proxy object. More... | |
SparseMatrixProxy global functions | |
template<typename PT , typename MT > | |
SparseMatrixProxy< PT, MT >::Iterator | 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 > | |
SparseMatrixProxy< PT, MT >::ConstIterator | 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 > | |
SparseMatrixProxy< PT, MT >::Iterator | 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 > | |
SparseMatrixProxy< PT, MT >::ConstIterator | 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 > | |
size_t | rows (const SparseMatrixProxy< PT, MT > &proxy) |
Returns the current number of rows of the represented matrix. More... | |
template<typename PT , typename MT > | |
size_t | columns (const SparseMatrixProxy< PT, MT > &proxy) |
Returns the current number of columns of the represented matrix. More... | |
template<typename PT , typename MT > | |
size_t | capacity (const SparseMatrixProxy< PT, MT > &proxy) |
Returns the maximum capacity of the represented matrix. More... | |
template<typename PT , typename MT > | |
size_t | 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 > | |
size_t | nonZeros (const SparseMatrixProxy< PT, MT > &proxy) |
Returns the number of non-zero elements in the represented matrix. More... | |
template<typename PT , typename MT > | |
size_t | 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 > | |
void | resize (const SparseMatrixProxy< PT, MT > &proxy, size_t m, size_t n, bool preserve=true) |
Changing the size of the represented matrix. More... | |
template<typename PT , typename MT > | |
void | reset (const SparseMatrixProxy< PT, MT > &proxy) |
Resetting the represented element to the default initial values. More... | |
template<typename PT , typename MT > | |
void | reset (const SparseMatrixProxy< PT, MT > &proxy, size_t i) |
Reset the specified row/column of the represented matrix. More... | |
template<typename PT , typename MT > | |
void | clear (const SparseMatrixProxy< PT, MT > &proxy) |
Clearing the represented matrix. More... | |
SparseVectorProxy global functions | |
template<typename PT , typename VT > | |
SparseVectorProxy< PT, VT >::Iterator | begin (const SparseVectorProxy< PT, VT > &proxy) |
Returns an iterator to the first element of the represented vector. More... | |
template<typename PT , typename VT > | |
SparseVectorProxy< PT, VT >::ConstIterator | cbegin (const SparseVectorProxy< PT, VT > &proxy) |
Returns an iterator to the first element of the represented vector. More... | |
template<typename PT , typename VT > | |
SparseVectorProxy< PT, VT >::Iterator | end (const SparseVectorProxy< PT, VT > &proxy) |
Returns an iterator just past the last element of the represented vector. More... | |
template<typename PT , typename VT > | |
SparseVectorProxy< PT, VT >::ConstIterator | cend (const SparseVectorProxy< PT, VT > &proxy) |
Returns an iterator just past the last element of the represented vector. More... | |
template<typename PT , typename VT > | |
size_t | size (const SparseVectorProxy< PT, VT > &proxy) |
Returns the current size/dimension of the represented vector. More... | |
template<typename PT , typename VT > | |
size_t | capacity (const SparseVectorProxy< PT, VT > &proxy) |
Returns the maximum capacity of the represented vector. More... | |
template<typename PT , typename VT > | |
size_t | nonZeros (const SparseVectorProxy< PT, VT > &proxy) |
Returns the number of non-zero elements in the represented vector. More... | |
template<typename PT , typename VT > | |
void | resize (const SparseVectorProxy< PT, VT > &proxy, size_t n, bool preserve=true) |
Changing the size of the represented vector. More... | |
template<typename PT , typename VT > | |
void | reset (const SparseVectorProxy< PT, VT > &proxy) |
Resetting the represented element to the default initial values. More... | |
template<typename PT , typename VT > | |
void | clear (const SparseVectorProxy< PT, VT > &proxy) |
Clearing the represented element. More... | |
Dense matrix SMP functions | |
template<typename MT1 , bool SO1, typename MT2 , bool SO2> | |
auto | smpAssign (Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs) -> EnableIf_t< IsDenseMatrix_v< MT1 > > |
Default implementation of the SMP assignment of a matrix to a dense matrix. More... | |
template<typename MT1 , bool SO1, typename MT2 , bool SO2> | |
auto | smpAddAssign (Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs) -> EnableIf_t< IsDenseMatrix_v< MT1 > > |
Default implementation of the SMP addition assignment of a matrix to a dense matrix. More... | |
template<typename MT1 , bool SO1, typename MT2 , bool SO2> | |
auto | smpSubAssign (Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs) -> EnableIf_t< IsDenseMatrix_v< MT1 > > |
Default implementation of the SMP subtraction assignment of a matrix to dense matrix. More... | |
template<typename MT1 , bool SO1, typename MT2 , bool SO2> | |
auto | smpSchurAssign (Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs) -> EnableIf_t< IsDenseMatrix_v< MT1 > > |
Default implementation of the SMP Schur product assignment of a matrix to dense matrix. More... | |
Dense vector SMP functions | |
template<typename VT1 , bool TF1, typename VT2 , bool TF2> | |
auto | smpAssign (Vector< VT1, TF1 > &lhs, const Vector< VT2, TF2 > &rhs) -> EnableIf_t< IsDenseVector_v< VT1 > > |
Default implementation of the SMP assignment of a vector to a dense vector. More... | |
template<typename VT1 , bool TF1, typename VT2 , bool TF2> | |
auto | smpAddAssign (Vector< VT1, TF1 > &lhs, const Vector< VT2, TF2 > &rhs) -> EnableIf_t< IsDenseVector_v< VT1 > > |
Default implementation of the SMP addition assignment of a vector to a dense vector. More... | |
template<typename VT1 , bool TF1, typename VT2 , bool TF2> | |
auto | smpSubAssign (Vector< VT1, TF1 > &lhs, const Vector< VT2, TF2 > &rhs) -> EnableIf_t< IsDenseVector_v< VT1 > > |
Default implementation of the SMP subtraction assignment of a vector to a dense vector. More... | |
template<typename VT1 , bool TF1, typename VT2 , bool TF2> | |
auto | smpMultAssign (Vector< VT1, TF1 > &lhs, const Vector< VT2, TF2 > &rhs) -> EnableIf_t< IsDenseVector_v< VT1 > > |
Default implementation of the SMP multiplication assignment of a vector to a dense vector. More... | |
template<typename VT1 , bool TF1, typename VT2 , bool TF2> | |
auto | smpDivAssign (Vector< VT1, TF1 > &lhs, const Vector< VT2, TF2 > &rhs) -> EnableIf_t< IsDenseVector_v< VT1 > > |
Default implementation of the SMP division assignment of a vector to a dense vector. More... | |
SMP utility functions | |
BLAZE_ALWAYS_INLINE size_t | getNumThreads () |
Returns the number of threads used for thread parallel operations. More... | |
BLAZE_ALWAYS_INLINE void | setNumThreads (size_t number) |
Sets the number of threads to be used for thread parallel operations. More... | |
BLAZE_ALWAYS_INLINE void | shutDownThreads () |
Provides a reliable shutdown of C++11 threads for Visual Studio compilers. More... | |
ParallelSection functions | |
bool | isParallelSectionActive () |
Returns whether a parallel section is active or not. More... | |
SerialSection functions | |
bool | isSerialSectionActive () |
Returns whether a serial section is active or not. More... | |
CompressedMatrix operators | |
template<typename Type , bool SO> | |
void | reset (CompressedMatrix< Type, SO > &m) |
Resetting the given compressed matrix. More... | |
template<typename Type , bool SO> | |
void | reset (CompressedMatrix< Type, SO > &m, size_t i) |
Reset the specified row/column of the given compressed matrix. More... | |
template<typename Type , bool SO> | |
void | clear (CompressedMatrix< Type, SO > &m) |
Clearing the given compressed matrix. More... | |
template<bool RF, typename Type , bool SO> | |
bool | isDefault (const CompressedMatrix< Type, SO > &m) |
Returns whether the given compressed matrix is in default state. More... | |
template<typename Type , bool SO> | |
bool | isIntact (const CompressedMatrix< Type, SO > &m) |
Returns whether the invariants of the given compressed matrix are intact. More... | |
template<typename Type , bool SO> | |
void | swap (CompressedMatrix< Type, SO > &a, CompressedMatrix< Type, SO > &b) noexcept |
Swapping the contents of two compressed matrices. More... | |
CompressedVector operators | |
template<typename Type , bool TF> | |
void | reset (CompressedVector< Type, TF > &v) |
Resetting the given compressed vector. More... | |
template<typename Type , bool TF> | |
void | clear (CompressedVector< Type, TF > &v) |
Clearing the given compressed vector. More... | |
template<bool RF, typename Type , bool TF> | |
bool | isDefault (const CompressedVector< Type, TF > &v) |
Returns whether the given compressed vector is in default state. More... | |
template<typename Type , bool TF> | |
bool | isIntact (const CompressedVector< Type, TF > &v) noexcept |
Returns whether the invariants of the given compressed vector are intact. More... | |
template<typename Type , bool TF> | |
void | swap (CompressedVector< Type, TF > &a, CompressedVector< Type, TF > &b) noexcept |
Swapping the contents of two compressed vectors. More... | |
IdentityMatrix operators | |
template<typename Type , bool SO> | |
constexpr void | reset (IdentityMatrix< Type, SO > &m) noexcept |
Resetting the given identity matrix. More... | |
template<typename Type , bool SO> | |
constexpr void | reset (IdentityMatrix< Type, SO > &m, size_t i) noexcept |
Reset the specified row/column of the given identity matrix. More... | |
template<typename Type , bool SO> | |
constexpr void | clear (IdentityMatrix< Type, SO > &m) noexcept |
Clearing the given identity matrix. More... | |
template<bool RF, typename Type , bool SO> | |
constexpr bool | isDefault (const IdentityMatrix< Type, SO > &m) noexcept |
Returns whether the given identity matrix is in default state. More... | |
template<typename Type , bool SO> | |
constexpr bool | isIntact (const IdentityMatrix< Type, SO > &m) noexcept |
Returns whether the invariants of the given identity matrix are intact. More... | |
template<typename Type , bool SO> | |
constexpr void | swap (IdentityMatrix< Type, SO > &a, IdentityMatrix< Type, SO > &b) noexcept |
Swapping the contents of two identity matrices. More... | |
MatrixAccessProxy global functions | |
template<typename MT > | |
void | reset (const MatrixAccessProxy< MT > &proxy) |
Resetting the represented element to the default initial values. More... | |
template<typename MT > | |
void | clear (const MatrixAccessProxy< MT > &proxy) |
Clearing the represented element. More... | |
template<bool RF, typename MT > | |
bool | isDefault (const MatrixAccessProxy< MT > &proxy) |
Returns whether the represented element is in default state. More... | |
template<bool RF, typename MT > | |
bool | isReal (const MatrixAccessProxy< MT > &proxy) |
Returns whether the matrix element represents a real number. More... | |
template<bool RF, typename MT > | |
bool | isZero (const MatrixAccessProxy< MT > &proxy) |
Returns whether the represented element is 0. More... | |
template<bool RF, typename MT > | |
bool | isOne (const MatrixAccessProxy< MT > &proxy) |
Returns whether the represented element is 1. More... | |
template<typename MT > | |
bool | isnan (const MatrixAccessProxy< MT > &proxy) |
Returns whether the represented element is not a number. More... | |
template<typename MT > | |
void | swap (const MatrixAccessProxy< MT > &a, const MatrixAccessProxy< MT > &b) noexcept |
Swapping the contents of two access proxies. More... | |
template<typename MT , typename T > | |
void | swap (const MatrixAccessProxy< MT > &a, T &b) noexcept |
Swapping the contents of an access proxy with another element. More... | |
template<typename T , typename MT > | |
void | swap (T &a, const MatrixAccessProxy< MT > &b) noexcept |
Swapping the contents of an access proxy with another element. More... | |
SparseMatrix operators | |
template<typename MT , bool SO, typename ST > | |
auto | operator *= (SparseMatrix< MT, SO > &mat, ST scalar) -> EnableIf_t< IsNumeric_v< ST >, MT & > |
Multiplication assignment operator for the multiplication of a sparse matrix and a scalar value ( ![]() | |
template<typename MT , bool SO, typename ST > | |
auto | operator *= (SparseMatrix< MT, SO > &&mat, ST scalar) -> EnableIf_t< IsNumeric_v< ST >, MT & > |
Multiplication assignment operator for the multiplication of a temporary sparse matrix and a scalar value ( ![]() | |
template<typename MT , bool SO, typename ST > | |
auto | operator/= (SparseMatrix< MT, SO > &mat, ST scalar) -> EnableIf_t< IsNumeric_v< ST >, MT & > |
Division assignment operator for the division of a sparse matrix by a scalar value ( ![]() | |
template<typename MT , bool SO, typename ST > | |
auto | operator/= (SparseMatrix< MT, SO > &&mat, ST scalar) -> EnableIf_t< IsNumeric_v< ST >, MT & > |
Division assignment operator for the division of a temporary sparse matrix by a scalar value ( ![]() | |
SparseMatrix functions | |
template<typename MT , bool SO> | |
bool | isnan (const SparseMatrix< MT, SO > &sm) |
Checks the given sparse matrix for not-a-number elements. More... | |
template<bool RF, typename MT , bool SO> | |
bool | isSymmetric (const SparseMatrix< MT, SO > &sm) |
Checks if the given sparse matrix is symmetric. More... | |
template<bool RF, typename MT , bool SO> | |
bool | isHermitian (const SparseMatrix< MT, SO > &sm) |
Checks if the given sparse matrix is Hermitian. More... | |
template<bool RF, typename MT , bool SO> | |
bool | isUniform (const SparseMatrix< MT, SO > &sm) |
Checks if the given sparse matrix is a uniform matrix. More... | |
template<bool RF, typename MT , bool SO> | |
bool | isZero (const SparseMatrix< MT, SO > &sm) |
Checks if the given sparse matrix is a zero matrix. More... | |
template<bool RF, typename MT , bool SO> | |
bool | isLower (const SparseMatrix< MT, SO > &sm) |
Checks if the given sparse matrix is a lower triangular matrix. More... | |
template<bool RF, typename MT , bool SO> | |
bool | isUniLower (const SparseMatrix< MT, SO > &sm) |
Checks if the given sparse matrix is a lower unitriangular matrix. More... | |
template<bool RF, typename MT , bool SO> | |
bool | isStrictlyLower (const SparseMatrix< MT, SO > &sm) |
Checks if the given sparse matrix is a strictly lower triangular matrix. More... | |
template<bool RF, typename MT , bool SO> | |
bool | isUpper (const SparseMatrix< MT, SO > &sm) |
Checks if the given sparse matrix is an upper triangular matrix. More... | |
template<bool RF, typename MT , bool SO> | |
bool | isUniUpper (const SparseMatrix< MT, SO > &sm) |
Checks if the given sparse matrix is an upper unitriangular matrix. More... | |
template<bool RF, typename MT , bool SO> | |
bool | isStrictlyUpper (const SparseMatrix< MT, SO > &sm) |
Checks if the given sparse matrix is a strictly upper triangular matrix. More... | |
template<bool RF, typename MT , bool SO> | |
bool | isDiagonal (const SparseMatrix< MT, SO > &sm) |
Checks if the give sparse matrix is diagonal. More... | |
template<bool RF, typename MT , bool SO> | |
bool | isIdentity (const SparseMatrix< MT, SO > &sm) |
Checks if the give sparse matrix is an identity matrix. More... | |
SparseVector operators | |
template<typename VT , bool TF, typename ST > | |
auto | operator *= (SparseVector< VT, TF > &vec, ST scalar) -> EnableIf_t< IsNumeric_v< ST >, VT & > |
Multiplication assignment operator for the multiplication of a sparse vector and a scalar value ( ![]() | |
template<typename VT , bool TF, typename ST > | |
auto | operator *= (SparseVector< VT, TF > &&vec, ST scalar) -> EnableIf_t< IsNumeric_v< ST >, VT & > |
Multiplication assignment operator for the multiplication of a temporary sparse vector and a scalar ( ![]() | |
template<typename VT , bool TF, typename ST > | |
auto | operator/= (SparseVector< VT, TF > &vec, ST scalar) -> EnableIf_t< IsNumeric_v< ST >, VT & > |
Division assignment operator for the division of a sparse vector by a scalar value ( ![]() | |
template<typename VT , bool TF, typename ST > | |
auto | operator/= (SparseVector< VT, TF > &&vec, ST scalar) -> EnableIf_t< IsNumeric_v< ST >, VT & > |
Division assignment operator for the division of a temporary sparse vector by a scalar value ( ![]() | |
SparseVector functions | |
template<typename VT , bool TF> | |
bool | isnan (const SparseVector< VT, TF > &sv) |
Checks the given sparse vector for not-a-number elements. More... | |
template<bool RF, typename VT , bool TF> | |
bool | isUniform (const SparseVector< VT, TF > &sv) |
Checks if the given sparse vector is a uniform vector. More... | |
template<bool RF, typename VT , bool TF> | |
bool | isZero (const SparseVector< VT, TF > &sv) |
Checks if the given sparse vector is a zero vector. More... | |
VectorAccessProxy global functions | |
template<typename VT > | |
void | reset (const VectorAccessProxy< VT > &proxy) |
Resetting the represented element to the default initial values. More... | |
template<typename VT > | |
void | clear (const VectorAccessProxy< VT > &proxy) |
Clearing the represented element. More... | |
template<bool RF, typename VT > | |
bool | isDefault (const VectorAccessProxy< VT > &proxy) |
Returns whether the represented element is in default state. More... | |
template<bool RF, typename VT > | |
bool | isReal (const VectorAccessProxy< VT > &proxy) |
Returns whether the vector element represents a real number. More... | |
template<bool RF, typename VT > | |
bool | isZero (const VectorAccessProxy< VT > &proxy) |
Returns whether the represented element is 0. More... | |
template<bool RF, typename VT > | |
bool | isOne (const VectorAccessProxy< VT > &proxy) |
Returns whether the represented element is 1. More... | |
template<typename VT > | |
bool | isnan (const VectorAccessProxy< VT > &proxy) |
Returns whether the represented element is not a number. More... | |
template<typename VT > | |
void | swap (const VectorAccessProxy< VT > &a, const VectorAccessProxy< VT > &b) noexcept |
Swapping the contents of two access proxies. More... | |
template<typename VT , typename T > | |
void | swap (const VectorAccessProxy< VT > &a, T &b) noexcept |
Swapping the contents of an access proxy with another element. More... | |
template<typename T , typename VT > | |
void | swap (T &a, const VectorAccessProxy< VT > &b) noexcept |
Swapping the contents of an access proxy with another element. More... | |
ZeroMatrix operators | |
template<typename Type , bool SO> | |
constexpr void | reset (ZeroMatrix< Type, SO > &m) noexcept |
Resetting the given zero matrix. More... | |
template<typename Type , bool SO> | |
constexpr void | reset (ZeroMatrix< Type, SO > &m, size_t i) noexcept |
Reset the specified row/column of the given zero matrix. More... | |
template<typename Type , bool SO> | |
constexpr void | clear (ZeroMatrix< Type, SO > &m) noexcept |
Clearing the given zero matrix. More... | |
template<bool RF, typename Type , bool SO> | |
constexpr bool | isDefault (const ZeroMatrix< Type, SO > &m) noexcept |
Returns whether the given zero matrix is in default state. More... | |
template<typename Type , bool SO> | |
constexpr bool | isIntact (const ZeroMatrix< Type, SO > &m) noexcept |
Returns whether the invariants of the given zero matrix are intact. More... | |
template<typename Type , bool SO> | |
constexpr void | swap (ZeroMatrix< Type, SO > &a, ZeroMatrix< Type, SO > &b) noexcept |
Swapping the contents of two zero matrices. More... | |
ZeroVector operators | |
template<typename Type , bool TF> | |
constexpr void | reset (ZeroVector< Type, TF > &v) noexcept |
Resetting the given zero vector. More... | |
template<typename Type , bool TF> | |
constexpr void | clear (ZeroVector< Type, TF > &v) noexcept |
Clearing the given zero vector. More... | |
template<bool RF, typename Type , bool TF> | |
constexpr bool | isDefault (const ZeroVector< Type, TF > &v) noexcept |
Returns whether the given zero vector is in default state. More... | |
template<typename Type , bool TF> | |
constexpr bool | isIntact (const ZeroVector< Type, TF > &v) noexcept |
Returns whether the invariants of the given zero vector are intact. More... | |
template<typename Type , bool TF> | |
constexpr void | swap (ZeroVector< Type, TF > &a, ZeroVector< Type, TF > &b) noexcept |
Swapping the contents of two zero vectors. More... | |
Vector functions | |
template<typename VT , bool TF> | |
bool | isUniform (const Vector< VT, TF > &v) |
Checks if the given vector is a uniform vector. More... | |
template<typename T1 , typename T2 > | |
decltype(auto) | inner (const Vector< T1, false > &lhs, const Vector< T2, false > &rhs) |
Multiplication operator for the scalar product (dot/inner product) of two vectors ( ![]() | |
template<typename T1 , typename T2 > | |
decltype(auto) | inner (const Vector< T1, false > &lhs, const Vector< T2, true > &rhs) |
Multiplication operator for the scalar product (dot/inner product) of two vectors ( ![]() | |
template<typename T1 , typename T2 > | |
decltype(auto) | inner (const Vector< T1, true > &lhs, const Vector< T2, false > &rhs) |
Multiplication operator for the scalar product (dot/inner product) of two vectors ( ![]() | |
template<typename T1 , typename T2 > | |
decltype(auto) | inner (const Vector< T1, true > &lhs, const Vector< T2, true > &rhs) |
Multiplication operator for the scalar product (dot/inner product) of two vectors ( ![]() | |
template<typename T1 , bool TF1, typename T2 , bool TF2> | |
decltype(auto) | dot (const Vector< T1, TF1 > &lhs, const Vector< T2, TF2 > &rhs) |
Multiplication operator for the scalar product (dot/inner product) of two vectors ( ![]() | |
template<typename T1 , bool TF1, typename T2 , bool TF2> | |
decltype(auto) | operator, (const Vector< T1, TF1 > &lhs, const Vector< T2, TF2 > &rhs) |
Multiplication operator for the scalar product (dot/inner product) of two vectors ( ![]() | |
template<typename T1 , typename T2 > | |
decltype(auto) | outer (const Vector< T1, false > &lhs, const Vector< T2, false > &rhs) |
Multiplication operator for the outer product of two vectors ( ![]() | |
template<typename T1 , typename T2 > | |
decltype(auto) | outer (const Vector< T1, false > &lhs, const Vector< T2, true > &rhs) |
Multiplication operator for the outer product of two vectors ( ![]() | |
template<typename T1 , typename T2 > | |
decltype(auto) | outer (const Vector< T1, true > &lhs, const Vector< T2, false > &rhs) |
Multiplication operator for the outer product of two vectors ( ![]() | |
template<typename T1 , typename T2 > | |
decltype(auto) | outer (const Vector< T1, true > &lhs, const Vector< T2, true > &rhs) |
Multiplication operator for the outer product of two vectors ( ![]() | |
template<typename VT , bool TF> | |
decltype(auto) | reverse (const Vector< VT, TF > &v) |
Reverse the elements of a vector. More... | |
Vector operators | |
template<typename VT , bool TF> | |
std::ostream & | operator<< (std::ostream &os, const Vector< VT, TF > &v) |
Global output operator for dense and sparse vectors. More... | |
AlignedAllocator operators | |
template<typename T1 , typename T2 > | |
bool | operator== (const AlignedAllocator< T1 > &lhs, const AlignedAllocator< T2 > &rhs) noexcept |
Equality comparison between two AlignedAllocator objects. More... | |
template<typename T1 , typename T2 > | |
bool | operator!= (const AlignedAllocator< T1 > &lhs, const AlignedAllocator< T2 > &rhs) noexcept |
Inequality comparison between two AlignedAllocator objects. More... | |
Checked delete operations | |
template<typename T > | |
void | checkedDelete (T *ptr) |
Type-checked delete operation. More... | |
template<typename T > | |
void | checkedArrayDelete (T *ptr) |
Type-checked delete [] operation. More... | |
Numeric cast operators | |
template<typename To , typename From > | |
To | numeric_cast (From from) |
Checked conversion of values of numeric type. More... | |
Pointer cast operators | |
template<typename To , typename From > | |
To * | static_pointer_cast (From *ptr) |
Static cast for pointer types. More... | |
template<typename To , typename From > | |
To * | dynamic_pointer_cast (From *ptr) |
Dynamic cast for pointer types. More... | |
template<typename To , typename From > | |
To * | const_pointer_cast (From *ptr) |
Const cast for pointer types. More... | |
template<typename To , typename From > | |
To * | reinterpret_pointer_cast (From *ptr) |
Reinterpret cast for pointer types. More... | |
Smart pointer cast operators | |
template<typename To , template< typename > class S, typename From > | |
S< To > | static_pointer_cast (S< From > ptr) |
Static cast for smart pointers. More... | |
template<typename To , template< typename > class S, typename From > | |
S< To > | dynamic_pointer_cast (S< From > ptr) |
Dynamic cast for smart pointers. More... | |
template<typename To , template< typename > class S, typename From > | |
S< To > | const_pointer_cast (S< From > ptr) |
Const cast for smart pointers. More... | |
template<typename To , template< typename > class S, typename From > | |
S< To > | reinterpret_pointer_cast (S< From > ptr) |
Reinterpret cast for smart pointers. More... | |
Random number functions | |
template<typename T > | |
T | rand () |
Random number function. More... | |
template<typename T , typename... Args> | |
T | rand (Args &&... args) |
Random number function. More... | |
template<typename T > | |
void | randomize (T &&value) |
Randomization of a given variable. More... | |
template<typename T , typename... Args> | |
void | randomize (T &&value, Args &&... args) |
Randomization of a given variable. More... | |
uint32_t | defaultSeed () |
Returns the default random seed. More... | |
uint32_t | getSeed () |
Returns the current seed of the random number generator. More... | |
void | setSeed (uint32_t seed) |
Setting the seed of the random number generator. More... | |
SmallArray operators | |
template<typename T1 , size_t N1, typename A1 , typename T2 , size_t N2, typename A2 > | |
bool | operator== (const SmallArray< T1, N1, A1 > &lhs, const SmallArray< T2, N2, A2 > &rhs) |
Equality operator for the comparison of two dense arrays. More... | |
template<typename T1 , size_t N1, typename A1 , typename T2 , size_t N2, typename A2 > | |
bool | operator!= (const SmallArray< T1, N1, A1 > &lhs, const SmallArray< T2, N2, A2 > &rhs) |
Inequality operator for the comparison of two dense arrays. More... | |
template<typename T , size_t N, typename A > | |
SmallArray< T, N, A >::Iterator | begin (SmallArray< T, N, A > &sa) |
Returns an iterator to the first element of the given small array. More... | |
template<typename T , size_t N, typename A > | |
SmallArray< T, N, A >::ConstIterator | begin (const SmallArray< T, N, A > &sa) |
Returns an iterator to the first element of the given small array. More... | |
template<typename T , size_t N, typename A > | |
SmallArray< T, N, A >::ConstIterator | cbegin (const SmallArray< T, N, A > &sa) |
Returns an iterator to the first element of the given small array. More... | |
template<typename T , size_t N, typename A > | |
SmallArray< T, N, A >::Iterator | end (SmallArray< T, N, A > &sa) |
Returns an iterator just past the last element of the given small array. More... | |
template<typename T , size_t N, typename A > | |
SmallArray< T, N, A >::ConstIterator | end (const SmallArray< T, N, A > &sa) |
Returns an iterator just past the last element of the given small array. More... | |
template<typename T , size_t N, typename A > | |
SmallArray< T, N, A >::ConstIterator | cend (const SmallArray< T, N, A > &sa) |
Returns an iterator just past the last element of the given small array. More... | |
template<typename T , size_t N, typename A > | |
void | clear (SmallArray< T, N, A > &sa) |
Clearing the given small array. More... | |
template<typename T , size_t N, typename A > | |
void | swap (SmallArray< T, N, A > &a, SmallArray< T, N, A > &b) noexcept(IsNothrowMoveConstructible_v< T >) |
Swapping the contents of two small arrays. More... | |
Time functions | |
std::string | getDate () |
Creating a formated date string in the form YYYY-MM-DD. More... | |
std::string | getTime () |
Creating a formated time and date string. More... | |
double | getWcTime () |
Returns the current wall clock time in seconds. More... | |
double | getCpuTime () |
Returns the current CPU time in seconds. More... | |
UnsignedValue operators | |
template<typename T1 , typename T2 > | |
bool | operator== (const UnsignedValue< T1 > &lhs, const UnsignedValue< T2 > &rhs) |
Equality comparison between two UnsignedValue objects. More... | |
template<typename T1 , typename T2 > | |
bool | operator!= (const UnsignedValue< T1 > &lhs, const UnsignedValue< T2 > &rhs) |
Inequality comparison between two UnsignedValue objects. More... | |
template<typename T1 , typename T2 > | |
bool | operator< (const UnsignedValue< T1 > &lhs, const UnsignedValue< T2 > &rhs) |
Less-than comparison between two UnsignedValue objects. More... | |
template<typename T1 , typename T2 > | |
bool | operator> (const UnsignedValue< T1 > &lhs, const UnsignedValue< T2 > &rhs) |
Greater-than comparison between two UnsignedValue objects. More... | |
template<typename T1 , typename T2 > | |
bool | operator<= (const UnsignedValue< T1 > &lhs, const UnsignedValue< T2 > &rhs) |
Less-or-equal-than comparison between two UnsignedValue objects. More... | |
template<typename T1 , typename T2 > | |
bool | operator>= (const UnsignedValue< T1 > &lhs, const UnsignedValue< T2 > &rhs) |
Greater-or-equal-than comparison between two UnsignedValue objects. More... | |
template<typename T > | |
std::ostream & | operator<< (std::ostream &os, const UnsignedValue< T > &uv) |
Global output operator for the UnsignedValue wrapper. More... | |
template<typename T > | |
std::istream & | operator>> (std::istream &is, UnsignedValue< T > &uv) |
Global input operator for the UnsignedValue wrapper. More... | |
Variables | |
constexpr Accuracy | 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 | 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 | 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 | 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 | 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 size_t | rowwise = 1UL |
Reduction flag for row-wise reduction operations. More... | |
constexpr size_t | columnwise = 0UL |
Reduction flag for column-wise reduction operations. More... | |
constexpr bool | strict = false |
Relaxation flag for strict semantics. More... | |
constexpr bool | relaxed = true |
Relaxation flag for relaxed semantics. More... | |
constexpr bool | rowMajor = false |
Storage order flag for row-major matrices. More... | |
constexpr bool | columnMajor = true |
Storage order flag for column-major matrices. More... | |
constexpr bool | columnVector = false |
Transpose flag for column vectors. More... | |
constexpr bool | rowVector = true |
Transpose flag for row vectors. More... | |
template<typename T > | |
constexpr bool | HasAbs_v = HasAbs<T>::value |
Auxiliary variable template for the HasAbs type trait.The HasAbs_v variable template provides a convenient shortcut to access the nested value of the HasAbs class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | HasAcos_v = HasAcos<T>::value |
Auxiliary variable template for the HasAcos type trait.The HasAcos_v variable template provides a convenient shortcut to access the nested value of the HasAcos class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | HasAcosh_v = HasAcosh<T>::value |
Auxiliary variable template for the HasAcosh type trait.The HasAcosh_v variable template provides a convenient shortcut to access the nested value of the HasAcosh class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T1 , typename T2 > | |
constexpr bool | HasAdd_v = HasAdd<T1,T2>::value |
Auxiliary variable template for the HasAdd type trait.The HasAdd_v variable template provides a convenient shortcut to access the nested value of the HasAdd class template. For instance, given the types T1 and T2 the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | HasAsin_v = HasAsin<T>::value |
Auxiliary variable template for the HasAsin type trait.The HasAsin_v variable template provides a convenient shortcut to access the nested value of the HasAsin class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | HasAsinh_v = HasAsinh<T>::value |
Auxiliary variable template for the HasAsinh type trait.The HasAsinh_v variable template provides a convenient shortcut to access the nested value of the HasAsinh class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | HasAtan_v = HasAtan<T>::value |
Auxiliary variable template for the HasAtan type trait.The HasAtan_v variable template provides a convenient shortcut to access the nested value of the HasAtan class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T1 , typename T2 > | |
constexpr bool | HasAtan2_v = HasAtan2<T1,T2>::value |
Auxiliary variable template for the HasAtan2 type trait.The HasAtan2_v variable template provides a convenient shortcut to access the nested value of the HasAtan2 class template. For instance, given the types T1 and T2 the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | HasAtanh_v = HasAtanh<T>::value |
Auxiliary variable template for the HasAtanh type trait.The HasAtanh_v variable template provides a convenient shortcut to access the nested value of the HasAtanh class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | HasCbrt_v = HasCbrt<T>::value |
Auxiliary variable template for the HasCbrt type trait.The HasCbrt_v variable template provides a convenient shortcut to access the nested value of the HasCbrt class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | HasCeil_v = HasCeil<T>::value |
Auxiliary variable template for the HasCeil type trait.The HasCeil_v variable template provides a convenient shortcut to access the nested value of the HasCeil class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | HasClamp_v = HasClamp<T>::value |
Auxiliary variable template for the HasClamp type trait.The HasClamp_v variable template provides a convenient shortcut to access the nested value of the HasClamp class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | HasConj_v = HasConj<T>::value |
Auxiliary variable template for the HasConj type trait.The HasConj_v variable template provides a convenient shortcut to access the nested value of the HasConj class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | HasConstDataAccess_v = HasConstDataAccess<T>::value |
Auxiliary variable template for the HasConstDataAccess type trait.The HasConstDataAccess_v variable template provides a convenient shortcut to access the nested value of the HasConstDataAccess class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | HasCos_v = HasCos<T>::value |
Auxiliary variable template for the HasCos type trait.The HasCos_v variable template provides a convenient shortcut to access the nested value of the HasCos class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | HasCosh_v = HasCosh<T>::value |
Auxiliary variable template for the HasCosh type trait.The HasCosh_v variable template provides a convenient shortcut to access the nested value of the HasCosh class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T1 , typename T2 > | |
constexpr bool | HasDiv_v = HasDiv<T1,T2>::value |
Auxiliary variable template for the HasDiv type trait.The HasDiv_v variable template provides a convenient shortcut to access the nested value of the HasDiv class template. For instance, given the types T1 and T2 the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | HasErf_v = HasErf<T>::value |
Auxiliary variable template for the HasErf type trait.The HasErf_v variable template provides a convenient shortcut to access the nested value of the HasErf class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | HasErfc_v = HasErfc<T>::value |
Auxiliary variable template for the HasErfc type trait.The HasErfc_v variable template provides a convenient shortcut to access the nested value of the HasErfc class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | HasExp_v = HasExp<T>::value |
Auxiliary variable template for the HasExp type trait.The HasExp_v variable template provides a convenient shortcut to access the nested value of the HasExp class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | HasExp10_v = HasExp10<T>::value |
Auxiliary variable template for the HasExp10 type trait.The HasExp10_v variable template provides a convenient shortcut to access the nested value of the HasExp10 class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | HasExp2_v = HasExp2<T>::value |
Auxiliary variable template for the HasExp2 type trait.The HasExp2_v variable template provides a convenient shortcut to access the nested value of the HasExp2 class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | HasFloor_v = HasFloor<T>::value |
Auxiliary variable template for the HasFloor type trait.The HasFloor_v variable template provides a convenient shortcut to access the nested value of the HasFloor class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T1 , typename T2 > | |
constexpr bool | HasHypot_v = HasHypot<T1,T2>::value |
Auxiliary variable template for the HasHypot type trait.The HasHypot_v variable template provides a convenient shortcut to access the nested value of the HasHypot class template. For instance, given the types T1 and T2 the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | HasImag_v = HasImag<T>::value |
Auxiliary variable template for the HasImag type trait.The HasImag_v variable template provides a convenient shortcut to access the nested value of the HasImag class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | HasInvCbrt_v = HasInvCbrt<T>::value |
Auxiliary variable template for the HasInvCbrt type trait.The HasInvCbrt_v variable template provides a convenient shortcut to access the nested value of the HasInvCbrt class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | HasInvSqrt_v = HasInvSqrt<T>::value |
Auxiliary variable template for the HasInvSqrt type trait.The HasInvSqrt_v variable template provides a convenient shortcut to access the nested value of the HasInvSqrt class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | HasLog_v = HasLog<T>::value |
Auxiliary variable template for the HasLog type trait.The HasLog_v variable template provides a convenient shortcut to access the nested value of the HasLog class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | HasLog10_v = HasLog10<T>::value |
Auxiliary variable template for the HasLog10 type trait.The HasLog10_v variable template provides a convenient shortcut to access the nested value of the HasLog10 class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | HasLog2_v = HasLog2<T>::value |
Auxiliary variable template for the HasLog2 type trait.The HasLog2_v variable template provides a convenient shortcut to access the nested value of the HasLog2 class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T1 , typename T2 > | |
constexpr bool | HasMax_v = HasMax<T1,T2>::value |
Auxiliary variable template for the HasMax type trait.The HasMax_v variable template provides a convenient shortcut to access the nested value of the HasMax class template. For instance, given the types T1 and T2 the following two statements are identical: More... | |
template<typename T1 , typename T2 > | |
constexpr bool | HasMin_v = HasMin<T1,T2>::value |
Auxiliary variable template for the HasMin type trait.The HasMin_v variable template provides a convenient shortcut to access the nested value of the HasMin class template. For instance, given the types T1 and T2 the following two statements are identical: More... | |
template<typename T1 , typename T2 > | |
constexpr bool | HasMult_v = HasMult<T1,T2>::value |
Auxiliary variable template for the HasMult type trait.The HasMult_v variable template provides a convenient shortcut to access the nested value of the HasMult class template. For instance, given the types T1 and T2 the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | HasMutableDataAccess_v = HasMutableDataAccess<T>::value |
Auxiliary variable template for the HasMutableDataAccess type trait.The HasMutableDataAccess_v variable template provides a convenient shortcut to access the nested value of the HasMutableDataAccess class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T1 , typename T2 > | |
constexpr bool | HasPow_v = HasPow<T1,T2>::value |
Auxiliary variable template for the HasPow type trait.The HasPow_v variable template provides a convenient shortcut to access the nested value of the HasPow class template. For instance, given the types T1 and T2 the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | HasReal_v = HasReal<T>::value |
Auxiliary variable template for the HasReal type trait.The HasReal_v variable template provides a convenient shortcut to access the nested value of the HasReal class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | HasRound_v = HasRound<T>::value |
Auxiliary variable template for the HasRound type trait.The HasRound_v variable template provides a convenient shortcut to access the nested value of the HasRound class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | HasSign_v = HasSign<T>::value |
Auxiliary variable template for the HasSign type trait.The HasSign_v variable template provides a convenient shortcut to access the nested value of the HasSign class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | HasSIMDAbs_v = HasSIMDAbs<T>::value |
Auxiliary variable template for the HasSIMDAbs type trait.The HasSIMDAbs_v variable template provides a convenient shortcut to access the nested value of the HasSIMDAbs class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | HasSIMDAcos_v = HasSIMDAcos<T>::value |
Auxiliary variable template for the HasSIMDAcos type trait.The HasSIMDAcos_v variable template provides a convenient shortcut to access the nested value of the HasSIMDAcos class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | HasSIMDAcosh_v = HasSIMDAcosh<T>::value |
Auxiliary variable template for the HasSIMDAcosh type trait.The HasSIMDAcosh_v variable template provides a convenient shortcut to access the nested value of the HasSIMDAcosh class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T1 , typename T2 > | |
constexpr bool | HasSIMDAdd_v = HasSIMDAdd<T1,T2>::value |
Auxiliary variable template for the HasSIMDAdd type trait.The HasSIMDAdd_v variable template provides a convenient shortcut to access the nested value of the HasSIMDAdd class template. For instance, given the types T1 and T2 the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | HasSIMDAsin_v = HasSIMDAsin<T>::value |
Auxiliary variable template for the HasSIMDAsin type trait.The HasSIMDAsin_v variable template provides a convenient shortcut to access the nested value of the HasSIMDAsin class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | HasSIMDAsinh_v = HasSIMDAsinh<T>::value |
Auxiliary variable template for the HasSIMDAsinh type trait.The HasSIMDAsinh_v variable template provides a convenient shortcut to access the nested value of the HasSIMDAsinh class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | HasSIMDAtan_v = HasSIMDAtan<T>::value |
Auxiliary variable template for the HasSIMDAtan type trait.The HasSIMDAtan_v variable template provides a convenient shortcut to access the nested value of the HasSIMDAtan class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T1 , typename T2 > | |
constexpr bool | HasSIMDAtan2_v = HasSIMDAtan2<T1,T2>::value |
Auxiliary variable template for the HasSIMDAtan2 type trait.The HasSIMDAtan2_v variable template provides a convenient shortcut to access the nested value of the HasSIMDAtan2 class template. For instance, given the types T1 and T2 the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | HasSIMDAtanh_v = HasSIMDAtanh<T>::value |
Auxiliary variable template for the HasSIMDAtanh type trait.The HasSIMDAtanh_v variable template provides a convenient shortcut to access the nested value of the HasSIMDAtanh class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T1 , typename T2 > | |
constexpr bool | HasSIMDBitand_v = HasSIMDBitand<T1,T2>::value |
Auxiliary variable template for the HasSIMDBitand type trait.The HasSIMDBitand_v variable template provides a convenient shortcut to access the nested value of the HasSIMDBitand class template. For instance, given the types T1 and T2 the following two statements are identical: More... | |
template<typename T1 , typename T2 > | |
constexpr bool | HasSIMDBitor_v = HasSIMDBitor<T1,T2>::value |
Auxiliary variable template for the HasSIMDBitor type trait.The HasSIMDBitor_v variable template provides a convenient shortcut to access the nested value of the HasSIMDBitor class template. For instance, given the types T1 and T2 the following two statements are identical: More... | |
template<typename T1 , typename T2 > | |
constexpr bool | HasSIMDBitxor_v = HasSIMDBitxor<T1,T2>::value |
Auxiliary variable template for the HasSIMDBitxor type trait.The HasSIMDBitxor_v variable template provides a convenient shortcut to access the nested value of the HasSIMDBitxor class template. For instance, given the types T1 and T2 the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | HasSIMDCbrt_v = HasSIMDCbrt<T>::value |
Auxiliary variable template for the HasSIMDCbrt type trait.The HasSIMDCbrt_v variable template provides a convenient shortcut to access the nested value of the HasSIMDCbrt class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | HasSIMDCeil_v = HasSIMDCeil<T>::value |
Auxiliary variable template for the HasSIMDCeil type trait.The HasSIMDCeil_v variable template provides a convenient shortcut to access the nested value of the HasSIMDCeil class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | HasSIMDConj_v = HasSIMDConj<T>::value |
Auxiliary variable template for the HasSIMDConj type trait.The HasSIMDConj_v variable template provides a convenient shortcut to access the nested value of the HasSIMDConj class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | HasSIMDCos_v = HasSIMDCos<T>::value |
Auxiliary variable template for the HasSIMDCos type trait.The HasSIMDCos_v variable template provides a convenient shortcut to access the nested value of the HasSIMDCos class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | HasSIMDCosh_v = HasSIMDCosh<T>::value |
Auxiliary variable template for the HasSIMDCosh type trait.The HasSIMDCosh_v variable template provides a convenient shortcut to access the nested value of the HasSIMDCosh class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T1 , typename T2 > | |
constexpr bool | HasSIMDDiv_v = HasSIMDDiv<T1,T2>::value |
Auxiliary variable template for the HasSIMDDiv type trait.The HasSIMDDiv_v variable template provides a convenient shortcut to access the nested value of the HasSIMDDiv class template. For instance, given the types T1 and T2 the following two statements are identical: More... | |
template<typename T1 , typename T2 > | |
constexpr bool | HasSIMDEqual_v = HasSIMDEqual<T1,T2>::value |
Auxiliary variable template for the HasSIMDEqual type trait.The HasSIMDEqual_v variable template provides a convenient shortcut to access the nested value of the HasSIMDEqual class template. For instance, given the types T1 and T2 the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | HasSIMDErf_v = HasSIMDErf<T>::value |
Auxiliary variable template for the HasSIMDErf type trait.The HasSIMDErf_v variable template provides a convenient shortcut to access the nested value of the HasSIMDErf class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | HasSIMDErfc_v = HasSIMDErfc<T>::value |
Auxiliary variable template for the HasSIMDErfc type trait.The HasSIMDErfc_v variable template provides a convenient shortcut to access the nested value of the HasSIMDErfc class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | HasSIMDExp_v = HasSIMDExp<T>::value |
Auxiliary variable template for the HasSIMDExp type trait.The HasSIMDExp_v variable template provides a convenient shortcut to access the nested value of the HasSIMDExp class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | HasSIMDExp10_v = HasSIMDExp10<T>::value |
Auxiliary variable template for the HasSIMDExp10 type trait.The HasSIMDExp10_v variable template provides a convenient shortcut to access the nested value of the HasSIMDExp10 class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | HasSIMDExp2_v = HasSIMDExp2<T>::value |
Auxiliary variable template for the HasSIMDExp2 type trait.The HasSIMDExp2_v variable template provides a convenient shortcut to access the nested value of the HasSIMDExp2 class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | HasSIMDFloor_v = HasSIMDFloor<T>::value |
Auxiliary variable template for the HasSIMDFloor type trait.The HasSIMDFloor_v variable template provides a convenient shortcut to access the nested value of the HasSIMDFloor class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T1 , typename T2 > | |
constexpr bool | HasSIMDHypot_v = HasSIMDHypot<T1,T2>::value |
Auxiliary variable template for the HasSIMDHypot type trait.The HasSIMDHypot_v variable template provides a convenient shortcut to access the nested value of the HasSIMDHypot class template. For instance, given the types T1 and T2 the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | HasSIMDInvCbrt_v = HasSIMDInvCbrt<T>::value |
Auxiliary variable template for the HasSIMDInvCbrt type trait.The HasSIMDInvCbrt_v variable template provides a convenient shortcut to access the nested value of the HasSIMDInvCbrt class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | HasSIMDInvSqrt_v = HasSIMDInvSqrt<T>::value |
Auxiliary variable template for the HasSIMDInvSqrt type trait.The HasSIMDInvSqrt_v variable template provides a convenient shortcut to access the nested value of the HasSIMDInvSqrt class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | HasSIMDLog_v = HasSIMDLog<T>::value |
Auxiliary variable template for the HasSIMDLog type trait.The HasSIMDLog_v variable template provides a convenient shortcut to access the nested value of the HasSIMDLog class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | HasSIMDLog10_v = HasSIMDLog10<T>::value |
Auxiliary variable template for the HasSIMDLog10 type trait.The HasSIMDLog10_v variable template provides a convenient shortcut to access the nested value of the HasSIMDLog10 class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | HasSIMDLog2_v = HasSIMDLog2<T>::value |
Auxiliary variable template for the HasSIMDLog2 type trait.The HasSIMDLog2_v variable template provides a convenient shortcut to access the nested value of the HasSIMDLog2 class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T1 , typename T2 > | |
constexpr bool | HasSIMDMax_v = HasSIMDMax<T1,T2>::value |
Auxiliary variable template for the HasSIMDMax type trait.The HasSIMDMax_v variable template provides a convenient shortcut to access the nested value of the HasSIMDMax class template. For instance, given the types T1 and T2 the following two statements are identical: More... | |
template<typename T1 , typename T2 > | |
constexpr bool | HasSIMDMin_v = HasSIMDMin<T1,T2>::value |
Auxiliary variable template for the HasSIMDMin type trait.The HasSIMDMin_v variable template provides a convenient shortcut to access the nested value of the HasSIMDMin class template. For instance, given the types T1 and T2 the following two statements are identical: More... | |
template<typename T1 , typename T2 > | |
constexpr bool | HasSIMDMult_v = HasSIMDMult<T1,T2>::value |
Auxiliary variable template for the HasSIMDMult type trait.The HasSIMDMult_v variable template provides a convenient shortcut to access the nested value of the HasSIMDMult class template. For instance, given the types T1 and T2 the following two statements are identical: More... | |
template<typename T1 , typename T2 > | |
constexpr bool | HasSIMDPow_v = HasSIMDPow<T1,T2>::value |
Auxiliary variable template for the HasSIMDPow type trait.The HasSIMDPow_v variable template provides a convenient shortcut to access the nested value of the HasSIMDPow class template. For instance, given the types T1 and T2 the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | HasSIMDRound_v = HasSIMDRound<T>::value |
Auxiliary variable template for the HasSIMDRound type trait.The HasSIMDRound_v variable template provides a convenient shortcut to access the nested value of the HasSIMDRound class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | HasSIMDShiftLI_v = HasSIMDShiftLI<T>::value |
Auxiliary variable template for the HasSIMDShiftLI type trait.The HasSIMDShiftLI_v variable template provides a convenient shortcut to access the nested value of the HasSIMDShiftLI class template. For instance, given the types T1 and T2 the following two statements are identical: More... | |
template<typename T1 , typename T2 > | |
constexpr bool | HasSIMDShiftLV_v = HasSIMDShiftLV<T1,T2>::value |
Auxiliary variable template for the HasSIMDShiftLV type trait.The HasSIMDShiftLV_v variable template provides a convenient shortcut to access the nested value of the HasSIMDShiftLV class template. For instance, given the types T1 and T2 the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | HasSIMDShiftRI_v = HasSIMDShiftRI<T>::value |
Auxiliary variable template for the HasSIMDShiftRI type trait.The HasSIMDShiftRI_v variable template provides a convenient shortcut to access the nested value of the HasSIMDShiftRI class template. For instance, given the types T1 and T2 the following two statements are identical: More... | |
template<typename T1 , typename T2 > | |
constexpr bool | HasSIMDShiftRV_v = HasSIMDShiftRV<T1,T2>::value |
Auxiliary variable template for the HasSIMDShiftRV type trait.The HasSIMDShiftRV_v variable template provides a convenient shortcut to access the nested value of the HasSIMDShiftRV class template. For instance, given the types T1 and T2 the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | HasSIMDSign_v = HasSIMDSign<T>::value |
Auxiliary variable template for the HasSIMDSign type trait.The HasSIMDSign_v variable template provides a convenient shortcut to access the nested value of the HasSIMDSign class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | HasSIMDSin_v = HasSIMDSin<T>::value |
Auxiliary variable template for the HasSIMDSin type trait.The HasSIMDSin_v variable template provides a convenient shortcut to access the nested value of the HasSIMDSin class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | HasSIMDSinh_v = HasSIMDSinh<T>::value |
Auxiliary variable template for the HasSIMDSinh type trait.The HasSIMDSinh_v variable template provides a convenient shortcut to access the nested value of the HasSIMDSinh class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | HasSIMDSqrt_v = HasSIMDSqrt<T>::value |
Auxiliary variable template for the HasSIMDSqrt type trait.The HasSIMDSqrt_v variable template provides a convenient shortcut to access the nested value of the HasSIMDSqrt class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T1 , typename T2 > | |
constexpr bool | HasSIMDSub_v = HasSIMDSub<T1,T2>::value |
Auxiliary variable template for the HasSIMDSub type trait.The HasSIMDSub_v variable template provides a convenient shortcut to access the nested value of the HasSIMDSub class template. For instance, given the types T1 and T2 the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | HasSIMDTan_v = HasSIMDTan<T>::value |
Auxiliary variable template for the HasSIMDTan type trait.The HasSIMDTan_v variable template provides a convenient shortcut to access the nested value of the HasSIMDTan class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | HasSIMDTanh_v = HasSIMDTanh<T>::value |
Auxiliary variable template for the HasSIMDTanh type trait.The HasSIMDTanh_v variable template provides a convenient shortcut to access the nested value of the HasSIMDTanh class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | HasSIMDTrunc_v = HasSIMDTrunc<T>::value |
Auxiliary variable template for the HasSIMDTrunc type trait.The HasSIMDTrunc_v variable template provides a convenient shortcut to access the nested value of the HasSIMDTrunc class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | HasSin_v = HasSin<T>::value |
Auxiliary variable template for the HasSin type trait.The HasSin_v variable template provides a convenient shortcut to access the nested value of the HasSin class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | HasSinh_v = HasSinh<T>::value |
Auxiliary variable template for the HasSinh type trait.The HasSinh_v variable template provides a convenient shortcut to access the nested value of the HasSinh class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | HasSqrt_v = HasSqrt<T>::value |
Auxiliary variable template for the HasSqrt type trait.The HasSqrt_v variable template provides a convenient shortcut to access the nested value of the HasSqrt class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T1 , typename T2 > | |
constexpr bool | HasSub_v = HasSub<T1,T2>::value |
Auxiliary variable template for the HasSub type trait.The HasSub_v variable template provides a convenient shortcut to access the nested value of the HasSub class template. For instance, given the types T1 and T2 the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | HasTan_v = HasTan<T>::value |
Auxiliary variable template for the HasTan type trait.The HasTan_v variable template provides a convenient shortcut to access the nested value of the HasTan class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | HasTanh_v = HasTanh<T>::value |
Auxiliary variable template for the HasTanh type trait.The HasTanh_v variable template provides a convenient shortcut to access the nested value of the HasTanh class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | HasTrunc_v = HasTrunc<T>::value |
Auxiliary variable template for the HasTrunc type trait.The HasTrunc_v variable template provides a convenient shortcut to access the nested value of the HasTrunc class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsAdaptor_v = IsAdaptor<T>::value |
Auxiliary variable template for the IsAdaptor type trait.The IsAdaptor_v variable template provides a convenient shortcut to access the nested value of the IsAdaptor class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsAddExpr_v = IsAddExpr<T>::value |
Auxiliary variable template for the IsAddExpr type trait.The IsAddExpr_v variable template provides a convenient shortcut to access the nested value of the IsAddExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsAligned_v = IsAligned<T>::value |
Auxiliary variable template for the IsAligned type trait.The IsAligned_v variable template provides a convenient shortcut to access the nested value of the IsAligned class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsBand_v = IsBand<T>::value |
Auxiliary variable template for the IsBand type trait.The IsBand_v variable template provides a convenient shortcut to access the nested value of the IsBand class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsBinaryMapExpr_v = IsBinaryMapExpr<T>::value |
Auxiliary variable template for the IsBinaryMapExpr type trait.The IsBinaryMapExpr_v variable template provides a convenient shortcut to access the nested value of the IsBinaryMapExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsBLASCompatible_v = IsBLASCompatible<T>::value |
Auxiliary variable template for the IsBLASCompatible type trait.The IsBLASCompatible_v variable template provides a convenient shortcut to access the nested value of the IsBLASCompatible class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsColumn_v = IsColumn<T>::value |
Auxiliary variable template for the IsColumn type trait.The IsColumn_v variable template provides a convenient shortcut to access the nested value of the IsColumn class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsColumnMajorMatrix_v = IsColumnMajorMatrix<T>::value |
Auxiliary variable template for the IsColumnMajorMatrix type trait.The IsColumnMajorMatrix_v variable template provides a convenient shortcut to access the nested value of the IsColumnMajorMatrix class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsColumns_v = IsColumns<T>::value |
Auxiliary variable template for the IsColumns type trait.The IsColumns_v variable template provides a convenient shortcut to access the nested value of the IsColumns class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsColumnVector_v = IsColumnVector<T>::value |
Auxiliary variable template for the IsColumnVector type trait.The IsColumnVector_v variable template provides a convenient shortcut to access the nested value of the IsColumnVector class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T1 , typename T2 > | |
constexpr bool | IsCommutative_v = IsCommutative<T1,T2>::value |
Auxiliary variable template for the IsCommutative type trait.The IsCommutative_v variable template provides a convenient shortcut to access the nested value of the IsCommutative class template. For instance, given the type1 T1 and T2 the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsComputation_v = IsComputation<T>::value |
Auxiliary variable template for the IsComputation type trait.The IsComputation_v variable template provides a convenient shortcut to access the nested value of the IsComputation class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsContiguous_v = IsContiguous<T>::value |
Auxiliary variable template for the IsContiguous type trait.The IsContiguous_v variable template provides a convenient shortcut to access the nested value of the IsContiguous class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsCrossExpr_v = IsCrossExpr<T>::value |
Auxiliary variable template for the IsCrossExpr type trait.The IsCrossExpr_v variable template provides a convenient shortcut to access the nested value of the IsCrossExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsCUDAAssignable_v = IsCUDAAssignable<T>::value |
Auxiliary variable template for the IsCUDAAssignable type trait.The IsCUDAAssignable_v variable template provides a convenient shortcut to access the nested value of the IsCUDAAssignable class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsCustom_v = IsCustom<T>::value |
Auxiliary variable template for the IsCustom type trait.The IsCustom_v variable template provides a convenient shortcut to access the nested value of the IsCustom class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsDeclaration_v = IsDeclaration<T>::value |
Auxiliary variable template for the IsDeclaration type trait.The IsDeclaration_v variable template provides a convenient shortcut to access the nested value of the IsDeclaration class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsDeclDiagExpr_v = IsDeclDiagExpr<T>::value |
Auxiliary variable template for the IsDeclDiagExpr type trait.The IsDeclDiagExpr_v variable template provides a convenient shortcut to access the nested value of the IsDeclDiagExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsDeclExpr_v = IsDeclExpr<T>::value |
Auxiliary variable template for the IsDeclExpr type trait.The IsDeclExpr_v variable template provides a convenient shortcut to access the nested value of the IsDeclExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsDeclHermExpr_v = IsDeclHermExpr<T>::value |
Auxiliary variable template for the IsDeclHermExpr type trait.The IsDeclHermExpr_v variable template provides a convenient shortcut to access the nested value of the IsDeclHermExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsDeclLowExpr_v = IsDeclLowExpr<T>::value |
Auxiliary variable template for the IsDeclLowExpr type trait.The IsDeclLowExpr_v variable template provides a convenient shortcut to access the nested value of the IsDeclLowExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsDeclSymExpr_v = IsDeclSymExpr<T>::value |
Auxiliary variable template for the IsDeclSymExpr type trait.The IsDeclSymExpr_v variable template provides a convenient shortcut to access the nested value of the IsDeclSymExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsDeclUppExpr_v = IsDeclUppExpr<T>::value |
Auxiliary variable template for the IsDeclUppExpr type trait.The IsDeclUppExpr_v variable template provides a convenient shortcut to access the nested value of the IsDeclUppExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsDenseMatrix_v = IsDenseMatrix<T>::value |
Auxiliary variable template for the IsDenseMatrix type trait.The IsDenseMatrix_v variable template provides a convenient shortcut to access the nested value of the IsDenseMatrix class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsDenseVector_v = IsDenseVector<T>::value |
Auxiliary variable template for the IsDenseVector type trait.The IsDenseVector_v variable template provides a convenient shortcut to access the nested value of the IsDenseVector class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsDiagonal_v = IsDiagonal<T>::value |
Auxiliary variable template for the IsDiagonal type trait.The IsDiagonal_v variable template provides a convenient shortcut to access the nested value of the IsDiagonal class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsDivExpr_v = IsDivExpr<T>::value |
Auxiliary variable template for the IsDivExpr type trait.The IsDivExpr_v variable template provides a convenient shortcut to access the nested value of the IsDivExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsElements_v = IsElements<T>::value |
Auxiliary variable template for the IsElements type trait.The IsElements_v variable template provides a convenient shortcut to access the nested value of the IsElements class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsEvalExpr_v = IsEvalExpr<T>::value |
Auxiliary variable template for the IsEvalExpr type trait.The IsEvalExpr_v variable template provides a convenient shortcut to access the nested value of the IsEvalExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsExpandExpr_v = IsExpandExpr<T>::value |
Auxiliary variable template for the IsExpandExpr type trait.The IsExpandExpr_v variable template provides a convenient shortcut to access the nested value of the IsExpandExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsExpression_v = IsExpression<T>::value |
Auxiliary variable template for the IsExpression type trait.The IsExpression_v variable template provides a convenient shortcut to access the nested value of the IsExpression class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsGeneral_v = IsGeneral<T>::value |
Auxiliary variable template for the IsGeneral type trait.The IsGeneral_v variable template provides a convenient shortcut to access the nested value of the IsGeneral class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsHermitian_v = IsHermitian<T>::value |
Auxiliary variable template for the IsHermitian type trait.The IsHermitian_v variable template provides a convenient shortcut to access the nested value of the IsHermitian class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsIdentity_v = IsIdentity<T>::value |
Auxiliary variable template for the IsIdentity type trait.The IsIdentity_v variable template provides a convenient shortcut to access the nested value of the IsIdentity class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsInitializer_v = IsInitializer<T>::value |
Auxiliary variable template for the IsInitializer type trait.The IsInitializer_v variable template provides a convenient shortcut to access the nested value of the IsInitializer class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsInvertible_v = IsInvertible<T>::value |
Auxiliary variable template for the IsInvertible type trait.The IsInvertible_v variable template provides a convenient shortcut to access the nested value of the IsInvertible class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsKronExpr_v = IsKronExpr<T>::value |
Auxiliary variable template for the IsKronExpr type trait.The IsKronExpr_v variable template provides a convenient shortcut to access the nested value of the IsKronExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsLower_v = IsLower<T>::value |
Auxiliary variable template for the IsLower type trait.The IsLower_v variable template provides a convenient shortcut to access the nested value of the IsLower class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsMatEvalExpr_v = IsMatEvalExpr<T>::value |
Auxiliary variable template for the IsMatEvalExpr type trait.The IsMatEvalExpr_v variable template provides a convenient shortcut to access the nested value of the IsMatEvalExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsMatInvExpr_v = IsMatInvExpr<T>::value |
Auxiliary variable template for the IsMatInvExpr type trait.The IsMatInvExpr_v variable template provides a convenient shortcut to access the nested value of the IsMatInvExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsMatMapExpr_v = IsMatMapExpr<T>::value |
Auxiliary variable template for the IsMatMapExpr type trait.The IsMatMapExpr_v variable template provides a convenient shortcut to access the nested value of the IsMatMapExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsMatMatAddExpr_v = IsMatMatAddExpr<T>::value |
Auxiliary variable template for the IsMatMatAddExpr type trait.The IsMatMatAddExpr_v variable template provides a convenient shortcut to access the nested value of the IsMatMatAddExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsMatMatKronExpr_v = IsMatMatKronExpr<T>::value |
Auxiliary variable template for the IsMatMatKronExpr type trait.The IsMatMatKronExpr_v variable template provides a convenient shortcut to access the nested value of the IsMatMatKronExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsMatMatMapExpr_v = IsMatMatMapExpr<T>::value |
Auxiliary variable template for the IsMatMatMapExpr type trait.The IsMatMatMapExpr_v variable template provides a convenient shortcut to access the nested value of the IsMatMatMapExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsMatMatMultExpr_v = IsMatMatMultExpr<T>::value |
Auxiliary variable template for the IsMatMatMultExpr type trait.The IsMatMatMultExpr_v variable template provides a convenient shortcut to access the nested value of the IsMatMatMultExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsMatMatSubExpr_v = IsMatMatSubExpr<T>::value |
Auxiliary variable template for the IsMatMatSubExpr type trait.The IsMatMatSubExpr_v variable template provides a convenient shortcut to access the nested value of the IsMatMatSubExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsMatReduceExpr_v = IsMatReduceExpr<T>::value |
Auxiliary variable template for the IsMatReduceExpr type trait.The IsMatReduceExpr_v variable template provides a convenient shortcut to access the nested value of the IsMatReduceExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsMatrix_v = IsMatrix<T>::value |
Auxiliary variable template for the IsMatrix type trait.The IsMatrix_v variable template provides a convenient shortcut to access the nested value of the IsMatrix class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsMatScalarDivExpr_v = IsMatScalarDivExpr<T>::value |
Auxiliary variable template for the IsMatScalarDivExpr type trait.The IsMatScalarDivExpr_v variable template provides a convenient shortcut to access the nested value of the IsMatScalarDivExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsMatScalarMultExpr_v = IsMatScalarMultExpr<T>::value |
Auxiliary variable template for the IsMatScalarMultExpr type trait.The IsMatScalarMultExpr_v variable template provides a convenient shortcut to access the nested value of the IsMatScalarMultExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsMatSerialExpr_v = IsMatSerialExpr<T>::value |
Auxiliary variable template for the IsMatSerialExpr type trait.The IsMatSerialExpr_v variable template provides a convenient shortcut to access the nested value of the IsMatSerialExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsMatTransExpr_v = IsMatTransExpr<T>::value |
Auxiliary variable template for the IsMatTransExpr type trait.The IsMatTransExpr_v variable template provides a convenient shortcut to access the nested value of the IsMatTransExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsMatVecMultExpr_v = IsMatVecMultExpr<T>::value |
Auxiliary variable template for the IsMatVecMultExpr type trait.The IsMatVecMultExpr_v variable template provides a convenient shortcut to access the nested value of the IsMatVecMultExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsMultExpr_v = IsMultExpr<T>::value |
Auxiliary variable template for the IsMultExpr type trait.The IsMultExpr_v variable template provides a convenient shortcut to access the nested value of the IsMultExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsNumericMatrix_v = IsNumericMatrix<T>::value |
Auxiliary variable template for the IsNumericMatrix type trait.The IsNumericMatrix_v variable template provides a convenient shortcut to access the nested value of the IsNumericMatrix class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsNumericVector_v = IsNumericVector<T>::value |
Auxiliary variable template for the IsNumericVector type trait.The IsNumericVector_v variable template provides a convenient shortcut to access the nested value of the IsNumericVector class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsOperation_v = IsOperation<T>::value |
Auxiliary variable template for the IsOperation type trait.The IsOperation_v variable template provides a convenient shortcut to access the nested value of the IsOperation class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsOpposedView_v = IsOpposedView<T>::value |
Auxiliary variable template for the IsOpposedView type trait.The IsOpposedView_v variable template provides a convenient shortcut to access the nested value of the IsOpposedView class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsPadded_v = IsPadded<T>::value |
Auxiliary variable template for the IsPadded type trait.The IsPadded_v variable template provides a convenient shortcut to access the nested value of the IsPadded class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsPaddingEnabled_v = IsPaddingEnabled<T>::value |
Auxiliary variable template for the IsPaddingEnabled type trait.The IsPaddingEnabled_v variable template provides a convenient shortcut to access the nested value of the IsPaddingEnabled class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsProxy_v = IsProxy<T>::value |
Auxiliary variable template for the IsProxy type trait.The IsProxy_v variable template provides a convenient shortcut to access the nested value of the IsProxy class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsReduceExpr_v = IsReduceExpr<T>::value |
Auxiliary variable template for the IsReduceExpr type trait.The IsReduceExpr_v variable template provides a convenient shortcut to access the nested value of the IsReduceExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsResizable_v = IsResizable<T>::value |
Auxiliary variable template for the IsResizable type trait.The IsResizable_v variable template provides a convenient shortcut to access the nested value of the IsResizable class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsRestricted_v = IsRestricted<T>::value |
Auxiliary variable template for the IsRestricted type trait.The IsRestricted_v variable template provides a convenient shortcut to access the nested value of the IsRestricted class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsRow_v = IsRow<T>::value |
Auxiliary variable template for the IsRow type trait.The IsRow_v variable template provides a convenient shortcut to access the nested value of the IsRow class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsRowMajorMatrix_v = IsRowMajorMatrix<T>::value |
Auxiliary variable template for the IsRowMajorMatrix type trait.The IsRowMajorMatrix_v variable template provides a convenient shortcut to access the nested value of the IsRowMajorMatrix class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsRows_v = IsRows<T>::value |
Auxiliary variable template for the IsRows type trait.The IsRows_v variable template provides a convenient shortcut to access the nested value of the IsRows class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsRowVector_v = IsRowVector<T>::value |
Auxiliary variable template for the IsRowVector type trait.The IsRowVector_v variable template provides a convenient shortcut to access the nested value of the IsRowVector class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsSchurExpr_v = IsSchurExpr<T>::value |
Auxiliary variable template for the IsSchurExpr type trait.The IsSchurExpr_v variable template provides a convenient shortcut to access the nested value of the IsSchurExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsSerialExpr_v = IsSerialExpr<T>::value |
Auxiliary variable template for the IsSerialExpr type trait.The IsSerialExpr_v variable template provides a convenient shortcut to access the nested value of the IsSerialExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsShrinkable_v = IsShrinkable<T>::value |
Auxiliary variable template for the IsShrinkable type trait.The IsShrinkable_v variable template provides a convenient shortcut to access the nested value of the IsShrinkable class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T1 , typename T2 , typename... Ts> | |
constexpr bool | IsSIMDCombinable_v = IsSIMDCombinable<T1,T2,Ts...>::value |
Auxiliary variable template for the IsSIMDCombinable type trait.The IsSIMDCombinable_v variable template provides a convenient shortcut to access the nested value of the IsSIMDCombinable class template. For instance, given the types T1 and T2 the following two statements are identical: More... | |
template<typename T , typename... Args> | |
constexpr bool | IsSIMDEnabled_v = IsSIMDEnabled<T,Args...>::value |
Auxiliary variable template for the IsSIMDEnabled type trait.The IsSIMDEnabled_v variable template provides a convenient shortcut to access the nested value of the IsSIMDEnabled class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsSIMDPack_v = IsSIMDPack<T>::value |
Auxiliary variable template for the IsSIMDPack type trait.The IsSIMDPack_v variable template provides a convenient shortcut to access the nested value of the IsSIMDPack class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsSMPAssignable_v = IsSMPAssignable<T>::value |
Auxiliary variable template for the IsSMPAssignable type trait.The IsSMPAssignable_v variable template provides a convenient shortcut to access the nested value of the IsSMPAssignable class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsSparseElement_v = IsSparseElement<T>::value |
Auxiliary variable template for the IsSparseElement type trait.The IsSparseElement_v variable template provides a convenient shortcut to access the nested value of the IsSparseElement class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsSparseMatrix_v = IsSparseMatrix<T>::value |
Auxiliary variable template for the IsSparseMatrix type trait.The IsSparseMatrix_v variable template provides a convenient shortcut to access the nested value of the IsSparseMatrix class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsSparseVector_v = IsSparseVector<T>::value |
Auxiliary variable template for the IsSparseVector type trait.The IsSparseVector_v variable template provides a convenient shortcut to access the nested value of the IsSparseVector class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsSquare_v = IsSquare<T>::value |
Auxiliary variable template for the IsSquare type trait.The IsSquare_v variable template provides a convenient shortcut to access the nested value of the IsSquare class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsStatic_v = IsStatic<T>::value |
Auxiliary variable template for the IsStatic type trait.The IsStatic_v variable template provides a convenient shortcut to access the nested value of the IsStatic class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsStrictlyLower_v = IsStrictlyLower<T>::value |
Auxiliary variable template for the IsStrictlyLower type trait.The IsStrictlyLower_v variable template provides a convenient shortcut to access the nested value of the IsStrictlyLower class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsStrictlyTriangular_v = IsStrictlyTriangular<T>::value |
Auxiliary variable template for the IsStrictlyTriangular type trait.The IsStrictlyTriangular_v variable template provides a convenient shortcut to access the nested value of the IsStrictlyTriangular class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsStrictlyUpper_v = IsStrictlyUpper<T>::value |
Auxiliary variable template for the IsStrictlyUpper type trait.The IsStrictlyUpper_v variable template provides a convenient shortcut to access the nested value of the IsStrictlyUpper class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsSubExpr_v = IsSubExpr<T>::value |
Auxiliary variable template for the IsSubExpr type trait.The IsSubExpr_v variable template provides a convenient shortcut to access the nested value of the IsSubExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsSubmatrix_v = IsSubmatrix<T>::value |
Auxiliary variable template for the IsSubmatrix type trait.The IsSubmatrix_v variable template provides a convenient shortcut to access the nested value of the IsSubmatrix class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsSubvector_v = IsSubvector<T>::value |
Auxiliary variable template for the IsSubvector type trait.The IsSubvector_v variable template provides a convenient shortcut to access the nested value of the IsSubvector class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsSymmetric_v = IsSymmetric<T>::value |
Auxiliary variable template for the IsSymmetric type trait.The IsSymmetric_v variable template provides a convenient shortcut to access the nested value of the IsSymmetric class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsTemporary_v = IsTemporary<T>::value |
Auxiliary variable template for the IsTemporary type trait.The IsTemporary_v variable template provides a convenient shortcut to access the nested value of the IsTemporary class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsTransExpr_v = IsTransExpr<T>::value |
Auxiliary variable template for the IsTransExpr type trait.The IsTransExpr_v variable template provides a convenient shortcut to access the nested value of the IsTransExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsTransformation_v = IsTransformation<T>::value |
Auxiliary variable template for the IsTransformation type trait.The IsTransformation_v variable template provides a convenient shortcut to access the nested value of the IsTransformation class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsTriangular_v = IsTriangular<T>::value |
Auxiliary variable template for the IsTriangular type trait.The IsTriangular_v variable template provides a convenient shortcut to access the nested value of the IsTriangular class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsTVecMatMultExpr_v = IsTVecMatMultExpr<T>::value |
Auxiliary variable template for the IsTVecMatMultExpr type trait.The IsTVecMatMultExpr_v variable template provides a convenient shortcut to access the nested value of the IsTVecMatMultExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsUnaryMapExpr_v = IsUnaryMapExpr<T>::value |
Auxiliary variable template for the IsUnaryMapExpr type trait.The IsUnaryMapExpr_v variable template provides a convenient shortcut to access the nested value of the IsUnaryMapExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsUniform_v = IsUniform<T>::value |
Auxiliary variable template for the IsUniform type trait.The IsUniform_v variable template provides a convenient shortcut to access the nested value of the IsUniform class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsUniLower_v = IsUniLower<T>::value |
Auxiliary variable template for the IsUniLower type trait.The IsUniLower_v variable template provides a convenient shortcut to access the nested value of the IsUniLower class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsUniTriangular_v = IsUniTriangular<T>::value |
Auxiliary variable template for the IsUniTriangular type trait.The IsUniTriangular_v variable template provides a convenient shortcut to access the nested value of the IsUniTriangular class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsUniUpper_v = IsUniUpper<T>::value |
Auxiliary variable template for the IsUniUpper type trait.The IsUniUpper_v variable template provides a convenient shortcut to access the nested value of the IsUniUpper class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsUpper_v = IsUpper<T>::value |
Auxiliary variable template for the IsUpper type trait.The IsUpper_v variable template provides a convenient shortcut to access the nested value of the IsUpper class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsVecEvalExpr_v = IsVecEvalExpr<T>::value |
Auxiliary variable template for the IsVecEvalExpr type trait.The IsVecEvalExpr_v variable template provides a convenient shortcut to access the nested value of the IsVecEvalExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsVecExpandExpr_v = IsVecExpandExpr<T>::value |
Auxiliary variable template for the IsVecExpandExpr type trait.The IsVecExpandExpr_v variable template provides a convenient shortcut to access the nested value of the IsVecExpandExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsVecMapExpr_v = IsVecMapExpr<T>::value |
Auxiliary variable template for the IsVecMapExpr type trait.The IsVecMapExpr_v variable template provides a convenient shortcut to access the nested value of the IsVecMapExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsVecScalarDivExpr_v = IsVecScalarDivExpr<T>::value |
Auxiliary variable template for the IsVecScalarDivExpr type trait.The IsVecScalarDivExpr_v variable template provides a convenient shortcut to access the nested value of the IsVecScalarDivExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsVecScalarMultExpr_v = IsVecScalarMultExpr<T>::value |
Auxiliary variable template for the IsVecScalarMultExpr type trait.The IsVecScalarMultExpr_v variable template provides a convenient shortcut to access the nested value of the IsVecScalarMultExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsVecSerialExpr_v = IsVecSerialExpr<T>::value |
Auxiliary variable template for the IsVecSerialExpr type trait.The IsVecSerialExpr_v variable template provides a convenient shortcut to access the nested value of the IsVecSerialExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsVector_v = IsVector<T>::value |
Auxiliary variable template for the IsVector type trait.The IsVector_v variable template provides a convenient shortcut to access the nested value of the IsVector class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsVecTransExpr_v = IsVecTransExpr<T>::value |
Auxiliary variable template for the IsVecTransExpr type trait.The IsVecTransExpr_v variable template provides a convenient shortcut to access the nested value of the IsVecTransExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsVecTVecMultExpr_v = IsVecTVecMultExpr<T>::value |
Auxiliary variable template for the IsVecTVecMultExpr type trait.The IsVecTVecMultExpr_v variable template provides a convenient shortcut to access the nested value of the IsVecTVecMultExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsVecVecAddExpr_v = IsVecVecAddExpr<T>::value |
Auxiliary variable template for the IsVecVecAddExpr type trait.The IsVecVecAddExpr_v variable template provides a convenient shortcut to access the nested value of the IsVecVecAddExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsVecVecDivExpr_v = IsVecVecDivExpr<T>::value |
Auxiliary variable template for the IsVecVecDivExpr type trait.The IsVecVecDivExpr_v variable template provides a convenient shortcut to access the nested value of the IsVecVecDivExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsVecVecKronExpr_v = IsVecVecKronExpr<T>::value |
Auxiliary variable template for the IsVecVecKronExpr type trait.The IsVecVecKronExpr_v variable template provides a convenient shortcut to access the nested value of the IsVecVecKronExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsVecVecMapExpr_v = IsVecVecMapExpr<T>::value |
Auxiliary variable template for the IsVecVecMapExpr type trait.The IsVecVecMapExpr_v variable template provides a convenient shortcut to access the nested value of the IsVecVecMapExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsVecVecMultExpr_v = IsVecVecMultExpr<T>::value |
Auxiliary variable template for the IsVecVecMultExpr type trait.The IsVecVecMultExpr_v variable template provides a convenient shortcut to access the nested value of the IsVecVecMultExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsVecVecSubExpr_v = IsVecVecSubExpr<T>::value |
Auxiliary variable template for the IsVecVecSubExpr type trait.The IsVecVecSubExpr_v variable template provides a convenient shortcut to access the nested value of the IsVecVecSubExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsView_v = IsView<T>::value |
Auxiliary variable template for the IsView type trait.The IsView_v variable template provides a convenient shortcut to access the nested value of the IsView class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsZero_v = IsZero<T>::value |
Auxiliary variable template for the IsZero type trait.The IsZero_v variable template provides a convenient shortcut to access the nested value of the IsZero class template. For instance, given the type T the following two statements are identical: More... | |
constexpr ptrdiff_t | DefaultMaxSize_v = -1L |
Default size of the MaxSize type trait. | |
template<typename T , size_t N> | |
constexpr ptrdiff_t | MaxSize_v = MaxSize<T,N>::value |
Auxiliary variable template for the MaxSize type trait.The MaxSize_v variable template provides a convenient shortcut to access the nested value of the MaxSize class template. For instance, given the type T and the dimension N the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | RequiresEvaluation_v = RequiresEvaluation<T>::value |
Auxiliary variable template for the RequiresEvaluation type trait.The RequiresEvaluation_v variable template provides a convenient shortcut to access the nested value of the RequiresEvaluation class template. For instance, given the type T the following two statements are identical: More... | |
constexpr ptrdiff_t | DefaultSize_v = -1L |
Default size of the Size type trait. | |
template<typename T , size_t N> | |
constexpr ptrdiff_t | Size_v = Size<T,N>::value |
Auxiliary variable template for the Size type trait.The Size_v variable template provides a convenient shortcut to access the nested value of the Size class template. For instance, given the type T and the dimension N the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | StorageOrder_v = T::storageOrder |
Auxiliary variable template for the StorageOrder type trait.The StorageOrder_v variable template provides a convenient shortcut to access the nested value of the StorageOrder class template. For instance, given the matrix type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | TransposeFlag_v = T::transposeFlag |
Auxiliary variable template for the TransposeFlag type trait.The TransposeFlag_v variable template provides a convenient shortcut to access the nested value of the TransposeFlag class template. For instance, given the vector type T the following two statements are identical: More... | |
template<typename OP , typename MT , typename... MTs> | |
constexpr bool | YieldsDiagonal_v = YieldsDiagonal<OP,MT,MTs...>::value |
Auxiliary variable template for the YieldsDiagonal type trait.The YieldsDiagonal_v variable template provides a convenient shortcut to access the nested value of the YieldsDiagonal class template. For instance, given the operation OP and the matrix type MT the following two statements are identical: More... | |
template<typename OP , typename MT , typename... MTs> | |
constexpr bool | YieldsHermitian_v = YieldsHermitian<OP,MT,MTs...>::value |
Auxiliary variable template for the YieldsHermitian type trait.The YieldsHermitian_v variable template provides a convenient shortcut to access the nested value of the YieldsHermitian class template. For instance, given the operation OP and the matrix type MT the following two statements are identical: More... | |
template<typename OP , typename MT , typename... MTs> | |
constexpr bool | YieldsIdentity_v = YieldsIdentity<OP,MT,MTs...>::value |
Auxiliary variable template for the YieldsIdentity type trait.The YieldsIdentity_v variable template provides a convenient shortcut to access the nested value of the YieldsIdentity class template. For instance, given the operation OP and the matrix type MT the following two statements are identical: More... | |
template<typename OP , typename MT , typename... MTs> | |
constexpr bool | YieldsLower_v = YieldsLower<OP,MT,MTs...>::value |
Auxiliary variable template for the YieldsLower type trait.The YieldsLower_v variable template provides a convenient shortcut to access the nested value of the YieldsLower class template. For instance, given the operation OP and the matrix type MT the following two statements are identical: More... | |
template<typename OP , typename MT , typename... MTs> | |
constexpr bool | YieldsStrictlyLower_v = YieldsStrictlyLower<OP,MT,MTs...>::value |
Auxiliary variable template for the YieldsStrictlyLower type trait.The YieldsStrictlyLower_v variable template provides a convenient shortcut to access the nested value of the YieldsStrictlyLower class template. For instance, given the operation OP and the matrix type MT the following two statements are identical: More... | |
template<typename OP , typename MT , typename... MTs> | |
constexpr bool | YieldsStrictlyTriangular_v = YieldsStrictlyTriangular<OP,MT,MTs...>::value |
Auxiliary variable template for the YieldsStrictlyTriangular type trait.The YieldsStrictlyTriangular_v variable template provides a convenient shortcut to access the nested value of the YieldsStrictlyTriangular class template. For instance, given the operation OP and the matrix type MT the following two statements are identical: More... | |
template<typename OP , typename MT , typename... MTs> | |
constexpr bool | YieldsStrictlyUpper_v = YieldsStrictlyUpper<OP,MT,MTs...>::value |
Auxiliary variable template for the YieldsStrictlyUpper type trait.The YieldsStrictlyUpper_v variable template provides a convenient shortcut to access the nested value of the YieldsStrictlyUpper class template. For instance, given the operation OP and the matrix type MT the following two statements are identical: More... | |
template<typename OP , typename MT , typename... MTs> | |
constexpr bool | YieldsSymmetric_v = YieldsSymmetric<OP,MT,MTs...>::value |
Auxiliary variable template for the YieldsSymmetric type trait.The YieldsSymmetric_v variable template provides a convenient shortcut to access the nested value of the YieldsSymmetric class template. For instance, given the operation OP and the matrix type MT the following two statements are identical: More... | |
template<typename OP , typename MT , typename... MTs> | |
constexpr bool | YieldsTriangular_v = YieldsTriangular<OP,MT,MTs...>::value |
Auxiliary variable template for the YieldsTriangular type trait.The YieldsTriangular_v variable template provides a convenient shortcut to access the nested value of the YieldsTriangular class template. For instance, given the operation OP and the matrix type MT the following two statements are identical: More... | |
template<typename OP , typename T , typename... Ts> | |
constexpr bool | YieldsUniform_v = YieldsUniform<OP,T,Ts...>::value |
Auxiliary variable template for the YieldsUniform type trait.The YieldsUniform_v variable template provides a convenient shortcut to access the nested value of the YieldsUniform class template. For instance, given the operation OP and the vector or matrix type T the following two statements are identical: More... | |
template<typename OP , typename MT , typename... MTs> | |
constexpr bool | YieldsUniLower_v = YieldsUniLower<OP,MT,MTs...>::value |
Auxiliary variable template for the YieldsUniLower type trait.The YieldsUniLower_v variable template provides a convenient shortcut to access the nested value of the YieldsUniLower class template. For instance, given the operation OP and the matrix type MT the following two statements are identical: More... | |
template<typename OP , typename MT , typename... MTs> | |
constexpr bool | YieldsUniTriangular_v = YieldsUniTriangular<OP,MT,MTs...>::value |
Auxiliary variable template for the YieldsUniTriangular type trait.The YieldsUniTriangular_v variable template provides a convenient shortcut to access the nested value of the YieldsUniTriangular class template. For instance, given the operation OP and the matrix type MT the following two statements are identical: More... | |
template<typename OP , typename MT , typename... MTs> | |
constexpr bool | YieldsUniUpper_v = YieldsUniUpper<OP,MT,MTs...>::value |
Auxiliary variable template for the YieldsUniUpper type trait.The YieldsUniUpper_v variable template provides a convenient shortcut to access the nested value of the YieldsUniUpper class template. For instance, given the operation OP and the matrix type MT the following two statements are identical: More... | |
template<typename OP , typename MT , typename... MTs> | |
constexpr bool | YieldsUpper_v = YieldsUpper<OP,MT,MTs...>::value |
Auxiliary variable template for the YieldsUpper type trait.The YieldsUpper_v variable template provides a convenient shortcut to access the nested value of the YieldsUpper class template. For instance, given the operation OP and the matrix type MT the following two statements are identical: More... | |
template<typename OP , typename T , typename... Ts> | |
constexpr bool | YieldsZero_v = YieldsZero<OP,T,Ts...>::value |
Auxiliary variable template for the YieldsZero type trait.The YieldsZero_v variable template provides a convenient shortcut to access the nested value of the YieldsZero class template. For instance, given the operation OP and the vector or matrix type T the following two statements are identical: More... | |
constexpr Checked | 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 | 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... | |
constexpr size_t | DMATDVECMULT_DEBUG_THRESHOLD = 256UL |
Row-major dense matrix/dense vector multiplication threshold.This debug value is used instead of the BLAZE_DMATDVECMULT_THRESHOLD while the Blaze debug mode is active. It specifies the threshold between the application of the custom Blaze kernels and the BLAS kernels for the row-major dense matrix/dense vector multiplication. In case the number of elements in the dense matrix is equal or higher than this value, the BLAS kernels are preferred over the custom Blaze kernels. In case the number of elements in the dense matrix is smaller, the Blaze kernels are used. | |
constexpr size_t | TDMATDVECMULT_DEBUG_THRESHOLD = 256UL |
Column-major dense matrix/dense vector multiplication threshold.This debug value is used instead of the BLAZE_TDMATDVECMULT_THRESHOLD while the Blaze debug mode is active. It specifies the threshold between the application of the custom Blaze kernels and the BLAS kernels for the column-major dense matrix/dense vector multiplication. In case the number of elements in the dense matrix is equal or higher than this value, the BLAS kernels are preferred over the custom Blaze kernels. In case the number of elements in the dense matrix is smaller, the Blaze kernels are used. | |
constexpr size_t | TDVECDMATMULT_DEBUG_THRESHOLD = 256UL |
Dense Vector/row-major dense matrix multiplication threshold.This debug value is used instead of the BLAZE_TDVECDMATMULT_THRESHOLD while the Blaze debug mode is active. It specifies the threshold between the application of the custom Blaze kernels and the BLAS kernels for the dense vector/row-major dense matrix multiplication. In case the number of elements in the dense matrix is equal or higher than this value, the BLAS kernels are preferred over the custom Blaze kernels. In case the number of elements in the dense matrix is smaller, the Blaze kernels are used. | |
constexpr size_t | TDVECTDMATMULT_DEBUG_THRESHOLD = 256UL |
Dense Vector/column-major dense matrix multiplication threshold.This debug value is used instead of the BLAZE_TDVECTDMATMULT_THRESHOLD while the Blaze debug mode is active. It specifies the threshold between the application of the custom Blaze kernels and the BLAS kernels for the dense vector/column-major dense matrix multiplication. In case the number of elements in the dense matrix is equal or higher than this value, the BLAS kernels are preferred over the custom Blaze kernels. In case the number of elements in the dense matrix is smaller, the Blaze kernels are used. | |
constexpr size_t | DMATDMATMULT_DEBUG_THRESHOLD = 256UL |
Row-major dense matrix/row-major dense matrix multiplication threshold.This debug value is used instead of the BLAZE_DMATDMATMULT_THRESHOLD while the Blaze debug mode is active. It specifies the threshold between the application of the custom Blaze kernels and the BLAS kernels for the row-major dense matrix/row-major dense matrix multiplication. In case the number of elements in the dense matrix is equal or higher than this value, the BLAS kernels are preferred over the custom Blaze kernels. In case the number of elements in the dense matrix is smaller, the Blaze kernels are used. | |
constexpr size_t | DMATTDMATMULT_DEBUG_THRESHOLD = 256UL |
Row-major dense matrix/column-major dense matrix multiplication threshold.This debug value is used instead of the BLAZE_DMATTDMATMULT_THRESHOLD while the Blaze debug mode is active. It specifies the threshold between the application of the custom Blaze kernels and the BLAS kernels for the row-major dense matrix/column-major dense matrix multiplication. In case the number of elements in the dense matrix is equal or higher than this value, the BLAS kernels are preferred over the custom Blaze kernels. In case the number of elements in the dense matrix is smaller, the Blaze kernels are used. | |
constexpr size_t | TDMATDMATMULT_DEBUG_THRESHOLD = 256UL |
Column-major dense matrix/row-major dense matrix multiplication threshold.This debug value is used instead of the BLAZE_TDMATDMATMULT_THRESHOLD while the Blaze debug mode is active. It specifies the threshold between the application of the custom Blaze kernels and the BLAS kernels for the column-major dense matrix/row-major dense matrix multiplication. In case the number of elements in the dense matrix is equal or higher than this value, the BLAS kernels are preferred over the custom Blaze kernels. In case the number of elements in the dense matrix is smaller, the Blaze kernels are used. | |
constexpr size_t | TDMATTDMATMULT_DEBUG_THRESHOLD = 256UL |
Column-major dense matrix/column-major dense matrix multiplication threshold.This debug value is used instead of the BLAZE_TDMATTDMATMULT_THRESHOLD while the Blaze debug mode is active. It specifies the threshold between the application of the custom Blaze kernels and the BLAS kernels for the column-major dense matrix/column-major dense matrix multiplication. In case the number of elements in the dense matrix is equal or higher than this value, the BLAS kernels are preferred over the custom Blaze kernels. In case the number of elements in the dense matrix is smaller, the Blaze kernels are used. | |
constexpr size_t | DMATSMATMULT_DEBUG_THRESHOLD = 256UL |
Row-major dense matrix/row-major sparse matrix multiplication threshold.This debug value is used instead of the BLAZE_DMATSMATMULT_THRESHOLD while the Blaze debug mode is active. It specifies the threshold between the application of the Blaze kernels for small and for large row-major dense matrix/row-major sparse matrix multiplications. In case the number of elements of the target matrix is equal or higher than this value, the kernel for large matrices is preferred over the kernel for small matrices. In case the number of elements in the target matrix is smaller, the kernel for small matrices is used. | |
constexpr size_t | TDMATSMATMULT_DEBUG_THRESHOLD = 256UL |
Column-major dense matrix/row-major sparse matrix multiplication threshold.This debug value is used instead of the BLAZE_DMATSMATMULT_THRESHOLD while the Blaze debug mode is active. It specifies the threshold between the application of the Blaze kernels for small and for large column-major dense matrix/row-major sparse matrix multiplications. In case the number of elements of the target matrix is equal or higher than this value, the kernel for large matrices is preferred over the kernel for small matrices. In case the number of elements in the target matrix is smaller, the kernel for small matrices is used. | |
constexpr size_t | TSMATDMATMULT_DEBUG_THRESHOLD = 256UL |
Column-major sparse matrix/row-major dense matrix multiplication threshold.This debug value is used instead of the BLAZE_TSMATDMATMULT_THRESHOLD while the Blaze debug mode is active. It specifies the threshold between the application of the Blaze kernels for small and for large column-major sparse matrix/row-major dense matrix multiplications. In case the number of elements of the target matrix is equal or higher than this value, the kernel for large matrices is preferred over the kernel for small matrices. In case the number of elements in the target matrix is smaller, the kernel for small matrices is used. | |
constexpr size_t | TSMATTDMATMULT_DEBUG_THRESHOLD = 256UL |
Column-major sparse matrix/column-major dense matrix multiplication threshold.This debug value is used instead of the BLAZE_TSMATTDMATMULT_THRESHOLD while the Blaze debug mode is active. It specifies the threshold between the application of the Blaze kernels for small and for large column-major sparse matrix/column-major dense matrix multiplications. In case the number of elements of the target matrix is equal or higher than this value, the kernel for large matrices is preferred over the kernel for small matrices. In case the number of elements in the target matrix is smaller, the kernel for small matrices is used. | |
constexpr size_t | SMP_DVECASSIGN_DEBUG_THRESHOLD = 32UL |
SMP dense vector assignment threshold.This debug value is used instead of the BLAZE_SMP_DVECASSIGN_THRESHOLD while the Blaze debug mode is active. It specifies when an assignment of a simple dense vector can be executed in parallel. In case the number of elements of the target vector is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. | |
constexpr size_t | SMP_DVECSCALARMULT_DEBUG_THRESHOLD = 32UL |
SMP dense vector/scalar multiplication/division threshold.This debug value is used instead of the BLAZE_SMP_DVECSCALARMULT_THRESHOLD while the Blaze debug mode is active. It specifies when a dense vector/scalar multiplication/division can be executed in parallel. In case the number of elements of the target vector is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. | |
constexpr size_t | SMP_DVECDVECADD_DEBUG_THRESHOLD = 32UL |
SMP dense vector/dense vector addition threshold.This debug value is used instead of the BLAZE_SMP_DVECDVECADD_THRESHOLD while the Blaze debug mode is active. It specifies when a dense vector/dense vector addition can be executed in parallel. In case the number of elements of the target vector is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. | |
constexpr size_t | SMP_DVECDVECSUB_DEBUG_THRESHOLD = 32UL |
SMP dense vector/dense vector subtraction threshold.This debug value is used instead of the BLAZE_SMP_DVECDVECSUB_THRESHOLD while the Blaze debug mode is active. It specifies when a dense vector/dense vector subtraction can be executed in parallel. In case the number of elements of the target vector is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. | |
constexpr size_t | SMP_DVECDVECMULT_DEBUG_THRESHOLD = 32UL |
SMP dense vector/dense vector multiplication threshold.This debug value is used instead of the BLAZE_SMP_DVECDVECMULT_THRESHOLD while the Blaze debug mode is active. It specifies when a dense vector/dense vector multiplication can be executed in parallel. In case the number of elements of the target vector is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. | |
constexpr size_t | SMP_DVECDVECDIV_DEBUG_THRESHOLD = 32UL |
SMP dense vector/dense vector division threshold.This debug value is used instead of the BLAZE_SMP_DVECDVECDIV_THRESHOLD while the Blaze debug mode is active. It specifies when a dense vector/dense vector division can be executed in parallel. In case the number of elements of the target vector is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. | |
constexpr size_t | SMP_DVECDVECOUTER_DEBUG_THRESHOLD = 256UL |
SMP dense vector/dense vector outer product threshold.This debug value is used instead of the BLAZE_SMP_DVECDVECOUTER_THRESHOLD while the Blaze debug mode is active. It specifies when a dense vector/dense vector outer product can be executed in parallel. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. | |
constexpr size_t | SMP_DMATDVECMULT_DEBUG_THRESHOLD = 16UL |
SMP row-major dense matrix/dense vector multiplication threshold.This debug value is used instead of the BLAZE_SMP_DMATDVECMULT_THRESHOLD while the Blaze debug mode is active. It specifies when a row-major dense matrix/dense vector multiplication can be executed in parallel. In case the number of elements of the target vector is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. | |
constexpr size_t | SMP_TDMATDVECMULT_DEBUG_THRESHOLD = 16UL |
SMP column-major dense matrix/dense vector multiplication threshold.This debug value is used instead of the BLAZE_SMP_TDMATDVECMULT_THRESHOLD while the Blaze debug mode is active. It specifies when a column-major dense matrix/dense vector multiplication can be executed in parallel. In case the number of elements of the target vector is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. | |
constexpr size_t | SMP_TDVECDMATMULT_DEBUG_THRESHOLD = 16UL |
SMP dense vector/row-major dense matrix multiplication threshold.This debug value is used instead of the BLAZE_SMP_TDVECDMATMULT_THRESHOLD while the Blaze debug mode is active. It specifies when a dense vector/row-major dense matrix multiplication can be executed in parallel. In case the number of elements of the target vector is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. | |
constexpr size_t | SMP_TDVECTDMATMULT_DEBUG_THRESHOLD = 16UL |
SMP dense vector/column-major dense matrix multiplication threshold.This debug value is used instead of the BLAZE_SMP_TDVECTDMATMULT_THRESHOLD while the Blaze debug mode is active. It specifies when a dense vector/column-major dense matrix multiplication can be executed in parallel. In case the number of elements of the target vector is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. | |
constexpr size_t | SMP_DMATSVECMULT_DEBUG_THRESHOLD = 16UL |
SMP row-major dense matrix/sparse vector multiplication threshold.This debug value is used instead of the BLAZE_SMP_DMATSVECMULT_THRESHOLD while the Blaze debug mode is active. It specifies when a row-major dense matrix/sparse vector multiplication can be executed in parallel. In case the number of elements of the target vector is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. | |
constexpr size_t | SMP_TDMATSVECMULT_DEBUG_THRESHOLD = 16UL |
SMP column-major dense matrix/sparse vector multiplication threshold.This debug value is used instead of the BLAZE_SMP_TDMATSVECMULT_THRESHOLD while the Blaze debug mode is active. It specifies when a column-major dense matrix/sparse vector multiplication can be executed in parallel. In case the number of elements of the target vector is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. | |
constexpr size_t | SMP_TSVECDMATMULT_DEBUG_THRESHOLD = 16UL |
SMP sparse vector/row-major dense matrix multiplication threshold.This debug value is used instead of the BLAZE_SMP_TSVECDMATMULT_THRESHOLD while the Blaze debug mode is active. It specifies when a sparse vector/row-major dense matrix multiplication can be executed in parallel. In case the number of elements of the target vector is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. | |
constexpr size_t | SMP_TSVECTDMATMULT_DEBUG_THRESHOLD = 16UL |
SMP sparse vector/column-major dense matrix multiplication threshold.This debug value is used instead of the BLAZE_SMP_TSVECTDMATMULT_THRESHOLD while the Blaze debug mode is active. It specifies when a sparse vector/column-major dense matrix multiplication can be executed in parallel. In case the number of elements of the target vector is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. | |
constexpr size_t | SMP_SMATDVECMULT_DEBUG_THRESHOLD = 16UL |
SMP row-major sparse matrix/dense vector multiplication threshold.This debug value is used instead of the BLAZE_SMP_SMATDVECMULT_THRESHOLD while the Blaze debug mode is active. It specifies when a row-major sparse matrix/dense vector multiplication can be executed in parallel. In case the number of elements of the target vector is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. | |
constexpr size_t | SMP_TSMATDVECMULT_DEBUG_THRESHOLD = 16UL |
SMP column-major sparse matrix/dense vector multiplication threshold.This debug value is used instead of the BLAZE_SMP_TSMATDVECMULT_THRESHOLD while the Blaze debug mode is active. It specifies when a column-major sparse matrix/dense vector multiplication can be executed in parallel. In case the number of elements of the target vector is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. | |
constexpr size_t | SMP_TDVECSMATMULT_DEBUG_THRESHOLD = 16UL |
SMP dense vector/row-major sparse matrix multiplication threshold.This debug value is used instead of the BLAZE_SMP_TDVECSMATMULT_THRESHOLD while the Blaze debug mode is active. It specifies when a dense vector/row-major sparse matrix multiplication can be executed in parallel. In case the number of elements of the target vector is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. | |
constexpr size_t | SMP_TDVECTSMATMULT_DEBUG_THRESHOLD = 16UL |
SMP dense vector/column-major sparse matrix multiplication threshold.This debug value is used instead of the BLAZE_SMP_TDVECTSMATMULT_THRESHOLD while the Blaze debug mode is active. It specifies when a dense vector/column-major sparse matrix multiplication can be executed in parallel. In case the number of elements of the target vector is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. | |
constexpr size_t | SMP_SMATSVECMULT_DEBUG_THRESHOLD = 16UL |
SMP row-major sparse matrix/sparse vector multiplication threshold.This debug value is used instead of the BLAZE_SMP_SMATSVECMULT_THRESHOLD while the Blaze debug mode is active. It specifies when a row-major sparse matrix/sparse vector multiplication can be executed in parallel. In case the number of elements of the target vector is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. | |
constexpr size_t | SMP_TSMATSVECMULT_DEBUG_THRESHOLD = 16UL |
SMP column-major sparse matrix/sparse vector multiplication threshold.This debug value is used instead of the BLAZE_SMP_TSMATSVECMULT_THRESHOLD while the Blaze debug mode is active. It specifies when a column-major sparse matrix/sparse vector multiplication can be executed in parallel. In case the number of elements of the target vector is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. | |
constexpr size_t | SMP_TSVECSMATMULT_DEBUG_THRESHOLD = 16UL |
SMP sparse vector/row-major sparse matrix multiplication threshold.This debug value is used instead of the BLAZE_SMP_TSVECSMATMULT_THRESHOLD while the Blaze debug mode is active. It specifies when a sparse vector/row-major sparse matrix multiplication can be executed in parallel. In case the number of elements of the target vector is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. | |
constexpr size_t | SMP_TSVECTSMATMULT_DEBUG_THRESHOLD = 16UL |
SMP sparse vector/column-major sparse matrix multiplication threshold.This debug value is used instead of the BLAZE_SMP_TSVECTSMATMULT_THRESHOLD while the Blaze debug mode is active. It specifies when a sparse vector/column-major sparse matrix multiplication can be executed in parallel. In case the number of elements of the target vector is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. | |
constexpr size_t | SMP_DMATASSIGN_DEBUG_THRESHOLD = 256UL |
SMP dense matrix assignment threshold.This debug value is used instead of the BLAZE_SMP_DMATASSIGN_THRESHOLD while the Blaze debug mode is active. It specifies when an assignment with a simple dense matrix can be executed in parallel. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. | |
constexpr size_t | SMP_DMATSCALARMULT_DEBUG_THRESHOLD = 256UL |
SMP dense matrix/scalar multiplication/division threshold.This debug value is used instead of the BLAZE_SMP_DMATSCALARMULT_THRESHOLD while the Blaze debug mode is active. It specifies when a dense matrix/scalar multiplication or division can be executed in parallel. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. | |
constexpr size_t | SMP_DMATDMATADD_DEBUG_THRESHOLD = 256UL |
SMP row-major dense matrix/row-major dense matrix addition threshold.This debug value is used instead of the BLAZE_SMP_DMATDMATADD_THRESHOLD while the Blaze debug mode is active. It specifies when a row-major dense matrix/row-major dense matrix addition can be executed in parallel. This threshold affects both additions between two row-major matrices or two column-major dense matrices. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. | |
constexpr size_t | SMP_DMATTDMATADD_DEBUG_THRESHOLD = 256UL |
SMP row-major dense matrix/column-major dense matrix addition threshold.This debug value is used instead of the BLAZE_SMP_DMATTDMATADD_THRESHOLD while the Blaze debug mode is active. It specifies when a row-major dense matrix/column-major dense matrix addition can be executed in parallel. This threshold affects both additions between a row-major matrix and a column-major matrix and a column-major matrix and a row-major matrix. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. | |
constexpr size_t | SMP_DMATDMATSUB_DEBUG_THRESHOLD = 256UL |
SMP row-major dense matrix/row-major dense matrix subtraction threshold.This debug value is used instead of the BLAZE_SMP_DMATDMATSUB_THRESHOLD while the Blaze debug mode is active. It specifies when a row-major dense matrix/row-major dense matrix subtraction can be executed in parallel. This threshold affects both subtractions between two row-major matrices or two column-major dense matrices. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. | |
constexpr size_t | SMP_DMATTDMATSUB_DEBUG_THRESHOLD = 256UL |
SMP row-major dense matrix/column-major dense matrix subtraction threshold.This debug value is used instead of the BLAZE_SMP_DMATTDMATSUB_THRESHOLD while the Blaze debug mode is active. It specifies when a row-major dense matrix/column-major dense matrix subtraction can be executed in parallel. This threshold affects both subtractions between a row-major matrix and a column-major matrix and a column-major matrix and a row-major matrix. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. | |
constexpr size_t | SMP_DMATDMATSCHUR_DEBUG_THRESHOLD = 256UL |
SMP row-major dense matrix/row-major dense matrix Schur product threshold.This debug value is used instead of the BLAZE_SMP_DMATDMATSCHUR_THRESHOLD while the Blaze debug mode is active. It specifies when a row-major dense matrix/row-major dense matrix Schur product can be executed in parallel. This threshold affects both Schur products between two row-major matrices or two column-major dense matrices. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. | |
constexpr size_t | SMP_DMATTDMATSCHUR_DEBUG_THRESHOLD = 256UL |
SMP row-major dense matrix/column-major dense matrix Schur product threshold.This debug value is used instead of the BLAZE_SMP_DMATTDMATSCHUR_THRESHOLD while the Blaze debug mode is active. It specifies when a row-major dense matrix/column-major dense matrix Schur product can be executed in parallel. This threshold affects both Schur products between a row-major matrix and a column-major matrix and a column-major matrix and a row-major matrix. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. | |
constexpr size_t | SMP_DMATDMATMULT_DEBUG_THRESHOLD = 256UL |
SMP row-major dense matrix/row-major dense matrix multiplication threshold.This debug value is used instead of the BLAZE_SMP_DMATDMATMULT_THRESHOLD while the Blaze debug mode is active. It specifies when a row-major dense matrix/row-major dense matrix multiplication can be executed in parallel. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. | |
constexpr size_t | SMP_DMATTDMATMULT_DEBUG_THRESHOLD = 256UL |
SMP row-major dense matrix/column-major dense matrix multiplication threshold.This debug value is used instead of the BLAZE_SMP_DMATTDMATMULT_THRESHOLD while the Blaze debug mode is active. It specifies when a row-major dense matrix/column-major dense matrix multiplication can be executed in parallel. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. | |
constexpr size_t | SMP_TDMATDMATMULT_DEBUG_THRESHOLD = 256UL |
SMP column-major dense matrix/row-major dense matrix multiplication threshold.This debug value is used instead of the BLAZE_SMP_TDMATDMATMULT_THRESHOLD while the Blaze debug mode is active. It specifies when a column-major dense matrix/row-major dense matrix multiplication can be executed in parallel. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. | |
constexpr size_t | SMP_TDMATTDMATMULT_DEBUG_THRESHOLD = 256UL |
SMP column-major dense matrix/column-major dense matrix multiplication threshold.This debug value is used instead of the BLAZE_SMP_TDMATTDMATMULT_THRESHOLD while the Blaze debug mode is active. It specifies when a column-major dense matrix/column-major dense matrix multiplication can be executed in parallel. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. | |
constexpr size_t | SMP_DMATSMATMULT_DEBUG_THRESHOLD = 256UL |
SMP row-major dense matrix/row-major sparse matrix multiplication threshold.This debug value is used instead of the BLAZE_SMP_DMATSMATMULT_THRESHOLD while the Blaze debug mode is active. It specifies when a row-major dense matrix/row-major sparse matrix multiplication can be executed in parallel. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. | |
constexpr size_t | SMP_DMATTSMATMULT_DEBUG_THRESHOLD = 256UL |
SMP row-major dense matrix/column-major sparse matrix multiplication threshold.This debug value is used instead of the BLAZE_SMP_DMATTSMATMULT_THRESHOLD while the Blaze debug mode is active. It specifies when a row-major dense matrix/column-major sparse matrix multiplication can be executed in parallel. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. | |
constexpr size_t | SMP_TDMATSMATMULT_DEBUG_THRESHOLD = 256UL |
SMP column-major dense matrix/row-major sparse matrix multiplication threshold.This debug value is used instead of the BLAZE_SMP_TDMATSMATMULT_THRESHOLD while the Blaze debug mode is active. It specifies when a column-major dense matrix/row-major sparse matrix multiplication can be executed in parallel. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. | |
constexpr size_t | SMP_TDMATTSMATMULT_DEBUG_THRESHOLD = 256UL |
SMP column-major dense matrix/column-major sparse matrix multiplication threshold.This debug value is used instead of the BLAZE_SMP_TDMATTSMATMULT_THRESHOLD while the Blaze debug mode is active. It specifies when a column-major dense matrix/column-major sparse matrix multiplication can be executed in parallel. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. | |
constexpr size_t | SMP_SMATDMATMULT_DEBUG_THRESHOLD = 256UL |
SMP row-major sparse matrix/row-major dense matrix multiplication threshold.This debug value is used instead of the BLAZE_SMP_SMATDMATMULT_THRESHOLD while the Blaze debug mode is active. It specifies when a row-major sparse matrix/row-major dense matrix multiplication can be executed in parallel. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. | |
constexpr size_t | SMP_SMATTDMATMULT_DEBUG_THRESHOLD = 256UL |
SMP row-major sparse matrix/column-major dense matrix multiplication threshold.This debug value is used instead of the BLAZE_SMP_SMATTDMATMULT_THRESHOLD while the Blaze debug mode is active. It specifies when a row-major sparse matrix/column-major dense matrix multiplication can be executed in parallel. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. | |
constexpr size_t | SMP_TSMATDMATMULT_DEBUG_THRESHOLD = 256UL |
SMP column-major sparse matrix/row-major dense matrix multiplication threshold.This debug value is used instead of the BLAZE_SMP_TSMATDMATMULT_THRESHOLD while the Blaze debug mode is active. It specifies when a column-major sparse matrix/row-major dense matrix multiplication can be executed in parallel. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. | |
constexpr size_t | SMP_TSMATTDMATMULT_DEBUG_THRESHOLD = 256UL |
SMP column-major sparse matrix/column-major dense matrix multiplication threshold.This debug value is used instead of the BLAZE_SMP_TSMATTDMATMULT_THRESHOLD while the Blaze debug mode is active. It specifies when a column-major sparse matrix/column-major dense matrix multiplication can be executed in parallel. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. | |
constexpr size_t | SMP_SMATSMATMULT_DEBUG_THRESHOLD = 256UL |
SMP row-major sparse matrix/row-major sparse matrix multiplication threshold.This debug value is used instead of the BLAZE_SMP_SMATSMATMULT_THRESHOLD while the Blaze debug mode is active. It specifies when a row-major sparse matrix/row-major sparse matrix multiplication can be executed in parallel. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. | |
constexpr size_t | SMP_SMATTSMATMULT_DEBUG_THRESHOLD = 256UL |
SMP row-major sparse matrix/column-major sparse matrix multiplication threshold.This debug value is used instead of the BLAZE_SMP_SMATTSMATMULT_THRESHOLD while the Blaze debug mode is active. It specifies when a row-major sparse matrix/column-major sparse matrix multiplication can be executed in parallel. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. | |
constexpr size_t | SMP_TSMATSMATMULT_DEBUG_THRESHOLD = 256UL |
SMP column-major sparse matrix/row-major sparse matrix multiplication threshold.This debug value is used instead of the BLAZE_SMP_TSMATSMATMULT_THRESHOLD while the Blaze debug mode is active. It specifies when a column-major sparse matrix/row-major sparse matrix multiplication can be executed in parallel. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. | |
constexpr size_t | SMP_TSMATTSMATMULT_DEBUG_THRESHOLD = 256UL |
SMP column-major sparse matrix/column-major sparse matrix multiplication threshold.This debug value is used instead of the BLAZE_SMP_TSMATTSMATMULT_THRESHOLD while the Blaze debug mode is active. It specifies when a column-major sparse matrix/column-major sparse matrix multiplication can be executed in parallel. In case the number of elements of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. | |
constexpr size_t | SMP_DMATREDUCE_DEBUG_THRESHOLD = 16UL |
SMP dense matrix reduction threshold.This debug value is used instead of the BLAZE_SMP_DMATREDUCE_THRESHOLD while the Blaze debug mode is active. It specifies when a dense matrix reduction can be executed in parallel. In case the number of elements of the target vector is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. | |
constexpr size_t | SMP_SMATREDUCE_DEBUG_THRESHOLD = 16UL |
SMP sparse matrix reduction threshold.This debug value is used instead of the BLAZE_SMP_SMATREDUCE_THRESHOLD while the Blaze debug mode is active. It specifies when a sparse matrix reduction can be executed in parallel. In case the number of elements of the target vector is larger or equal to this threshold, the operation is executed in parallel. If the number of elements is below this threshold the operation is executed single-threaded. | |
template<typename T1 , typename T2 , typename... Ts> | |
constexpr bool | And_v = And_t<T1,T2,Ts...>::value |
Auxiliary variable template for the And_t alias.The And_v variable template provides a convenient shortcut to access the nested value of the And_t alias. For instance, given the types T1 and T2 the following two statements are identical: More... | |
template<typename T1 , typename T2 > | |
constexpr bool | Equal_v = Equal_t<T1,T2>::value |
Auxiliary variable template for the Equal_t alias.The Equal_v variable template provides a convenient shortcut to access the nested value of the Equal_t alias. For instance, given the types T1 and T2 the following two statements are identical: More... | |
template<typename T1 , typename T2 > | |
constexpr bool | Greater_v = Greater_t<T1,T2>::value |
Auxiliary variable template for the Greater_t alias.The Greater_v variable template provides a convenient shortcut to access the nested value of the Greater_t alias. For instance, given the types T1 and T2 the following two statements are identical: More... | |
template<typename T1 , typename T2 > | |
constexpr bool | Less_v = Less_t<T1,T2>::value |
Auxiliary variable template for the Less_t alias.The Less_v variable template provides a convenient shortcut to access the nested value of the Less_t alias. For instance, given the types T1 and T2 the following two statements are identical: More... | |
template<typename T1 , typename T2 , typename... Ts> | |
constexpr bool | Nand_v = Nand_t<T1,T2,Ts...>::value |
Auxiliary variable template for the Nand_t alias.The Nand_v variable template provides a convenient shortcut to access the nested value of the Nand_t alias. For instance, given the types T1 and T2 the following two statements are identical: More... | |
template<typename T1 , typename T2 , typename... Ts> | |
constexpr bool | Nor_v = Nor_t<T1,T2,Ts...>::value |
Auxiliary variable template for the Nor_t alias.The Nor_v variable template provides a convenient shortcut to access the nested value of the Nor_t alias. For instance, given the types T1 and T2 the following two statements are identical: More... | |
template<typename C > | |
constexpr bool | Not_v = Not_t<C>::value |
Auxiliary variable template for the Not_t alias.The Not_v variable template provides a convenient shortcut to access the nested value of the Not_t alias. For instance, given the type C the following two statements are identical: More... | |
template<typename T1 , typename T2 , typename... Ts> | |
constexpr bool | Or_v = Or_t<T1,T2,Ts...>::value |
Auxiliary variable template for the Or_t alias.The Or_v variable template provides a convenient shortcut to access the nested value of the Or_t alias. For instance, given the types T1 and T2 the following two statements are identical: More... | |
template<typename T1 , typename T2 > | |
constexpr bool | Xor_v = Xor_t<T1,T2>::value |
Auxiliary variable template for the Xor_t alias.The Xor_v variable template provides a convenient shortcut to access the nested value of the Xor_t alias. For instance, given the types T1 and T2 the following two statements are identical: More... | |
template<typename TL , typename T > | |
constexpr bool | Contains_v = Contains<TL,T>::value |
Auxiliary variable template for the Contains type trait.The Contains_v variable template provides a convenient shortcut to access the nested value of the Contains class template. For instance, given the type list TL and the type T the following two statements are identical: More... | |
template<typename TL , typename T > | |
constexpr bool | ContainsRelated_v = ContainsRelated<TL,T>::value |
Auxiliary variable template for the ContainsRelated type trait.The ContainsRelated_v variable template provides a convenient shortcut to access the nested value of the ContainsRelated class template. For instance, given the type list TL and the type T the following two statements are identical: More... | |
template<typename TL , typename T > | |
constexpr size_t | IndexOf_v = IndexOf<TL,T>::value |
Auxiliary variable template for the IndexOf type trait.The IndexOf_v variable template provides a convenient shortcut to access the nested value of the IndexOf class template. For instance, given the type list TL and the type T the following two statements are identical: More... | |
template<typename TL > | |
constexpr size_t | Length_v = Length<TL>::value |
Auxiliary variable template for the Length type trait.The Length_v variable template provides a convenient shortcut to access the nested value of the Length class template. For instance, given the type list TL the following two statements are identical: More... | |
template<typename T > | |
constexpr size_t | AlignmentOf_v = AlignmentOf<T>::value |
Auxiliary variable template for the AlignmentOf type trait.The AlignmentOf_v variable template provides a convenient shortcut to access the nested value of the AlignmentOf class template. For instance, given the type T the following two statements are identical: More... | |
template<template< typename > class TypeTrait, typename T1 , typename T2 , typename... Ts> | |
constexpr bool | All_v = All<TypeTrait,T1,T2,Ts...>::value |
Auxiliary variable template for the All type trait.The All_v variable template provides a convenient shortcut to access the nested value of the All class template. For instance, given the type trait TypeTrait and the two types T1 and T2 the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | AlwaysFalse_v = false |
Auxiliary variable template for the AlwaysFalse type trait.The AlwaysFalse_v variable template provides a convenient shortcut to access the nested value of the AlwaysFalse class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | AlwaysTrue_v = true |
Auxiliary variable template for the AlwaysTrue type trait.The AlwaysTrue_v variable template provides a convenient shortcut to access the nested value of the AlwaysTrue class template. For instance, given the type T the following two statements are identical: More... | |
template<template< typename > class TypeTrait, typename T1 , typename T2 , typename... Ts> | |
constexpr bool | Any_v = Any<TypeTrait,T1,T2,Ts...>::value |
Auxiliary variable template for the Any type trait.The Any_v variable template provides a convenient shortcut to access the nested value of the Any class template. For instance, given the type trait TypeTrait and the two types T1 and T2 the following two statements are identical: More... | |
template<typename T , size_t N> | |
constexpr size_t | Extent_v = Extent<T,N>::value |
Auxiliary variable template for the Extent type trait.The Extent_v variable template provides a convenient shortcut to access the nested value of the Extent class template. For instance, given the type T and the compile time constant N the following two statements are identical: More... | |
template<typename T , size_t S> | |
constexpr bool | HasSize_v = HasSize<T,S>::value |
Auxiliary variable template for the HasSize type trait.The HasSize_v variable template provides a convenient shortcut to access the nested value of the HasSize class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | Has1Byte_v = Has1Byte<T>::value |
Auxiliary variable template for the Has1Byte type trait.The Has1Byte_v variable template provides a convenient shortcut to access the nested value of the Has1Byte class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | Has2Bytes_v = Has2Bytes<T>::value |
Auxiliary variable template for the Has2Bytes type trait.The Has2Bytes_v variable template provides a convenient shortcut to access the nested value of the Has2Bytes class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | Has4Bytes_v = Has4Bytes<T>::value |
Auxiliary variable template for the Has4Bytes type trait.The Has4Bytes_v variable template provides a convenient shortcut to access the nested value of the Has4Bytes class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | Has8Bytes_v = Has8Bytes<T>::value |
Auxiliary variable template for the Has8Bytes type trait.The Has8Bytes_v variable template provides a convenient shortcut to access the nested value of the Has8Bytes class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T1 , typename T2 > | |
constexpr bool | HaveSameSize_v = HaveSameSize<T1,T2>::value |
Auxiliary variable template for the HaveSameSize type trait.The HaveSameSize_v variable template provides a convenient shortcut to access the nested value of the HaveSameSize class template. For instance, given the typew T1 and T2 the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsArithmetic_v = IsArithmetic<T>::value |
Auxiliary variable template for the IsArithmetic type trait.The IsArithmetic_v variable template provides a convenient shortcut to access the nested value of the IsArithmetic class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsArray_v = IsArray<T>::value |
Auxiliary variable template for the IsArray type trait.The IsArray_v variable template provides a convenient shortcut to access the nested value of the IsArray class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T , typename U > | |
constexpr bool | IsAssignable_v = IsAssignable<T,U>::value |
Auxiliary variable template for the IsAssignable type trait.The IsAssignable_v variable template provides a convenient shortcut to access the nested value of the IsAssignable class template. For instance, given the types T and U the following two statements are identical: More... | |
template<typename T , typename U > | |
constexpr bool | IsNothrowAssignable_v = IsNothrowAssignable<T,U>::value |
Auxiliary variable template for the IsNothrowAssignable type trait.The IsNothrowAssignable_v variable template provides a convenient shortcut to access the nested value of the IsNothrowAssignable class template. For instance, given the types T and U the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsCopyAssignable_v = IsCopyAssignable<T>::value |
Auxiliary variable template for the IsCopyAssignable type trait.The IsCopyAssignable_v variable template provides a convenient shortcut to access the nested value of the IsCopyAssignable class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsNothrowCopyAssignable_v = IsNothrowCopyAssignable<T>::value |
Auxiliary variable template for the IsNothrowCopyAssignable type trait.The IsNothrowCopyAssignable_v variable template provides a convenient shortcut to access the nested value of the IsNothrowCopyAssignable class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsMoveAssignable_v = IsMoveAssignable<T>::value |
Auxiliary variable template for the IsMoveAssignable type trait.The IsMoveAssignable_v variable template provides a convenient shortcut to access the nested value of the IsMoveAssignable class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsNothrowMoveAssignable_v = IsNothrowMoveAssignable<T>::value |
Auxiliary variable template for the IsNothrowMoveAssignable type trait.The IsNothrowMoveAssignable_v variable template provides a convenient shortcut to access the nested value of the IsNothrowMoveAssignable class template. For instance, given the type T the following two statements are identical: More... | |
template<typename Base , typename Derived > | |
constexpr bool | IsBaseOf_v = IsBaseOf<Base,Derived>::value |
Auxiliary variable template for the IsBaseOf type trait.The IsBaseOf_v variable template provides a convenient shortcut to access the nested value of the IsBaseOf class template. For instance, given the types T1 and T2 the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsBoolean_v = IsBoolean<T>::value |
Auxiliary variable template for the IsBoolean type trait.The IsBoolean_v variable template provides a convenient shortcut to access the nested value of the IsBoolean class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsBuiltin_v = IsBuiltin<T>::value |
Auxiliary variable template for the IsBuiltin type trait.The IsBuiltin_v variable template provides a convenient shortcut to access the nested value of the IsBuiltin class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsCharacter_v = IsCharacter<T>::value |
Auxiliary variable template for the IsCharacter type trait.The IsCharacter_v variable template provides a convenient shortcut to access the nested value of the IsCharacter class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsClass_v = IsClass<T>::value |
Auxiliary variable template for the IsClass type trait.The IsClass_v variable template provides a convenient shortcut to access the nested value of the IsClass class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsComplex_v = IsComplex<T>::value |
Auxiliary variable template for the IsComplex type trait.The IsComplex_v variable template provides a convenient shortcut to access the nested value of the IsComplex class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsComplexDouble_v = IsComplexDouble<T>::value |
Auxiliary variable template for the IsComplexDouble type trait.The IsComplexDouble_v variable template provides a convenient shortcut to access the nested value of the IsComplexDouble class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsComplexFloat_v = IsComplexFloat<T>::value |
Auxiliary variable template for the IsComplexFloat type trait.The IsComplexFloat_v variable template provides a convenient shortcut to access the nested value of the IsComplexFloat class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsConst_v = IsConst<T>::value |
Auxiliary variable template for the IsConst type trait.The IsConst_v variable template provides a convenient shortcut to access the nested value of the IsConst class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T , typename... Args> | |
constexpr bool | IsConstructible_v = IsConstructible<T>::value |
Auxiliary variable template for the IsConstructible type trait.The IsConstructible_v variable template provides a convenient shortcut to access the nested value of the IsConstructible class template. For instance, given the types T1, T2 and T3 the following two statements are identical: More... | |
template<typename T , typename... Args> | |
constexpr bool | IsNothrowConstructible_v = IsNothrowConstructible<T>::value |
Auxiliary variable template for the IsNothrowConstructible type trait.The IsNothrowConstructible_v variable template provides a convenient shortcut to access the nested value of the IsNothrowConstructible class template. For instance, given the types T1, T2 and T3 the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsDefaultConstructible_v = IsDefaultConstructible<T>::value |
Auxiliary variable template for the IsDefaultConstructible type trait.The IsDefaultConstructible_v variable template provides a convenient shortcut to access the nested value of the IsDefaultConstructible class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsNothrowDefaultConstructible_v = IsNothrowDefaultConstructible<T>::value |
Auxiliary variable template for the IsNothrowDefaultConstructible type trait.The IsNothrowDefaultConstructible_v variable template provides a convenient shortcut to access the nested value of the IsNothrowDefaultConstructible class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsCopyConstructible_v = IsCopyConstructible<T>::value |
Auxiliary variable template for the IsCopyConstructible type trait.The IsCopyConstructible_v variable template provides a convenient shortcut to access the nested value of the IsCopyConstructible class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsNothrowCopyConstructible_v = IsNothrowCopyConstructible<T>::value |
Auxiliary variable template for the IsNothrowCopyConstructible type trait.The IsNothrowCopyConstructible_v variable template provides a convenient shortcut to access the nested value of the IsNothrowCopyConstructible class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsMoveConstructible_v = IsMoveConstructible<T>::value |
Auxiliary variable template for the IsMoveConstructible type trait.The IsMoveConstructible_v variable template provides a convenient shortcut to access the nested value of the IsMoveConstructible class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsNothrowMoveConstructible_v = IsNothrowMoveConstructible<T>::value |
Auxiliary variable template for the IsNothrowMoveConstructible type trait.The IsNothrowMoveConstructible_v variable template provides a convenient shortcut to access the nested value of the IsNothrowMoveConstructible class template. For instance, given the type T the following two statements are identical: More... | |
template<typename From , typename To > | |
constexpr bool | IsConvertible_v = IsConvertible<From,To>::value |
Auxiliary variable template for the IsConvertible type trait.The IsConvertible_v variable template provides a convenient shortcut to access the nested value of the IsConvertible class template. For instance, given the types T1 and T2 the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsDestructible_v = IsDestructible<T>::value |
Auxiliary variable template for the IsDestructible type trait.The IsDestructible_v variable template provides a convenient shortcut to access the nested value of the IsDestructible class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsNothrowDestructible_v = IsNothrowDestructible<T>::value |
Auxiliary variable template for the IsNothrowDestructible type trait.The IsNothrowDestructible_v variable template provides a convenient shortcut to access the nested value of the IsNothrowDestructible class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsDouble_v = IsDouble<T>::value |
Auxiliary variable template for the IsDouble type trait.The IsDouble_v variable template provides a convenient shortcut to access the nested value of the IsDouble class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsEmpty_v = IsEmpty<T>::value |
Auxiliary variable template for the IsEmpty type trait.The IsEmpty_v variable template provides a convenient shortcut to access the nested value of the IsEmpty class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsEnum_v = IsEnum<T>::value |
Auxiliary variable template for the IsEnum type trait.The IsEnum_v variable template provides a convenient shortcut to access the nested value of the IsEnum class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsFloat_v = IsFloat<T>::value |
Auxiliary variable template for the IsFloat type trait.The IsFloat_v variable template provides a convenient shortcut to access the nested value of the IsFloat class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsFloatingPoint_v = IsFloatingPoint<T>::value |
Auxiliary variable template for the IsFloatingPoint type trait.The IsFloatingPoint_v variable template provides a convenient shortcut to access the nested value of the IsFloatingPoint class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsInteger_v = IsInteger<T>::value |
Auxiliary variable template for the IsInteger type trait.The IsInteger_v variable template provides a convenient shortcut to access the nested value of the IsInteger class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsIntegral_v = IsIntegral<T>::value |
Auxiliary variable template for the IsIntegral type trait.The IsIntegral_v variable template provides a convenient shortcut to access the nested value of the IsIntegral class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsLong_v = IsLong<T>::value |
Auxiliary variable template for the IsLong type trait.The IsLong_v variable template provides a convenient shortcut to access the nested value of the IsLong class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsLongDouble_v = IsLongDouble<T>::value |
Auxiliary variable template for the IsLongDouble type trait.The IsLongDouble_v variable template provides a convenient shortcut to access the nested value of the IsLongDouble class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsLValueReference_v = IsLValueReference<T>::value |
Auxiliary variable template for the IsLValueReference type trait.The IsLValueReference_v variable template provides a convenient shortcut to access the nested value of the IsLValueReference class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsNumeric_v = IsNumeric<T>::value |
Auxiliary variable template for the IsNumeric type trait.The IsNumeric_v variable template provides a convenient shortcut to access the nested value of the IsNumeric class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsObject_v = IsObject<T>::value |
Auxiliary variable template for the IsObject type trait.The IsObject_v variable template provides a convenient shortcut to access the nested value of the IsObject class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsPod_v = IsPod<T>::value |
Auxiliary variable template for the IsPod type trait.The IsPod_v variable template provides a convenient shortcut to access the nested value of the IsPod class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsPointer_v = IsPointer<T>::value |
Auxiliary variable template for the IsPointer type trait.The IsPointer_v variable template provides a convenient shortcut to access the nested value of the IsPointer class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsReference_v = IsReference<T>::value |
Auxiliary variable template for the IsReference type trait.The IsReference_v variable template provides a convenient shortcut to access the nested value of the IsReference class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsRValueReference_v = IsRValueReference<T>::value |
Auxiliary variable template for the IsRValueReference type trait.The IsRValueReference_v variable template provides a convenient shortcut to access the nested value of the IsRValueReference class template. For instance, given the type T the following two statements are identical: More... | |
template<typename A , typename B > | |
constexpr bool | IsStrictlySame_v = IsStrictlySame<A,B>::value |
Auxiliary variable template for the IsStrictlySame type trait.The IsStrictlySame_v variable template provides a convenient shortcut to access the nested value of the IsStrictlySame class template. For instance, given the types T1 and T2 the following two statements are identical: More... | |
template<typename A , typename B > | |
constexpr bool | IsSame_v = IsSame<A,B>::value |
Auxiliary variable template for the IsSame type trait.The IsSame_v variable template provides a convenient shortcut to access the nested value of the IsSame class template. For instance, given the types T1 and T2 the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsShort_v = IsShort<T>::value |
Auxiliary variable template for the IsShort type trait.The IsShort_v variable template provides a convenient shortcut to access the nested value of the IsShort class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsSigned_v = IsSigned<T>::value |
Auxiliary variable template for the IsSigned type trait.The IsSigned_v variable template provides a convenient shortcut to access the nested value of the IsSigned class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsUnion_v = IsUnion<T>::value |
Auxiliary variable template for the IsUnion type trait.The IsUnion_v variable template provides a convenient shortcut to access the nested value of the IsUnion class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsUnsigned_v = IsUnsigned<T>::value |
Auxiliary variable template for the IsUnsigned type trait.The IsUnsigned_v variable template provides a convenient shortcut to access the nested value of the IsUnsigned class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsValid_v = IsValid<T>::value |
Auxiliary variable template for the IsValid type trait.The IsValid_v variable template provides a convenient shortcut to access the nested value of the IsValid class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsVectorizable_v = IsVectorizable<T>::value |
Auxiliary variable template for the IsVectorizable type trait.The IsVectorizable_v variable template provides a convenient shortcut to access the nested value of the IsVectorizable class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsVoid_v = IsVoid<T>::value |
Auxiliary variable template for the IsVoid type trait.The IsVoid_v variable template provides a convenient shortcut to access the nested value of the IsVoid class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | IsVolatile_v = IsVolatile<T>::value |
Auxiliary variable template for the IsVolatile type trait.The IsVolatile_v variable template provides a convenient shortcut to access the nested value of the IsVolatile class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr size_t | Rank_v = Rank<T>::value |
Auxiliary variable template for the Rank type trait.The Rank_v variable template provides a convenient shortcut to access the nested value of the Rank class template. For instance, given the type T the following two statements are identical: More... | |
template<size_t N> | |
constexpr bool | IsEven_v = IsEven<N>::value |
Auxiliary variable template for the IsEven value trait.The IsEven_v variable template provides a convenient shortcut to access the nested value of the IsEven class template. For instance, given the compile time constant value N the following two statements are identical: More... | |
template<size_t M, size_t N> | |
constexpr bool | IsMultipleOf_v = IsMultipleOf<M,N>::value |
Auxiliary variable template for the IsMultipleOf value trait.The IsMultipleOf_v variable template provides a convenient shortcut to access the nested value of the IsMultipleOf class template. For instance, given the compile time constant values M and N the following two statements are identical: More... | |
template<size_t N> | |
constexpr bool | IsOdd_v = IsOdd<N>::value |
Auxiliary variable template for the IsOdd value trait.The IsOdd_v variable template provides a convenient shortcut to access the nested value of the IsOdd class template. For instance, given the compile time constant value N the following two statements are identical: More... | |
template<size_t B, size_t N> | |
constexpr bool | IsPowerOf_v = IsPowerOf<B,N>::value |
Auxiliary variable template for the IsPowerOf value trait.The IsPowerOf_v variable template provides a convenient shortcut to access the nested value of the IsPowerOf class template. For instance, given the compile time constant values B and N the following two statements are identical: More... | |
Namespace of the Blaze C++ math library.
using blaze::BaseType_t = typedef typename T::BaseType |
Alias declaration for nested BaseType
type definitions.The BaseType_t alias declaration provides a convenient shortcut to access the nested BaseType type definition of the given type T. The following code example shows both ways to access the nested type definition:
using blaze::CompositeType_t = typedef typename T::CompositeType |
Alias declaration for nested CompositeType
type definitions.The CompositeType_t alias declaration provides a convenient shortcut to access the nested CompositeType type definition of the given type T. The following code example shows both ways to access the nested type definition:
using blaze::ConstIterator_t = typedef typename T::ConstIterator |
Alias declaration for nested ConstIterator
type definitions.The ConstIterator_t alias declaration provides a convenient shortcut to access the nested ConstIterator type definition of the given type T. The following code example shows both ways to access the nested type definition:
using blaze::ConstPointer_t = typedef typename T::ConstPointer |
Alias declaration for nested ConstPointer
type definitions.The ConstPointer_t alias declaration provides a convenient shortcut to access the nested ConstPointer type definition of the given type T. The following code example shows both ways to access the nested type definition:
using blaze::ConstReference_t = typedef typename T::ConstReference |
Alias declaration for nested ConstReference
type definitions.The ConstReference_t alias declaration provides a convenient shortcut to access the nested ConstReference type definition of the given type T. The following code example shows both ways to access the nested type definition:
using blaze::ElementType_t = typedef typename T::ElementType |
Alias declaration for nested ElementType
type definitions.The ElementType_t alias declaration provides a convenient shortcut to access the nested ElementType type definition of the given type T. The following code example shows both ways to access the nested type definition:
using blaze::Iterator_t = typedef typename T::Iterator |
Alias declaration for nested Iterator
type definitions.The Iterator_t alias declaration provides a convenient shortcut to access the nested Iterator type definition of the given type T. The following code example shows both ways to access the nested type definition:
using blaze::LeftOperand_t = typedef typename T::LeftOperand |
Alias declaration for nested LeftOperand
type definitions.The LeftOperand_t alias declaration provides a convenient shortcut to access the nested LeftOperand type definition of the given type T. The following code example shows both ways to access the nested type definition:
using blaze::MatrixType_t = typedef typename T::MatrixType |
Alias declaration for nested MatrixType
type definitions.The MatrixType_t alias declaration provides a convenient shortcut to access the nested MatrixType type definition of the given type T. The following code example shows both ways to access the nested type definition:
using blaze::Operand_t = typedef typename T::Operand |
Alias declaration for nested Operand
type definitions.The Operand_t alias declaration provides a convenient shortcut to access the nested Operand type definition of the given type T. The following code example shows both ways to access the nested type definition:
using blaze::OppositeType_t = typedef typename T::OppositeType |
Alias declaration for nested OppositeType
type definitions.The OppositeType_t alias declaration provides a convenient shortcut to access the nested OppositeType type definition of the given type T. The following code example shows both ways to access the nested type definition:
using blaze::Pointer_t = typedef typename T::Pointer |
Alias declaration for nested Pointer
type definitions.The Pointer_t alias declaration provides a convenient shortcut to access the nested Pointer type definition of the given type T. The following code example shows both ways to access the nested type definition:
using blaze::Rebind_t = typedef typename T1::template Rebind<T2>::Other |
Alias declaration for nested Rebind
class templates.The Rebind_t alias declaration provides a convenient shortcut to access the nested Rebind class template of the given type T1. The following code example shows both ways to access the nested class template:
using blaze::Reference_t = typedef typename T::Reference |
Alias declaration for nested Reference
type definitions.The Reference_t alias declaration provides a convenient shortcut to access the nested Reference type definition of the given type T. The following code example shows both ways to access the nested type definition:
using blaze::RepresentedType_t = typedef typename T::RepresentedType |
Alias declaration for nested RepresentedType
type definitions.The RepresentedType_t alias declaration provides a convenient shortcut to access the nested RepresentedType type definition of the given type T. The following code example shows both ways to access the nested type definition:
using blaze::Resize_t = typedef typename T::template Resize<Ns...>::Other |
Alias declaration for nested Resize
class templates.The Resize_t alias declaration provides a convenient shortcut to access the nested Resize class template of the given type T1. The following code example shows both ways to access the nested class template:
using blaze::ResultType_t = typedef typename T::ResultType |
Alias declaration for nested ResultType
type definitions.The ResultType_t alias declaration provides a convenient shortcut to access the nested ResultType type definition of the given type T. The following code example shows both ways to access the nested type definition:
using blaze::ReturnType_t = typedef typename T::ReturnType |
Alias declaration for nested ReturnType
type definitions.The ReturnType_t alias declaration provides a convenient shortcut to access the nested ReturnType type definition of the given type T. The following code example shows both ways to access the nested type definition:
using blaze::RightOperand_t = typedef typename T::RightOperand |
Alias declaration for nested RightOperand
type definitions.The RightOperand_t alias declaration provides a convenient shortcut to access the nested RightOperand type definition of the given type T. The following code example shows both ways to access the nested type definition:
using blaze::SIMDType_t = typedef typename T::SIMDType |
Alias declaration for nested SIMDType
type definitions.The SIMDType_t alias declaration provides a convenient shortcut to access the nested SIMDType type definition of the given type T. The following code example shows both ways to access the nested type definition:
using blaze::TransposeType_t = typedef typename T::TransposeType |
Alias declaration for nested TransposeType
type definitions.The TransposeType_t alias declaration provides a convenient shortcut to access the nested TransposeType type definition of the given type T. The following code example shows both ways to access the nested type definition:
using blaze::ValueType_t = typedef typename T::ValueType |
Alias declaration for nested ValueType
type definitions.The ValueType_t alias declaration provides a convenient shortcut to access the nested ValueType type definition of the given type T. The following code example shows both ways to access the nested type definition:
using blaze::VectorType_t = typedef typename T::VectorType |
Alias declaration for nested VectorType
type definitions.The VectorType_t alias declaration provides a convenient shortcut to access the nested VectorType type definition of the given type T. The following code example shows both ways to access the nested type definition:
using blaze::ViewedType_t = typedef typename T::ViewedType |
Alias declaration for nested ViewedType
type definitions.The ViewedType_t alias declaration provides a convenient shortcut to access the nested ViewedType type definition of the given type T. The following code example shows both ways to access the nested type definition:
DisableIf_t< IsBuiltin_v<T>, T* > blaze::allocate | ( | size_t | size | ) |
Aligned array allocation for user-specific class types.
size | The number of elements of the given type to allocate. |
std::bad_alloc | Allocation failed. |
The allocate() function provides the functionality to allocate memory based on the alignment restrictions of the given user-specific class type. For instance, in case the given type has the requirement to be 32-byte aligned, the returned pointer is guaranteed to be 32-byte aligned. Additionally, all elements of the array are guaranteed to be default constructed. Note that the allocate() function provides exception safety similar to the new operator: In case any element throws an exception during construction, all elements that have already been constructed are destroyed in reverse order and the allocated memory is deallocated again.
DisableIf_t< IsBuiltin_v<T> > blaze::deallocate | ( | T * | address | ) |
Deallocation of memory for user-specific class types.
address | The address of the first element of the array to be deallocated. |
This function deallocates the given memory that was previously allocated via the allocate() function.
void blaze::deserialize | ( | Archive & | archive, |
Vector< VT, TF > & | vec | ||
) |
Deserializes a vector from the given archive.
archive | The archive to be read from. |
vec | The vector to be deserialized. |
std::runtime_error | Vector could not be deserialized. |
The deserialize() function converts the portable, binary representation contained in the given archive into the given vector type. For a detailed example that demonstrates the (de-)serialization process of vectors, see the serialize() function.
void blaze::deserialize | ( | Archive & | archive, |
Matrix< MT, SO > & | mat | ||
) |
Deserializes a matrix from the given archive.
archive | The archive to be read from. |
mat | The matrix to be deserialized. |
std::runtime_error | Matrix could not be deserialized. |
The deserialize() function converts the portable, binary representation contained in the given archive into the given matrix type. For a detailed example that demonstrates the (de-)serialization process of matrices, see the serialize() function.
|
noexcept |
Loads a vector of 2-byte integral values.
address | The first integral value to be loaded. |
This function loads a vector of 2-byte integral values. The given address must be aligned according to the enabled instruction set (16-byte alignment in case of SSE, 32-byte alignment in case of AVX, and 64-byte alignment in case of AVX-512).
|
noexcept |
Loads a vector of 2-byte integral complex values.
address | The first integral complex value to be loaded. |
This function loads a vector of 2-byte integral complex values. The given address must be aligned according to the enabled instruction set (16-byte alignment in case of SSE, 32-byte alignment in case of AVX, and 64-byte alignment in case of AVX-512).
|
noexcept |
Loads a vector of 4-byte integral values.
address | The first integral value to be loaded. |
This function loads a vector of 4-byte integral values. The given address must be aligned according to the enabled instruction set (16-byte alignment in case of SSE, 32-byte alignment in case of AVX, and 64-byte alignment in case of AVX-512/MIC).
|
noexcept |
Loads a vector of 4-byte integral complex values.
address | The first integral complex value to be loaded. |
This function loads a vector of 4-byte integral complex values. The given address must be aligned according to the enabled instruction set (16-byte alignment in case of SSE, 32-byte alignment in case of AVX, and 64-byte alignment in case of AVX-512/MIC).
|
noexcept |
Loads a vector of 8-byte integral values.
address | The first integral value to be loaded. |
This function loads a vector of 8-byte integral values. The given address must be aligned according to the enabled instruction set (16-byte alignment in case of SSE, 32-byte alignment in case of AVX, and 64-byte alignment in case of AVX-512/MIC).
|
noexcept |
Loads a vector of 8-byte integral complex values.
address | The first integral complex value to be loaded. |
This function loads a vector of 8-byte integral complex values. The given address must be aligned according to the enabled instruction set (16-byte alignment in case of SSE, 32-byte alignment in case of AVX, and 64-byte alignment in case of AVX-512/MIC).
|
noexcept |
Loads a vector of 2-byte integral values.
address | The first integral value to be loaded. |
This function loads a vector of 2-byte integral values. In contrast to the according loada()
function, the given address is not required to be properly aligned.
|
noexcept |
Loads a vector of 2-byte integral complex values.
address | The first integral complex value to be loaded. |
This function loads a vector of 2-byte integral complex values. In contrast to the according loada()
function, the given address is not required to be properly aligned.
|
noexcept |
Loads a vector of 4-byte integral values.
address | The first integral value to be loaded. |
This function loads a vector of 4-byte integral values. In contrast to the according loada()
function, the given address is not required to be properly aligned.
|
noexcept |
Loads a vector of 4-byte integral complex values.
address | The first integral complex value to be loaded. |
This function loads a vector of 4-byte integral complex values. In contrast to the according loada()
function, the given address is not required to be properly aligned.
|
noexcept |
Loads a vector of 8-byte integral values.
address | The first integral value to be loaded. |
This function loads a vector of 8-byte integral values. In contrast to the according loada()
function, the given address is not required to be properly aligned.
|
noexcept |
Loads a vector of 8-byte integral complex values.
address | The first integral complex value to be loaded. |
This function loads a vector of 8-byte integral complex values. In contrast to the according loada()
function, the given address is not required to be properly aligned.
|
inline |
Normalization of the sparse vector ( ).
vec | The given sparse vector. |
This function represents the normalization of a sparse vector:
The function returns an expression representing the normalized sparse vector. Note that this function only works for floating point vectors. The attempt to use this function for an integral vector results in a compile time error.
|
inline |
Normalization of the dense vector ( ).
vec | The given dense vector. |
This function represents the normalization of a dense vector:
The function returns an expression representing the normalized dense vector. Note that this function only works for floating point vectors. The attempt to use this function for an integral vector results in a compile time error.
|
inline |
Inequality comparison between two UnsignedValue objects.
lhs | The left-hand side UnsignedValue wrapper. |
rhs | The right-hand side UnsignedValue wrapper. |
|
inlinenoexcept |
Inequality comparison between two AlignedAllocator objects.
lhs | The left-hand side aligned allocator. |
rhs | The right-hand side aligned allocator. |
|
inlinenoexcept |
Inequality comparison between two InitializerIterator objects.
lhs | The left-hand side iterator. |
rhs | The right-hand side iterator. |
|
inlinenoexcept |
Inequality comparison between two UniformIterator objects.
lhs | The left-hand side iterator. |
rhs | The right-hand side iterator. |
|
inlinenoexcept |
Inequality comparison between two DenseIterator objects.
lhs | The left-hand side iterator. |
rhs | The right-hand side iterator. |
|
inlinenoexcept |
Addition between a InitializerIterator and an integral value.
it | The iterator to be incremented. |
inc | The number of elements the iterator is incremented. |
|
inlinenoexcept |
Addition between an integral value and a InitializerIterator.
inc | The number of elements the iterator is incremented. |
it | The iterator to be incremented. |
|
inlinenoexcept |
Addition between a UniformIterator and an integral value.
it | The iterator to be incremented. |
inc | The number of elements the iterator is incremented. |
|
inlinenoexcept |
Addition between an integral value and a UniformIterator.
inc | The number of elements the iterator is incremented. |
it | The iterator to be incremented. |
|
inlinenoexcept |
Addition between a DenseIterator and an integral value.
it | The iterator to be incremented. |
inc | The number of elements the iterator is incremented. |
|
inlinenoexcept |
Addition between an integral value and a DenseIterator.
inc | The number of elements the iterator is incremented. |
it | The iterator to be incremented. |
|
inlinenoexcept |
Subtraction between a InitializerIterator and an integral value.
it | The iterator to be decremented. |
dec | The number of elements the iterator is decremented. |
|
inlinenoexcept |
Calculating the number of elements between two iterators.
lhs | The left-hand side iterator. |
rhs | The right-hand side iterator. |
|
inlinenoexcept |
Subtraction between a UniformIterator and an integral value.
it | The iterator to be decremented. |
dec | The number of elements the iterator is decremented. |
|
inlinenoexcept |
Calculating the number of elements between two UniformIterator objects.
lhs | The left-hand side iterator. |
rhs | The right-hand side iterator. |
|
inlinenoexcept |
Subtraction between a DenseIterator and an integral value.
it | The iterator to be decremented. |
dec | The number of elements the iterator is decremented. |
|
inlinenoexcept |
Calculating the number of elements between two DenseIterator objects.
lhs | The left-hand side iterator. |
rhs | The right-hand side iterator. |
|
inline |
Less-than comparison between two UnsignedValue objects.
lhs | The left-hand side UnsignedValue wrapper. |
rhs | The right-hand side UnsignedValue wrapper. |
|
inlinenoexcept |
Less-than comparison between two InitializerIterator objects.
lhs | The left-hand side iterator. |
rhs | The right-hand side iterator. |
|
inlinenoexcept |
Less-than comparison between two UniformIterator objects.
lhs | The left-hand side iterator. |
rhs | The right-hand side iterator. |
|
inlinenoexcept |
Less-than comparison between two DenseIterator objects.
lhs | The left-hand side iterator. |
rhs | The right-hand side iterator. |
|
inline |
Global output operator for the UnsignedValue wrapper.
os | Reference to the output stream. |
uv | Reference to a UnsignedValue object. |
|
inline |
Less-or-equal-than comparison between two UnsignedValue objects.
lhs | The left-hand side UnsignedValue wrapper. |
rhs | The right-hand side UnsignedValue wrapper. |
|
inlinenoexcept |
Less-than comparison between two InitializerIterator objects.
lhs | The left-hand side iterator. |
rhs | The right-hand side iterator. |
|
inline |
Less-or-equal-than comparison between a NegativeEpsilon object and a floating point value.
rhs | The right-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Less-or-equal-than comparison between a NegativeAccuracy object and a floating point value.
rhs | The right-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Less-or-equal-than comparison between a floating point value and a NegativeEpsilon object.
lhs | The left-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Less-or-equal-than comparison between a floating point value and a NegativeAccuracy object.
lhs | The left-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inlinenoexcept |
Less-or-equal-than comparison between two UniformIterator objects.
lhs | The left-hand side iterator. |
rhs | The right-hand side iterator. |
|
inlinenoexcept |
Less-or-equal-than comparison between two DenseIterator objects.
lhs | The left-hand side iterator. |
rhs | The right-hand side iterator. |
|
inline |
Equality comparison between two UnsignedValue objects.
lhs | The left-hand side UnsignedValue wrapper. |
rhs | The right-hand side UnsignedValue wrapper. |
|
inlinenoexcept |
Equality comparison between two AlignedAllocator objects.
lhs | The left-hand side aligned allocator. |
rhs | The right-hand side aligned allocator. |
|
inlinenoexcept |
Equality comparison between two InitializerIterator objects.
lhs | The left-hand side iterator. |
rhs | The right-hand side iterator. |
|
inlinenoexcept |
Equality comparison between two UniformIterator objects.
lhs | The left-hand side iterator. |
rhs | The right-hand side iterator. |
|
inlinenoexcept |
Equality comparison between two DenseIterator objects.
lhs | The left-hand side iterator. |
rhs | The right-hand side iterator. |
|
inline |
Greater-than comparison between two UnsignedValue objects.
lhs | The left-hand side UnsignedValue wrapper. |
rhs | The right-hand side UnsignedValue wrapper. |
|
inlinenoexcept |
Greater-than comparison between two InitializerIterator objects.
lhs | The left-hand side iterator. |
rhs | The right-hand side iterator. |
|
inlinenoexcept |
Greater-than comparison between two UniformIterator objects.
lhs | The left-hand side iterator. |
rhs | The right-hand side iterator. |
|
inlinenoexcept |
Greater-than comparison between two DenseIterator objects.
lhs | The left-hand side iterator. |
rhs | The right-hand side iterator. |
|
inline |
Greater-or-equal-than comparison between two UnsignedValue objects.
lhs | The left-hand side UnsignedValue wrapper. |
rhs | The right-hand side UnsignedValue wrapper. |
|
inlinenoexcept |
Greater-than comparison between two InitializerIterator objects.
lhs | The left-hand side iterator. |
rhs | The right-hand side iterator. |
|
inline |
Greater-or-equal-than comparison between a NegativeEpsilon object and a floating point value.
rhs | The right-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Greater-or-equal-than comparison between a NegativeAccuracy object and a floating point value.
rhs | The right-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Less-or-equal-than comparison between a floating point value and a NegativeEpsilon object.
lhs | The left-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Less-or-equal-than comparison between a floating point value and a NegativeAccuracy object.
lhs | The left-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inlinenoexcept |
Greater-or-equal-than comparison between two UniformIterator objects.
lhs | The left-hand side iterator. |
rhs | The right-hand side iterator. |
|
inlinenoexcept |
Greater-or-equal-than comparison between two DenseIterator objects.
lhs | The left-hand side iterator. |
rhs | The right-hand side iterator. |
std::istream & blaze::operator>> | ( | std::istream & | is, |
UnsignedValue< T > & | uv | ||
) |
Global input operator for the UnsignedValue wrapper.
is | Reference to the input stream. |
uv | Reference to a UnsignedValue object. |
The input operator guarantees that this object is not changed in the case of an input error. Only values suitable for the according built-in unsigned integral data type T are allowed. Otherwise, the input stream's position is returned to its previous position and the std::istream::failbit is set.
void blaze::serialize | ( | Archive & | archive, |
const Vector< VT, TF > & | vec | ||
) |
Serializes the given vector and writes it to the archive.
archive | The archive to be written. |
vec | The vector to be serialized. |
std::runtime_error | Error during serialization. |
The serialize() function converts the given vector into a portable, binary representation. The following example demonstrates the (de-)serialization process of vectors:
As the example demonstrates, the vector serialization offers an enormous flexibility. However, several actions result in errors:
In case an error is encountered during (de-)serialization, a std::runtime_exception is thrown.
void blaze::serialize | ( | Archive & | archive, |
const Matrix< MT, SO > & | mat | ||
) |
Serializes the given matrix and writes it to the archive.
archive | The archive to be written. |
mat | The matrix to be serialized. |
std::runtime_error | Matrix could not be serialized. |
The serialize() function converts the given matrix into a portable, binary representation. The following example demonstrates the (de-)serialization process of matrices:
As the example demonstrates, the matrix serialization offers an enormous flexibility. However, several actions result in errors:
In case an error is encountered during (de-)serialization, a std::runtime_exception is thrown.
|
noexcept |
Sets all values in the vector to the given 2-byte integral value.
value | The given 2-byte integral value. |
|
noexcept |
Sets all values in the vector to the given 2-byte integral complex value.
value | The given 2-byte integral complex value. |
|
noexcept |
Sets all values in the vector to the given 4-byte integral value.
value | The given 4-byte integral value. |
|
noexcept |
Sets all values in the vector to the given 4-byte integral complex value.
value | The given 4-byte integral complex value. |
|
noexcept |
Sets all values in the vector to the given 8-byte integral value.
value | The given 8-byte integral value. |
|
noexcept |
Sets all values in the vector to the given 8-byte integral complex value.
value | The given 8-byte integral complex value. |
constexpr bool blaze::columnMajor = true |
Storage order flag for column-major matrices.
Via this flag it is possible to specify the storage order of matrices as column-major. For instance, given the following matrix
in case of column-major order the elements are stored in the order
The following example demonstrates the setup of this matrix:
constexpr bool blaze::columnVector = false |
Transpose flag for column vectors.
Via this flag it is possible to specify vectors as column vectors. The following example demonstrates the setup of a 3-dimensional column vector:
constexpr size_t blaze::columnwise = 0UL |
Reduction flag for column-wise reduction operations.
This flag can be used to perform column-wise reduction operations on matrices. The following example shows the column-wise summation of a column-major matrix:
constexpr bool blaze::relaxed = true |
Relaxation flag for relaxed semantics.
Via this flag it is possible to specify that according operations should use relaxed semantics instead of strict semantics. The following example demonstrates this by means of the isDefault() function template:
constexpr bool blaze::rowMajor = false |
Storage order flag for row-major matrices.
Via this flag it is possible to specify the storage order of matrices as row-major. For instance, given the following matrix
in case of row-major order the elements are stored in the order
The following example demonstrates the setup of this matrix:
constexpr bool blaze::rowVector = true |
Transpose flag for row vectors.
Via this flag it is possible to specify vectors as row vectors. The following example demonstrates the setup of a 3-dimensional row vector:
constexpr size_t blaze::rowwise = 1UL |
Reduction flag for row-wise reduction operations.
This flag can be used to perform row-wise reduction operations on matrices. The following example shows the row-wise summation of a row-major matrix:
constexpr bool blaze::strict = false |
Relaxation flag for strict semantics.
Via this flag it is possible to specify that according operations should use strict semantics instead of relaxed semantics. The following example demonstrates this by means of the isDefault() function template: