Namespaces | Classes | Typedefs | Enumerations | Functions | Variables
blaze Namespace Reference

Namespace of the Blaze C++ math library. More...

Namespaces

 logging
 Namespace for the logging module.
 
 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  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 from this class in order to qualify as addition expression template. Only in case a class is derived from the AddExpr base class, the IsAddExpr type trait recognizes the class as valid addition expression template. More...
 
struct  AddExprTrait
 Evaluation of the return type of an addition expression.Via this type trait it is possible to evaluate the return type of an addition expression between scalars, vectors, and matrices. Given the two types T1 and T2, which must either be scalar, vector, or matrix types, the nested type Type corresponds to the resulting return type. In case the types of T1 or T2 don't fit or if the two types cannot be added, the resulting data type Type is set to INVALID_TYPE. 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  And
 Compile time logical and evaluation.The And class template performs at compile time a logical and ('&&') evaluation of at least two compile time conditions: 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...
 
class  Append
 Appending a type to a type list.The Append class can be used to append the data type Type to a type list TList. 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  AreSIMDCombinable
 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  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  Atan
 Generic wrapper for the atan() function. More...
 
struct  Atanh
 Generic wrapper for the atanh() function. More...
 
struct  Bool
 Compile time integral constant wrapper for bool.The Bool class template represents an integral wrapper for a compile time constant expression of type bool. The value of a Bool 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...
 
struct  Cbrt
 Generic wrapper for the cbrt() function. More...
 
struct  Ceil
 Generic wrapper for the ceil() function. More...
 
struct  Char
 Compile time integral constant wrapper for char.The Char class template represents an integral wrapper for a compile time constant expression of type char. The value of an Char 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...
 
struct  Clip
 Generic wrapper for the clip() function. More...
 
class  Column
 Reference to a specific column of a dense or sparse matrix.The Column template represents a reference to a specific column of a dense or sparse matrix primitive. The type of the matrix is specified via the first template parameter: More...
 
struct  ColumnExprTrait
 Evaluation of the expression type type of a column operation.Via this type trait it is possible to evaluate the return type of a column operation. Given the dense or sparse matrix type MT, the nested type Type corresponds to the resulting return type. In case the given type is neither a dense nor a sparse matrix type, the resulting data type Type is set to INVALID_TYPE. More...
 
struct  Columns
 Compile time evaluation of the number of columns of a matrix.The Columns type trait evaluates the number of columns of the given matrix type at compile time. In case the given type T is a matrix type with a fixed number of columns (e.g. StaticMatrix), the value member constant is set to the according number of columns. In all other cases, value is set to 0. 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 $ M \times N $ compressed matrix.The CompressedMatrix class template is the representation of an arbitrary sized sparse matrix with $ M \cdot N $ dynamically allocated 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  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  ConstantGrowth
 Constant growth policy class.The ConstantGrowth policy class implements a constant growth strategy. It can be customized for any purpose: the Growth template argument specifies the constant increase of the given size. More...
 
class  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 1, else it is set to 0. 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...
 
class  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 1, else it is set to 0. 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 from this class in order to qualify as cross product expression template. Only in case a class is derived from the CrossExpr base class, the IsCrossExpr type trait recognizes the class as valid cross product expression template. More...
 
struct  CrossExprTrait
 Evaluation of the return type of a cross product expression.Via this type trait it is possible to evaluate the return type of a cross product expression. Given the two types T1 and T2, which must be dense or sparse column vectors, the nested type Type corresponds to the resulting return type. In case the types of T1 or T2 don't fit or if the two types cannot be used in a cross product, the resulting data type Type is set to INVALID_TYPE. More...
 
struct  CrossTrait
 Base template for the CrossTrait class. More...
 
struct  CTrans
 Generic wrapper for the ctrans() function. More...
 
struct  CTransExprTrait
 Evaluation of the return type of a conjugate transpose expression.Via this type trait it is possible to evaluate the return type of a conjugate transpose expression. Given the type T, which must either be a vector or matrix type, the nested type Type corresponds to the resulting return type. In case the type of T doesn't fit or if no conjugate transpose operation exists for the type, the resulting data type Type is set to INVALID_TYPE. 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  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 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 $ N \times N $ matrices. More...
 
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 $ 3 \times 3 $ dense diagonal matrix: More...
 
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  DisableIfTrue
 Substitution Failure Is Not An Error (SFINAE) class.The DisableIfTrue 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  DivExpr
 Base class for all division expression templates.The DivExpr class serves as a tag for all expression templates that implement mathematical divisions. All classes, that represent a mathematical division (vector/scalar divisions and matrix/scalar division) and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as division expression template. Only in case a class is derived from the DivExpr base class, the IsDivExpr type trait recognizes the class as valid division expression template. More...
 
struct  DivExprTrait
 Evaluation of the resulting expression type of a division.Via this type trait it is possible to evaluate the return type of a division expression between scalars, vectors, and matrices. Given the two types T1 and T2, where T1 must either be a scalar, vector, or matrix type and T2 which must be a scalar type, the nested type Type corresponds to the resulting return type. In case T1 or T2 don't fit or if the two types cannot be divided, the resulting data type Type is set to INVALID_TYPE. More...
 
struct  DivTrait
 Base template for the DivTrait class. More...
 
struct  DMatCTransExprTrait
 Evaluation of the expression type of a dense matrix conjugate transpose operation.Via this type trait it is possible to evaluate the resulting expression type of a dense matrix conjugate transpose operation. Given the row-major dense matrix type MT, the nested type Type corresponds to the resulting expression type. In case MT is not a row-major dense matrix type, the resulting Type is set to INVALID_TYPE. 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...
 
struct  DMatDMatAddExprTrait
 Evaluation of the expression type of a dense matrix/dense matrix addition.Via this type trait it is possible to evaluate the resulting expression type of a dense matrix/dense matrix addition. Given the two row-major dense matrix types MT1 and MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 or MT2 is not a row-major dense matrix, the resulting data type Type is set to INVALID_TYPE. 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...
 
struct  DMatDMatMultExprTrait
 Evaluation of the expression type of a dense matrix/dense matrix multiplication.Via this type trait it is possible to evaluate the resulting expression type of a dense matrix/dense matrix multiplication. Given the two row-major dense matrix types MT1 and MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 or MT2 is not a row-major dense matrix, the resulting data type Type is set to INVALID_TYPE. 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...
 
struct  DMatDMatSubExprTrait
 Evaluation of the expression type of a dense matrix/dense matrix subtraction.Via this type trait it is possible to evaluate the resulting expression type of a dense matrix/dense matrix subtraction. Given the two row-major dense matrix types MT1 and MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 or MT2 is not a row-major dense matrix, the resulting data type Type is set to INVALID_TYPE. 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...
 
struct  DMatDVecMultExprTrait
 Evaluation of the expression type of a dense matrix/dense vector multiplication.Via this type trait it is possible to evaluate the resulting expression type of a dense matrix/dense vector multiplication. Given the row-major dense matrix type MT and the non-transpose dense vector type VT, the nested type Type corresponds to the resulting expression type. In case either MT is not a row-major dense matrix type or VT is not a non-transpose dense vector type, the resulting data type Type is set to INVALID_TYPE. 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...
 
struct  DMatEvalExprTrait
 Evaluation of the expression type of a dense matrix evaluation operation.Via this type trait it is possible to evaluate the resulting expression type of a dense matrix evaluation operation. Given the row-major dense matrix type MT, the nested type Type corresponds to the resulting expression type. In case MT is not a row-major dense matrix type, the resulting Type is set to INVALID_TYPE. More...
 
class  DMatForEachExpr
 Expression object for the dense matrix forEach() function.The DMatForEachExpr class represents the compile time expression for the evaluation of a custom operation on each element of a dense matrix via the forEach() function. More...
 
struct  DMatForEachExprTrait
 Evaluation of the expression type of a dense matrix custom operation.Via this type trait it is possible to evaluate the resulting expression type of a dense matrix custom operation. Given the row-major dense matrix type MT and the custom operation type OP, the nested type Type corresponds to the resulting expression type. In case MT is not a row-major dense matrix type, the resulting Type is set to INVALID_TYPE. More...
 
class  DMatInvExpr
 Expression object for dense matrix inversions.The DMatInvExpr class represents the compile time expression for inversions of dense matrices. More...
 
struct  DMatInvExprTrait
 Evaluation of the expression type of a dense matrix inversion operation.Via this type trait it is possible to evaluate the resulting expression type of a dense matrix inversion operation. Given the row-major dense matrix type MT, the nested type Type corresponds to the resulting expression type. In case MT is not a row-major dense matrix type, the resulting Type is set to INVALID_TYPE. 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...
 
struct  DMatScalarDivExprTrait
 Evaluation of the expression type of a dense matrix/scalar division.Via this type trait it is possible to evaluate the resulting expression type of a dense matrix/scalar division. Given the row-major dense matrix type MT and the scalar type ST, the nested type Type corresponds to the resulting expression type. In case either MT is not a row-major dense matrix type or ST is not a scalar type, the resulting Type is set to INVALID_TYPE. 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...
 
struct  DMatScalarMultExprTrait
 Evaluation of the expression type of a dense matrix/scalar multiplication.Via this type trait it is possible to evaluate the resulting expression type of a dense matrix/scalar multiplication. Given the row-major dense matrix type MT and the scalar type ST, the nested type Type corresponds to the resulting expression type. In case either MT is not a row-major dense matrix type or ST is not a scalar type, the resulting Type is set to INVALID_TYPE. 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...
 
struct  DMatSerialExprTrait
 Evaluation of the expression type of a dense matrix serial evaluation operation.Via this type trait it is possible to evaluate the resulting expression type of a dense matrix serial evaluation operation. Given the row-major dense matrix type MT, the nested type Type corresponds to the resulting expression type. In case MT is not a row-major dense matrix type, the resulting Type is set to INVALID_TYPE. 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...
 
struct  DMatSMatAddExprTrait
 Evaluation of the expression type of a dense matrix/sparse matrix addition.Via this type trait it is possible to evaluate the resulting expression type of a dense matrix/sparse matrix addition. Given the row-major dense matrix type MT1 and the row-major sparse matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a row-major dense matrix type or MT2 is not a row-major sparse matrix type, the resulting data type Type is set to INVALID_TYPE. 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...
 
struct  DMatSMatMultExprTrait
 Evaluation of the expression type of a dense matrix/sparse matrix multiplication.Via this type trait it is possible to evaluate the resulting expression type of a dense matrix/sparse matrix multiplication. Given the row-major dense matrix type MT1 and the row-major sparse matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a row-major dense matrix type or MT2 is not a row-major sparse matrix type, the resulting data type Type is set to INVALID_TYPE. 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...
 
struct  DMatSMatSubExprTrait
 Evaluation of the expression type of a dense matrix/sparse matrix subtraction.Via this type trait it is possible to evaluate the resulting expression type of a dense matrix/sparse matrix subtraction. Given the row-major dense matrix type MT1 and the row-major sparse matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a row-major dense matrix type or MT2 is not a row-major sparse matrix type, the resulting data type Type is set to INVALID_TYPE. 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...
 
struct  DMatSVecMultExprTrait
 Evaluation of the expression type of a dense matrix/sparse vector multiplication.Via this type trait it is possible to evaluate the resulting expression type of a dense matrix/sparse vector multiplication. Given the row-major dense matrix type MT and the non-transpose sparse vector type VT, the nested type Type corresponds to the resulting expression type. In case either MT is not a row-major dense matrix type or VT is not a non-transpose sparse vector type, the resulting data type Type is set to INVALID_TYPE. 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...
 
struct  DMatTDMatAddExprTrait
 Evaluation of the expression type of a dense matrix/transpose dense matrix addition.Via this type trait it is possible to evaluate the resulting expression type of a dense matrix/transpose dense matrix addition. Given the row-major dense matrix type MT1 and the column-major dense matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a row-major dense matrix type or MT2 is not a column-major dense matrix type, the resulting data type Type is set to INVALID_TYPE. 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...
 
struct  DMatTDMatMultExprTrait
 Evaluation of the expression type of a dense matrix/transpose dense matrix multiplication.Via this type trait it is possible to evaluate the resulting expression type of a dense matrix/transpose dense matrix multiplication. Given the row-major dense matrix type MT1 and the column-major dense matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a row-major dense matrix type or MT2 is not a column-major dense matrix type, the resulting data type Type is set to INVALID_TYPE. 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...
 
struct  DMatTDMatSubExprTrait
 Evaluation of the expression type of a dense matrix/transpose dense matrix subtraction.Via this type trait it is possible to evaluate the resulting expression type of a dense matrix/transpose dense matrix subtraction. Given the row-major dense matrix type MT1 and the column-major dense matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a row-major dense matrix type or MT2 is not a column-major dense matrix type, the resulting data type Type is set to INVALID_TYPE. More...
 
class  DMatTransExpr
 Expression object for dense matrix transpositions.The DMatTransExpr class represents the compile time expression for transpositions of dense matrices. More...
 
struct  DMatTransExprTrait
 Evaluation of the expression type of a dense matrix transpose operation.Via this type trait it is possible to evaluate the resulting expression type of a dense matrix transpose operation. Given the row-major dense matrix type MT, the nested type Type corresponds to the resulting expression type. In case MT is not a row-major dense matrix type, the resulting Type is set to INVALID_TYPE. 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...
 
struct  DMatTSMatAddExprTrait
 Evaluation of the expression type of a dense matrix/transpose sparse matrix addition.Via this type trait it is possible to evaluate the resulting expression type of a dense matrix/transpose sparse matrix addition. Given the row-major dense matrix type MT1 and the column-major sparse matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a row-major dense matrix type or MT2 is not a column-major sparse matrix type, the resulting data type Type is set to INVALID_TYPE. 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...
 
struct  DMatTSMatMultExprTrait
 Evaluation of the expression type of a dense matrix/transpose sparse matrix multiplication.Via this type trait it is possible to evaluate the resulting expression type of a dense matrix/ transpose sparse matrix multiplication. Given the row-major dense matrix type MT1 and the column-major sparse matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a row-major dense matrix type or MT2 is not a column-major sparse matrix type, the resulting data type Type is set to INVALID_TYPE. 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...
 
struct  DMatTSMatSubExprTrait
 Evaluation of the expression type of a dense matrix/transpose sparse matrix subtraction.Via this type trait it is possible to evaluate the resulting expression type of a dense matrix/ transpose sparse matrix subtraction. Given the row-major dense matrix type MT1 and the column-major sparse matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a row-major dense matrix type or MT2 is not a column-major sparse matrix type, the resulting data type Type is set to INVALID_TYPE. More...
 
struct  DVecCTransExprTrait
 Evaluation of the expression type of a dense vector conjugate transpose operation.Via this type trait it is possible to evaluate the resulting expression type of a dense vector conjugate transpose operation. Given the non-transpose dense vector type VT, the nested type Type corresponds to the resulting expression type. In case VT is not a non-transpose dense vector type, the resulting Type is set to INVALID_TYPE. 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...
 
struct  DVecDVecAddExprTrait
 Evaluation of the expression type of a dense vector/dense vector addition.Via this type trait it is possible to evaluate the resulting expression type of a dense vector/dense vector addition. Given the two non-transpose dense vector types VT1 and VT2, the nested type Type corresponds to the resulting expression type. In case either VT1 or VT2 is not a non-transpose dense vector type, the resulting Type is set to INVALID_TYPE. 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...
 
struct  DVecDVecCrossExprTrait
 Evaluation of the expression type of a dense vector/dense vector cross product.Via this type trait it is possible to evaluate the resulting expression type of a dense vector/dense vector cross product. Given the two non-transpose dense vector types VT1 and VT2, the nested type Type corresponds to the resulting expression type. In case either VT1 or VT2 is not a non-transpose dense vector type, the resulting Type is set to INVALID_TYPE. 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...
 
struct  DVecDVecDivExprTrait
 Evaluation of the expression type of a dense vector/dense vector division.Via this type trait it is possible to evaluate the resulting expression type of a dense vector/dense vector division. Given the two non-transpose dense vector types VT1 and VT2, the nested type Type corresponds to the resulting expression type. In case either VT1 or VT2 is not a non-transpose dense vector type, the resulting Type is set to INVALID_TYPE. 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...
 
struct  DVecDVecMultExprTrait
 Evaluation of the expression type of a dense vector/dense vector multiplication.Via this type trait it is possible to evaluate the resulting expression type of a dense vector/dense vector multiplication. Given the two non-transpose dense vector types VT1 and VT2, the nested type Type corresponds to the resulting expression type. In case either VT1 or VT2 is not a non-transpose dense vector type, the resulting Type is set to INVALID_TYPE. 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...
 
struct  DVecDVecSubExprTrait
 Evaluation of the expression type of a dense vector/dense vector subtraction.Via this type trait it is possible to evaluate the resulting expression type of a dense vector/dense vector subtraction. Given the two non-transpose dense vector types VT1 and VT2, the nested type Type corresponds to the resulting expression type. In case either VT1 or VT2 is not a non-transpose dense vector type, the resulting Type is set to INVALID_TYPE. 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...
 
struct  DVecEvalExprTrait
 Evaluation of the expression type of a dense vector evaluation operation.Via this type trait it is possible to evaluate the resulting expression type of a dense vector evaluation operation. Given the non-transpose dense vector type VT, the nested type Type corresponds to the resulting expression type. In case VT is not a non-transpose dense vector type, the resulting Type is set to INVALID_TYPE. More...
 
class  DVecForEachExpr
 Expression object for the dense vector forEach() function.The DVecForEachExpr class represents the compile time expression for the evaluation of a custom operation on each element of a dense vector via the forEach() function. More...
 
struct  DVecForEachExprTrait
 Evaluation of the expression type of a dense vector custom operation.Via this type trait it is possible to evaluate the resulting expression type of a dense vector custom operation. Given the non-transpose dense vector type VT and the custom operation type OP, the nested type Type corresponds to the resulting expression type. In case VT is not a non-transpose dense vector type, the resulting Type is set to INVALID_TYPE. 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...
 
struct  DVecScalarDivExprTrait
 Evaluation of the expression type of a dense vector/scalar division.Via this type trait it is possible to evaluate the resulting expression type of a dense vector/scalar division. Given the non-transpose dense vector type VT and the scalar type ST, the nested type Type corresponds to the resulting expression type. In case either VT is not a non-transpose dense vector type or ST is not a scalar type, the resulting Type is set to INVALID_TYPE. 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...
 
struct  DVecScalarMultExprTrait
 Evaluation of the expression type of a dense vector/scalar multiplication.Via this type trait it is possible to evaluate the resulting expression type of a dense vector/scalar multiplication. Given the non-transpose dense vector type VT and the scalar type ST, the nested type Type corresponds to the resulting expression type. In case either VT is not a non-transpose dense vector type or ST is not a scalar type, the resulting Type is set to INVALID_TYPE. 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...
 
struct  DVecSerialExprTrait
 Evaluation of the expression type of a dense vector serial evaluation operation.Via this type trait it is possible to evaluate the resulting expression type of a dense vector serial evaluation operation. Given the non-transpose dense vector type VT, the nested type Type corresponds to the resulting expression type. In case VT is not a non-transpose dense vector type, the resulting Type is set to INVALID_TYPE. 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...
 
struct  DVecSVecAddExprTrait
 Evaluation of the expression type of a dense vector/sparse vector addition.Via this type trait it is possible to evaluate the resulting expression type of a dense vector/sparse vector addition. Given the non-transpose dense vector type VT1 and the non-transpose sparse vector type VT2, the nested type Type corresponds to the resulting expression type. In case either VT1 is not a non-transpose dense vector type or VT2 is not a non-transpose sparse vector type, the resulting Type is set to INVALID_TYPE. 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...
 
struct  DVecSVecCrossExprTrait
 Evaluation of the expression type of a dense vector/sparse vector cross product.Via this type trait it is possible to evaluate the resulting expression type of a dense vector/sparse vector cross product. Given the non-transpose dense vector type VT1 and the non-transpose sparse vector typeVT2, the nested type Type corresponds to the resulting expression type. In case either VT1 is not a non-transpose dense vector type or VT2 is not a non-transpose sparse vector type, the resulting Type is set to INVALID_TYPE. 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...
 
struct  DVecSVecMultExprTrait
 Evaluation of the expression type of a dense vector/sparse vector multiplication.Via this type trait it is possible to evaluate the resulting expression type of a dense vector/sparse vector multiplication. Given the non-transpose dense vector type VT1 and the non-transpose sparse vector typeVT2, the nested type Type corresponds to the resulting expression type. In case either VT1 is not a non-transpose dense vector type or VT2 is not a non-transpose sparse vector type, the resulting Type is set to INVALID_TYPE. 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...
 
struct  DVecSVecSubExprTrait
 Evaluation of the expression type of a dense vector/sparse vector subtraction.Via this type trait it is possible to evaluate the resulting expression type of a dense vector/sparse vector subtraction. Given the non-transpose dense vector type VT1 and the non-transpose sparse vector typeVT2, the nested type Type corresponds to the resulting expression type. In case either VT1 is not a non-transpose dense vector type or VT2 is not a non-transpose sparse vector type, the resulting Type is set to INVALID_TYPE. More...
 
class  DVecTDVecMultExpr
 Expression object for outer products between two dense vectors.The DVecTDVecMultExpr class represents the compile time expression for outer products between dense vectors. More...
 
struct  DVecTDVecMultExprTrait
 Evaluation of the expression type of a dense vector/transpose dense vector multiplication.Via this type trait it is possible to evaluate the resulting expression type of a dense vector/transpose dense vector multiplication (outer product). Given the non-transpose dense vector type VT1 and the transpose dense vector type VT2, the nested type Type corresponds to the resulting expression type. In case either VT1 is not a non-transpose dense vector type or VT2 is not a transpose dense vector type, the resulting Type is set to INVALID_TYPE. More...
 
class  DVecTransExpr
 Expression object for dense vector transpositions.The DVecTransExpr class represents the compile time expression for transpositions of dense vectors. More...
 
struct  DVecTransExprTrait
 Evaluation of the expression type of a dense vector transpose operation.Via this type trait it is possible to evaluate the resulting expression type of a dense vector transpose operation. Given the non-transpose dense vector type VT, the nested type Type corresponds to the resulting expression type. In case VT is not a non-transpose dense vector type, the resulting Type is set to INVALID_TYPE. 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  DVecTSVecMultExpr
 Expression object for dense vector-sparse vector outer products.The DVecTSVecMultExpr class represents the compile time expression for dense vector-sparse vector outer products. More...
 
struct  DVecTSVecMultExprTrait
 Evaluation of the expression type of a dense vector/transpose sparse vector multiplication.Via this type trait it is possible to evaluate the resulting expression type of a dense vector/transpose sparse vector multiplication (outer product). Given the non-transpose dense vector type VT1 and the transpose sparse vector type VT2, the nested type Type corresponds to the resulting expression type. In case either VT1 is not a non-transpose dense vector type or VT2 is not a transpose sparse vector type, the resulting Type is set to INVALID_TYPE. More...
 
class  DynamicMatrix
 Efficient implementation of a dynamic $ M \times N $ matrix.The DynamicMatrix class template is the representation of an arbitrary sized matrix with $ M \times N $ dynamically allocated 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  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  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...
 
struct  EnableIfTrue
 Substitution Failure Is Not An Error (SFINAE) class.The EnableIfTrue 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  Equal
 Compile time type comparison.The Equal class 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...
 
class  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 Type from a type list TList. 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...
 
class  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 from this class in order to qualify as evaluation expression template. Only in case a class is derived from the EvalExpr base class, the IsEvalExpr type trait recognizes the class as valid evaluation expression template. More...
 
struct  EvalExprTrait
 Evaluation of the return type of an evaluation expression.Via this type trait it is possible to evaluate the return type of an evaluation expression. Given the type T, which must either be a vector or matrix type, the nested type Type corresponds to the resulting return type. In case the type of T doesn't fit or if no evaluation operation exists for the type, the resulting data type Type is set to INVALID_TYPE. More...
 
struct  Exp
 Generic wrapper for the exp() function. More...
 
struct  Expression
 Base class for all expression templates.The Expression class is the base class for all expression templates. All classes, that represent a mathematical operation and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as expression template. Only in case a class is derived from the Expression base class, the IsExpression type trait recognizes the class as valid expression template. More...
 
struct  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...
 
struct  ForEachExpr
 Base class for all for-each expression templates.The ForEachExpr class serves as a tag for all expression templates that represent a unary, custom operation. All classes, that represent a custom operation and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as for-each expression template. Only in case a class is derived from the ForEachExpr base class, the IsForEachExpr type trait recognizes the class as valid for-each expression template. More...
 
struct  ForEachExprTrait
 Evaluation of the return type of a forEach expression.Via this type trait it is possible to evaluate the return type of a forEach expression. Given the type T, which must either be a scalar, vector, or matrix type, the nested type Type corresponds to the resulting return type. In case the type of T doesn't fit or if no forEach operation exists for the type, the resulting data type Type is set to INVALID_TYPE. More...
 
struct  ForEachTrait
 Base template for the ForEachTrait class.The ForEachTrait class template offers the possibility to select the resulting data type of a generic forEach operation on the given type T. Given the type T, which must either be a vector or matrix type, the nested type Type corresponds to the resulting data type of the operation. In case the type of T doesn't fit or if no forEach operation exists for the type, the resulting data type Type is set to INVALID_TYPE. Note that const and volatile qualifiers and reference modifiers are generally ignored. More...
 
struct  Greater
 Compile time type comparison.The Greater class 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...
 
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  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  HasCyclicDependency
 
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  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  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  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  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 exponent 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 exponent 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  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  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  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  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 Size 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...
 
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 $ a_{ij} $ via iterator is also applied to element $ a_{ji} $. The following example illustrates this by means of a $ 3 \times 3 $ dense Hermitian matrix: More...
 
class  HermitianMatrix
 Matrix adapter for Hermitian $ N \times N $ matrices. More...
 
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 $ a_{ij} $ of the accessed matrix is also applied to element $ a_{ji} $. The following example illustrates this by means of a $ 3 \times 3 $ dense Hermitian matrix: More...
 
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 $ a_{ij} $ via iterator is also applied to the value $ a_{ji} $. The following example illustrates this by means of a $ 3 \times 3 $ sparse Hermitian matrix: 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  If
 Compile time type selection.The If class template selects one of the two given types T2 and T3 depending on T1. In case T1::value evaluates to true, the member type definition Type is set to T2. In case T1::value evaluates to false, Type is set to T3. More...
 
struct  IfTrue
 Compile time type selection.The IfTrue 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...
 
struct  ImagTrait
 Base template for the ImagTrait class.The ImagTrait class template offers the possibility to select the resulting data type of a generic imag operation on the given type T. Given the type T, which must either be a scalar, vector, or matrix type, the nested type Type corresponds to the resulting data type of the operation. In case the type of T doesn't fit or if no imag operation exists for the type, the resulting data type Type is set to INVALID_TYPE. Note that const and volatile qualifiers and reference modifiers are generally ignored. More...
 
class  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 -1. 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  InputString
 Implementation of a string wrapper.The InputString class is a wrapper class for the purpose to read input strings delimited by quotations from streams, like for instance "example input". All characters between the leading and the trailing quotation are extracted unchanged from the input stream, including whitespaces. The input string has to be in one single line. In case of input errors, the std::istream::failbit of the input stream is set. More...
 
struct  Int
 Compile time integral constant wrapper for int.The Int class template represents an integral wrapper for a compile time constant expression of type int. The value of an Int 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...
 
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...
 
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  InvCbrt
 Generic wrapper for the invcbrt() function. More...
 
struct  InvExprTrait
 Evaluation of the return type of an inversion expression.Via this type trait it is possible to evaluate the return type of an inversion expression. Given the type T, which must either a (complex) floating point type or a dense matrix type, the nested type Type corresponds to the resulting return type. In case the type of T doesn't fit or if no inversion operation exists for the type, the resulting data type Type is set to INVALID_TYPE. 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 or privately) 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...
 
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  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  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  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  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 or privately) 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  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  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 or privately) 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  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  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 or privately) 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  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 or privately) 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  IsForEachExpr
 Compile time check whether the given type is a for-each expression template.This type trait class tests whether or not the given type Type is a for-each expression template. In order to qualify as a valid for-each expression template, the given type has to derive (publicly or privately) from the ForEachExpr base class. In case the given type is a valid for-each 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  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  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  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  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 or privately) 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  IsMatForEachExpr
 Compile time check whether the given type is a matrix for-each expression template.This type trait class tests whether or not the given type Type is a matrix for-each expression template. In order to qualify as a valid matrix for-each expression template, the given type has to derive (publicly or privately) from the MatForEachExpr base class. In case the given type is a valid matrix for-each 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 or privately) 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  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 or privately) 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  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 or privately) 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 or privately) 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  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 or privately) 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 or privately) 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 or privately) 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 or privately) 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 or privately) 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 or privately) 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 $ M = x*N $, where x is any positive integer in the range $ [0..\infty) $). In case the value is a multiple of N, 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  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 IsDefaultConstructible 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  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  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 $ B^x = N $, where x is any positive integer in the range $ [0..\infty) $. In case the value is a power of B, 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  IsProxy
 Compile time check for proxy types.This type trait tests whether or not the given template parameter is a proxy type (i.e. 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  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. dense or sparse row). 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  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  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  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 or privately) 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  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  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  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 or privately) 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. dense or sparse submatrix). 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. dense or sparse subvector). 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 or privately) 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  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 or privately) 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  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 or privately) 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  IsVecForEachExpr
 Compile time check whether the given type is a vector for-each expression template.This type trait class tests whether or not the given type Type is a vector for-each expression template. In order to qualify as a valid vector for-each expression template, the given type has to derive (publicly or privately) from the VecForEachExpr base class. In case the given type is a valid vector for-each 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 or privately) 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 or privately) 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 or privately) 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. 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 or privately) 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 or privately) 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 or privately) 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 or privately) 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  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 or privately) 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 or privately) 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...
 
class  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
 Compile time type comparison.The Less class 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...
 
struct  Limits
 Numerical limits of built-in data types.The Limits class provides numerical limits for the following built-in data types: More...
 
struct  LinearGrowth
 Linear growth policy class.The LinearGrowth policy class implements a linear growth strategy. It can be customized for any purpose: the Growth template argument specifies the factor of the size growth. More...
 
struct  Log
 Generic wrapper for the log() function. More...
 
struct  Log10
 Generic wrapper for the log10() function. More...
 
struct  Long
 Compile time integral constant wrapper for long.The Long class template represents an integral wrapper for a compile time constant expression of type long. The value of an Long 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...
 
class  LowerMatrix
 Matrix adapter for lower triangular $ N \times N $ matrices. More...
 
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 $ 3 \times 3 $ dense lower matrix: 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  MatEvalExpr
 Base class for all matrix evaluation expression templates.The MatEvalExpr class serves as a tag for all expression templates that implement a matrix evaluation operation. All classes, that represent a matrix evaluation operation and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as matrix evaluation expression template. Only in case a class is derived from the MatEvalExpr base class, the IsMatEvalExpr type trait recognizes the class as valid matrix evaluation expression template. More...
 
struct  MatForEachExpr
 Base class for all matrix for-each expression templates.The MatForEachExpr class serves as a tag for all expression templates that represent a unary, custom operation on a matrix. All classes, that represent a matrix custom operation and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as matrix for-each expression template. Only in case a class is derived from the MatForEachExpr base class, the IsMatForEachExpr type trait recognizes the class as valid matrix for-each expression template. More...
 
struct  MathTrait
 Base template for the MathTrait class. 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 from this class in order to qualify as matrix inversion expression template. Only in case a class is derived from the MatInvExpr base class, the IsMatInvExpr type trait recognizes the class as valid matrix inversion expression template. More...
 
struct  MatMatAddExpr
 Base class for all matrix/matrix addition expression templates.The MatMatAddExpr class serves as a tag for all expression templates that implement a matrix/matrix addition. All classes, that represent a matrix addition and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as matrix addition expression template. Only in case a class is derived from the MatMatAddExpr base class, the IsMatMatAddExpr type trait recognizes the class as valid matrix addition expression template. More...
 
struct  MatMatMultExpr
 Base class for all matrix/matrix multiplication expression templates.The MatMatMultExpr class serves as a tag for all expression templates that implement a matrix/matrix multiplication. All classes, that represent a matrix multiplication and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as matrix multiplication expression template. Only in case a class is derived from the MatMatMultExpr base class, the IsMatMatMultExpr type trait recognizes the class as valid matrix multiplication expression template. More...
 
struct  MatMatSubExpr
 Base class for all matrix/matrix subtraction expression templates.The MatMatSubExpr class serves as a tag for all expression templates that implement a matrix/matrix subtraction. All classes, that represent a matrix subtraction and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as matrix subtraction expression template. Only in case a class is derived from the MatMatSubExpr base class, the IsMatMatSubExpr type trait recognizes the class as valid matrix subtraction expression template. More...
 
struct  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, $ M \times N $ matrices.The MatrixAccessProxy provides safe access to the elements of a non-const sparse matrices.
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 divsion expression templates.The MatScalarDivExpr class serves as a tag for all expression templates that implement a matrix/scalar divsion. All classes, that represent a matrix/scalar divsion and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as matrix/scalar divsion expression template. Only in case a class is derived from the MatScalarDivExpr base class, the IsMatScalarDivExpr type trait recognizes the class as valid matrix/scalar divsion expression template. More...
 
struct  MatScalarMultExpr
 Base class for all matrix/scalar multiplication expression templates.The MatScalarMultExpr class serves as a tag for all expression templates that implement a matrix/scalar multiplication. All classes, that represent a matrix/scalar multiplication and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as matrix/scalar multiplication expression template. Only in case a class is derived from the MatScalarMultExpr base class, the IsMatScalarMultExpr type trait recognizes the class as valid matrix/scalar multiplication expression template. More...
 
struct  MatSerialExpr
 Base class for all matrix serial evaluation expression templates.The MatSerialExpr class serves as a tag for all expression templates that enforce a serial evaluation of a matrix. All classes, that represent a matrix serialization operation and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as matrix serial evaluation expression template. Only in case a class is derived from the MatSerialExpr base class, the IsMatSerialExpr type trait recognizes the class as valid matrix serial evaluation expression template. More...
 
struct  MatTransExpr
 Base class for all matrix transposition expression templates.The MatTransExpr class serves as a tag for all expression templates that implement a matrix transposition operation. All classes, that represent a matrix transposition operation and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as matrix transposition expression template. Only in case a class is derived from the MatTransExpr base class, the IsMatTransExpr type trait recognizes the class as valid matrix transposition expression template. More...
 
struct  MatVecMultExpr
 Base class for all matrix/vector multiplication expression templates.The MatVecMultExpr class serves as a tag for all expression templates that implement a matrix/vector multiplication. All classes, that represent a matrix/vector multiplication and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as matrix/vector multiplication expression template. Only in case a class is derived from the MatVecMultExpr base class, the IsMatVecMultExpr type trait recognizes the class as valid matrix/vector multiplication expression template. More...
 
struct  Max
 Compile time value evaluation.The Max class template selects the larger of the two given template arguments T1 and T2. In order for Max to be able to determine the larger type, both arguments are required to have a nested member value. In case T1::value is larger than T2::value, the nested type definition Type is set to T1, otherwise it is set to T2. More...
 
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
 Compile time value evaluation.The Min class template selects the smaller of the two given template arguments T1 and T2. In order for Min to be able to determine the smaller type, both arguments are required to have a nested member value. In case T1::value is smaller than T2::value, the nested type definition Type is set to T1, otherwise it is set to T2. More...
 
struct  Minus
 Compile time integral subtraction.The Minus class template returns the difference of the two given template arguments T1 and T2. In order for Minus 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...
 
struct  Modulus
 Compile time integral modulus operation.The Modulus class template returns the result of a modulus operation between the two given template arguments T1 and T2. In order for Modulus 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 modulus operation can be accessed via the nested member value, the resulting type is available via the nested type ValueType. 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 from this class in order to qualify as multiplication expression template. Only in case a class is derived from the MultExpr base class, the IsMultExpr type trait recognizes the class as valid multiplication expression template. More...
 
struct  MultExprTrait
 Evaluation of the resulting expression type of a multiplication.Via this type trait it is possible to evaluate the return type of a multiplication expression between scalars, vectors, and matrices. Given the two types T1 and T2, which must be either scalar, vector, or matrix types, the nested type Type corresponds to the resulting return type. In case T1 or T2 don't fit or if the two types cannot be multiplied, the resulting data type Type is set to INVALID_TYPE. 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  NextMultiple
 Compile time integral round up operation.The NextMultiple class template rounds up the given template argument of type T1 to the next multiple of the given template argument of type T2. In case T1 already represents a multiple of T2, the result is T1. In order for NextMultiple to be able to perform the round up operation, both arguments are required to have a nested member value. The result of the operation can be accessed via the nested member value, the resulting type is available via the nested type ValueType. 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 $ a_{ij} $ of the accessed matrix is also applied to element $ a_{ji} $. The following example illustrates this by means of a $ 3 \times 3 $ sparse symmetric matrix with StaticVector elements: More...
 
struct  Not
 Compile time type negation.The Not class 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...
 
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 $ a_{ij} $ of the accessed matrix is also applied to element $ a_{ji} $. The following example illustrates this by means of a $ 3 \times 3 $ dense symmetric matrix: More...
 
struct  OptimalGrowth
 Optimal growth policy class.The OptimalGrowth policy class implements the optimal growth strategy suggested by Andrew Koenig for the std::vector class (see Andrew Koenig's column in the September 1998 issue of JOOP (Journal of Object-Oriented Programming), or the Dr. Dobb's article 'C++ Made Easier: How Vectors Grow', 2001). It applies an exponential growth strategy using a factor of 1.5 and additionally ensures that the sizes returns are always multiples of four. More...
 
struct  Or
 Compile time logical or evaluation.The Or class template performs at compile time a logical or ('&&') evaluation of at least two compile time conditions: 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  Plus
 Compile time integral addition.The Plus class template returns the sum of the two given template arguments T1 and T2. In order for Plus 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...
 
struct  Pow
 Generic wrapper for the pow() 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...
 
class  PtrIterator
 Implementation of an iterator for pointer vectors.The PtrIterator class follows the example of the random-access iterator classes of the STL. However, the focus of this iterator implementation is the use with (polymorphic) pointers. The implementation of the Blaze library eases the use of iterators over a range of pointers and improves the semantics on these pointers.
. More...
 
class  PtrVector
 Implementation of a vector for (polymorphic) pointers. 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 $ [0..max] $, where max is the maximal value of the given data type T. More...
 
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  RealTrait
 Base template for the RealTrait class.The RealTrait class template offers the possibility to select the resulting data type of a generic real operation on the given type T. Given the type T, which must either be a scalar, vector, or matrix type, the nested type Type corresponds to the resulting data type of the operation. In case the type of T doesn't fit or if no real operation exists for the type, the resulting data type Type is set to INVALID_TYPE. Note that const and volatile qualifiers and reference modifiers are generally ignored. More...
 
struct  Rebind
 Rebind mechanism to obtain a CompressedMatrix with different data/element type. 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  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...
 
class  Row
 Reference to a specific row of a dense or sparse matrix.The Row template represents a reference to a specific row of a dense or sparse matrix primitive. The type of the matrix is specified via the first template parameter: More...
 
struct  RowExprTrait
 Evaluation of the expression type type of a row operation.Via this type trait it is possible to evaluate the return type of a row operation. Given the dense or sparse matrix type MT, the nested type Type corresponds to the resulting return type. In case the given type is neither a dense nor a sparse matrix type, the resulting data type Type is set to INVALID_TYPE. More...
 
struct  Rows
 Compile time evaluation of the number of rows of a matrix.The Rows type trait evaluates the number of rows of the given matrix type at compile time. In case the given type T is a matrix type with a fixed number of rows (e.g. StaticMatrix), the value member constant is set to the according number of rows. In all other cases, value is set to 0. More...
 
struct  RowTrait
 Base template for the RowTrait 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 from this class in order to qualify as serial evaluation expression template. Only in case a class is derived from the SerialExpr base class, the IsSerialExpr type trait recognizes the class as valid serial evaluation expression template. More...
 
struct  SerialExprTrait
 Evaluation of the return type of a serial evaluation expression.Via this type trait it is possible to evaluate the return type of a serial evaluation expression. Given the type T, which must either be a vector or matrix type, the nested type Type corresponds to the resulting return type. In case the type of T doesn't fit or if no serial evaluation operation exists for the type, the resulting data type Type is set to INVALID_TYPE. 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...
 
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 a vector.The Size type trait evaluates the size of the given vector type at compile time. In case the given type T is a vector type with a fixed size (e.g. StaticVector), the value member constant is set to the according size. In all other cases, value is set to 0. More...
 
class  size_t
 Size type of the Blaze library. More...
 
struct  SizeT
 Compile time integral constant wrapper for size_t.The SizeT class template represents an integral wrapper for a compile time constant expression of type size_t. The value of an SizeT 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...
 
struct  SMatCTransExprTrait
 Evaluation of the expression type of a sparse matrix conjugate transpose operation.Via this type trait it is possible to evaluate the resulting expression type of a sparse matrix conjugate transpose operation. Given the row-major sparse matrix type MT, the nested type Type corresponds to the resulting expression type. In case MT is not a row-major sparse matrix type, the resulting Type is set to INVALID_TYPE. More...
 
struct  SMatDMatAddExprTrait
 Evaluation of the expression type of a sparse matrix/dense matrix addition.Via this type trait it is possible to evaluate the resulting expression type of a sparse matrix/dense matrix addition. Given the row-major sparse matrix type MT1 and the row-major dense matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a row-major sparse matrix type or MT2 is not a row-major dense matrix type, the resulting data type Type is set to INVALID_TYPE. 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...
 
struct  SMatDMatMultExprTrait
 Evaluation of the expression type of a sparse matrix/dense matrix multiplication.Via this type trait it is possible to evaluate the resulting expression type of a sparse matrix/dense matrix multiplication. Given the row-major sparse matrix type MT1 and the row-major dense matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a row-major sparse matrix type or MT2 is not a row-major dense matrix type, the resulting data type Type is set to INVALID_TYPE. 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...
 
struct  SMatDMatSubExprTrait
 Evaluation of the expression type of a sparse matrix/dense matrix subtraction.Via this type trait it is possible to evaluate the resulting expression type of a sparse matrix/dense matrix subtraction. Given the row-major sparse matrix type MT1 and the row-major dense matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a row-major sparse matrix type or MT2 is not a row-major dense matrix type, the resulting data type Type is set to INVALID_TYPE. 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...
 
struct  SMatDVecMultExprTrait
 Evaluation of the expression type of a sparse matrix/dense vector multiplication.Via this type trait it is possible to evaluate the resulting expression type of a sparse matrix/dense vector multiplication. Given the row-major sparse matrix type MT and the non-transpose dense vector type VT, the nested type Type corresponds to the resulting expression type. In case either MT is not a row-major sparse matrix type or VT is not a non-transpose dense vector type, the resulting data type Type is set to INVALID_TYPE. 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...
 
struct  SMatEvalExprTrait
 Evaluation of the expression type of a sparse matrix evaluation operation.Via this type trait it is possible to evaluate the resulting expression type of a sparse matrix evaluation operation. Given the row-major sparse matrix type MT, the nested type Type corresponds to the resulting expression type. In case MT is not a row-major sparse matrix type, the resulting Type is set to INVALID_TYPE. More...
 
class  SMatForEachExpr
 Expression object for the sparse matrix forEach() function.The SMatForEachExpr class represents the compile time expression for the evaluation of a custom operation on each element of a sparse matrix via the forEach() function. More...
 
struct  SMatForEachExprTrait
 Evaluation of the expression type of a sparse matrix for-each operation.Via this type trait it is possible to evaluate the resulting expression type of a sparse matrix for-each operation. Given the row-major sparse matrix type MT and the custom operation type OP, the nested type Type corresponds to the resulting expression type. In case MT is not a row-major sparse matrix type, the resulting Type is set to INVALID_TYPE. 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...
 
struct  SMatScalarDivExprTrait
 Evaluation of the expression type of a sparse matrix/scalar division.Via this type trait it is possible to evaluate the resulting expression type of a sparse matrix/scalar division. Given the row-major sparse matrix type MT and the scalar type ST, the nested type Type corresponds to the resulting expression type. In case either MT is not a row-major sparse matrix type or ST is not a scalar type, the resulting Type is set to INVALID_TYPE. 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...
 
struct  SMatScalarMultExprTrait
 Evaluation of the expression type of a sparse matrix/scalar multiplication.Via this type trait it is possible to evaluate the resulting expression type of a sparse matrix/scalar multiplication. Given the row-major sparse matrix type MT and the scalar type ST, the nested type Type corresponds to the resulting expression type. In case either MT is not a row-major sparse matrix type or ST is not a scalar type, the resulting Type is set to INVALID_TYPE. 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...
 
struct  SMatSerialExprTrait
 Evaluation of the expression type of a sparse matrix serial evaluation operation.Via this type trait it is possible to evaluate the resulting expression type of a sparse matrix serial evaluation operation. Given the row-major sparse matrix type MT, the nested type Type corresponds to the resulting expression type. In case MT is not a row-major sparse matrix type, the resulting Type is set to INVALID_TYPE. 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...
 
struct  SMatSMatAddExprTrait
 Evaluation of the expression type of a sparse matrix/sparse matrix addition.Via this type trait it is possible to evaluate the resulting expression type of a sparse matrix/sparse matrix addition. Given the two row-major sparse matrix types MT1 and MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 or MT2 is not a row-major sparse matrix, the resulting data type Type is set to INVALID_TYPE. 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...
 
struct  SMatSMatMultExprTrait
 Evaluation of the expression type of a sparse matrix/sparse matrix multiplication.Via this type trait it is possible to evaluate the resulting expression type of a sparse matrix/sparse matrix multiplication. Given the two row-major sparse matrix types MT1 and MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 or MT2 is not a row-major sparse matrix, the resulting data type Type is set to INVALID_TYPE. 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...
 
struct  SMatSMatSubExprTrait
 Evaluation of the expression type of a sparse matrix/sparse matrix subtraction.Via this type trait it is possible to evaluate the resulting expression type of a sparse matrix/sparse matrix subtraction. Given the two row-major sparse matrix types MT1 and MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 or MT2 is not a row-major sparse matrix, the resulting data type Type is set to INVALID_TYPE. 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...
 
struct  SMatSVecMultExprTrait
 Evaluation of the expression type of a sparse matrix/sparse vector multiplication.Via this type trait it is possible to evaluate the resulting expression type of a sparse matrix/sparse vector multiplication. Given the row-major sparse matrix type MT and the non-transpose sparse vector type VT, the nested type Type corresponds to the resulting expression type. In case either MT is not a row-major sparse matrix type or VT is not a non-transpose sparse vector type, the resulting data type Type is set to INVALID_TYPE. More...
 
struct  SMatTDMatAddExprTrait
 Evaluation of the expression type of a sparse matrix/transpose dense matrix addition.Via this type trait it is possible to evaluate the resulting expression type of a sparse matrix/transpose dense matrix addition. Given the row-major sparse matrix type MT1 and the column-major dense matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a row-major sparse matrix type or MT2 is not a column-major dense matrix type, the resulting data type Type is set to INVALID_TYPE. 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...
 
struct  SMatTDMatMultExprTrait
 Evaluation of the expression type of a sparse matrix/transpose dense matrix multiplication.Via this type trait it is possible to evaluate the resulting expression type of a sparse matrix/transpose dense matrix multiplication. Given the row-major sparse matrix type MT1 and the column-major dense matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a row-major sparse matrix type or MT2 is not a column-major dense matrix type, the resulting data type Type is set to INVALID_TYPE. 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...
 
struct  SMatTDMatSubExprTrait
 Evaluation of the expression type of a sparse matrix/transpose dense matrix subtraction.Via this type trait it is possible to evaluate the resulting expression type of a sparse matrix/transpose dense matrix subtraction. Given the row-major sparse matrix type MT1 and the column-major dense matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a row-major sparse matrix type or MT2 is not a column-major dense matrix type, the resulting data type Type is set to INVALID_TYPE. More...
 
class  SMatTransExpr
 Expression object for sparse matrix transpositions.The SMatTransExpr class represents the compile time expression for transpositions of sparse matrices. More...
 
struct  SMatTransExprTrait
 Evaluation of the expression type of a sparse matrix transpose operation.Via this type trait it is possible to evaluate the resulting expression type of a sparse matrix transpose operation. Given the row-major sparse matrix type MT, the nested type Type corresponds to the resulting expression type. In case MT is not a row-major sparse matrix type, the resulting Type is set to INVALID_TYPE. 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...
 
struct  SMatTSMatAddExprTrait
 Evaluation of the expression type of a sparse matrix/transpose sparse matrix addition.Via this type trait it is possible to evaluate the resulting expression type of a sparse matrix/transpose sparse matrix addition. Given the row-major sparse matrix type MT1 and the column-major sparse matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a row-major sparse matrix type or MT2 is not a column-major sparse matrix type, the resulting data type Type is set to INVALID_TYPE. 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...
 
struct  SMatTSMatMultExprTrait
 Evaluation of the expression type of a sparse matrix/transpose sparse matrix multiplication.Via this type trait it is possible to evaluate the resulting expression type of a sparse matrix/transpose sparse matrix multiplication. Given the row-major sparse matrix type MT1 and the column-major sparse matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a row-major sparse matrix type or MT2 is not a column-major sparse matrix type, the resulting data type Type is set to INVALID_TYPE. 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...
 
struct  SMatTSMatSubExprTrait
 Evaluation of the expression type of a sparse matrix/transpose sparse matrix subtraction.Via this type trait it is possible to evaluate the resulting expression type of a sparse matrix/transpose sparse matrix subtraction. Given the row-major sparse matrix type MT1 and the column-major sparse matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a row-major sparse matrix type or MT2 is not a column-major sparse matrix type, the resulting data type Type is set to INVALID_TYPE. 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  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 $ N \times N $ matrices. More...
 
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 $ 3 \times 3 $ dense strictly lower triangular matrix: More...
 
class  StrictlyUpperMatrix
 Matrix adapter for strictly upper triangular $ N \times N $ matrices. More...
 
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 $ 3 \times 3 $ dense strictly upper triangular matrix: 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 from this class in order to qualify as subtraction expression template. Only in case a class is derived from the SubExpr base class, the IsSubExpr type trait recognizes the class as valid subtraction expression template. More...
 
struct  SubExprTrait
 Evaluation of the return type of a subtraction expression.Via this type trait it is possible to evaluate the return type of a subtraction expression between scalar, vectors, and matrices. Given the two types T1 and T2, which must be either scalar, vector, or matrix types, the nested type Type corresponds to the resulting return type. In case T1 or T2 don't fit or if the two types cannot be subtracted, the resulting data type Type is set to INVALID_TYPE. More...
 
class  Submatrix
 View on a specific submatrix of a dense or sparse matrix.The Submatrix class template represents a view on a specific submatrix of a dense or sparse matrix primitive. The type of the matrix is specified via the first template parameter: More...
 
struct  SubmatrixExprTrait
 Evaluation of the expression type type of a submatrix operation.Via this type trait it is possible to evaluate the return type of a submatrix operation. Given the dense or sparse matrix type MT and the alignment flag AF, the nested type Type corresponds to the resulting return type. In case the given type is neither a dense nor a sparse matrix type, the resulting data type Type is set to INVALID_TYPE. More...
 
struct  SubmatrixTrait
 Base template for the SubmatrixTrait class. More...
 
struct  SubTrait
 Base template for the SubTrait class. More...
 
class  Subvector
 View on a specific subvector of a dense or sparse vector.The Subvector class template represents a view on a specific subvector of a dense or sparse vector primitive. The type of the vector is specified via the first template parameter: More...
 
struct  SubvectorExprTrait
 Evaluation of the expression type type of a subvector operation.Via this type trait it is possible to evaluate the return type of a subvector operation. Given the dense or sparse vector type VT and the alignment flag AF, the nested type Type corresponds to the resulting return type. In case the given type is neither a dense nor a sparse vector type, the resulting data type Type is set to INVALID_TYPE. More...
 
struct  SubvectorTrait
 Base template for the SubvectorTrait class. More...
 
struct  SVecCTransExprTrait
 Evaluation of the expression type of a sparse vector conjugate transpose operation.Via this type trait it is possible to evaluate the resulting expression type of a sparse vector conjugate transpose operation. Given the non-transpose sparse vector type VT, the nested type Type corresponds to the resulting expression type. In case VT is not a non-transpose sparse vector type, the resulting Type is set to INVALID_TYPE. More...
 
struct  SVecDVecAddExprTrait
 Evaluation of the expression type of a sparse vector/dense vector addition.Via this type trait it is possible to evaluate the resulting expression type of a sparse vector/dense vector addition. Given the non-transpose sparse vector type VT1 and the non-transpose dense vector typeVT2, the nested type Type corresponds to the resulting expression type. In case either VT1 is not a non-transpose sparse vector type or VT2 is not a non-transpose dense vector type, the resulting Type is set to INVALID_TYPE. 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...
 
struct  SVecDVecCrossExprTrait
 Evaluation of the expression type of a sparse vector/dense vector cross product.Via this type trait it is possible to evaluate the resulting expression type of a sparse vector/dense vector cross product. Given the non-transpose sparse vector type VT1 and the non-transpose dense vector typeVT2, the nested type Type corresponds to the resulting expression type. In case either VT1 is not a non-transpose sparse vector type or VT2 is not a non-transpose dense vector type, the resulting Type is set to INVALID_TYPE. 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...
 
struct  SVecDVecDivExprTrait
 Evaluation of the expression type of a sparse vector/dense vector division.Via this type trait it is possible to evaluate the resulting expression type of a sparse vector/dense vector division. Given the non-transpose sparse vector type VT1 and the non-transpose dense vector typeVT2, the nested type Type corresponds to the resulting expression type. In case either VT1 is not a non-transpose sparse vector type or VT2 is not a non-transpose dense vector type, the resulting Type is set to INVALID_TYPE. 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...
 
struct  SVecDVecMultExprTrait
 Evaluation of the expression type of a sparse vector/dense vector multiplication.Via this type trait it is possible to evaluate the resulting expression type of a sparse vector/dense vector multiplication. Given the non-transpose sparse vector type VT1 and the non-transpose dense vector typeVT2, the nested type Type corresponds to the resulting expression type. In case either VT1 is not a non-transpose sparse vector type or VT2 is not a non-transpose dense vector type, the resulting Type is set to INVALID_TYPE. 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...
 
struct  SVecDVecSubExprTrait
 Evaluation of the expression type of a sparse vector/dense vector subtraction.Via this type trait it is possible to evaluate the resulting expression type of a sparse vector/dense vector subtraction. Given the non-transpose sparse vector type VT1 and the non-transpose dense vector typeVT2, the nested type Type corresponds to the resulting expression type. In case either VT1 is not a non-transpose sparse vector type or VT2 is not a non-transpose dense vector type, the resulting Type is set to INVALID_TYPE. 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...
 
struct  SVecEvalExprTrait
 Evaluation of the expression type of a sparse vector evaluation operation.Via this type trait it is possible to evaluate the resulting expression type of a sparse vector evaluation operation. Given the non-transpose sparse vector type VT, the nested type Type corresponds to the resulting expression type. In case VT is not a non-transpose sparse vector type, the resulting Type is set to INVALID_TYPE. More...
 
class  SVecForEachExpr
 Expression object for the sparse vector forEach() function.The SVecForEachExpr class represents the compile time expression for the evaluation of a custom operation on each element of a sparse vector via the forEach() function. More...
 
struct  SVecForEachExprTrait
 Evaluation of the expression type of a sparse vector for-each operation.Via this type trait it is possible to evaluate the resulting expression type of a sparse vector custom operation. Given the non-transpose sparse vector type VT and the custom operation type OP, the nested type Type corresponds to the resulting expression type. In case VT is not a non-transpose sparse vector type, the resulting Type is set to INVALID_TYPE. 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...
 
struct  SVecScalarDivExprTrait
 Evaluation of the expression type of a sparse vector/scalar division.Via this type trait it is possible to evaluate the resulting expression type of a sparse vector/scalar division. Given the non-transpose sparse vector type VT and the scalar type ST, the nested type Type corresponds to the resulting expression type. In case either VT is not a non-transpose sparse vector type or ST is not a scalar type, the resulting Type is set to INVALID_TYPE. 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...
 
struct  SVecScalarMultExprTrait
 Evaluation of the expression type of a sparse vector/scalar multiplication.Via this type trait it is possible to evaluate the resulting expression type of a sparse vector/scalar multiplication. Given the non-transpose sparse vector type VT and the scalar type ST, the nested type Type corresponds to the resulting expression type. In case either VT is not a non-transpose sparse vector type or ST is not a scalar type, the resulting Type is set to INVALID_TYPE. 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...
 
struct  SVecSerialExprTrait
 Evaluation of the expression type of a sparse vector serial evaluation operation.Via this type trait it is possible to evaluate the resulting expression type of a sparse vector serial evaluation operation. Given the non-transpose sparse vector type VT, the nested type Type corresponds to the resulting expression type. In case VT is not a non-transpose sparse vector type, the resulting Type is set to INVALID_TYPE. 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...
 
struct  SVecSVecAddExprTrait
 Evaluation of the expression type of a sparse vector/sparse vector addition.Via this type trait it is possible to evaluate the resulting expression type of a sparse vector/sparse vector addition. Given the two non-transpose sparse vector types VT1 and VT2, the nested type Type corresponds to the resulting expression type. In case either VT1 or VT2 is not a non-transpose sparse vector type, the resulting Type is set to INVALID_TYPE. 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...
 
struct  SVecSVecCrossExprTrait
 Evaluation of the expression type of a sparse vector/sparse vector cross product.Via this type trait it is possible to evaluate the resulting expression type of a sparse vector/sparse vector cross product. Given the two non-transpose sparse vector types VT1 and VT2, the nested type Type corresponds to the resulting expression type. In case either VT1 or VT2 is not a non-transpose sparse vector type, the resulting Type is set to INVALID_TYPE. 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...
 
struct  SVecSVecMultExprTrait
 Evaluation of the expression type of a sparse vector/sparse vector multiplication.Via this type trait it is possible to evaluate the resulting expression type of a sparse vector/sparse vector multiplication. Given the two non-transpose sparse vector types VT1 and VT2, the nested type Type corresponds to the resulting expression type. In case either VT1 or VT2 is not a non-transpose sparse vector type, the resulting Type is set to INVALID_TYPE. 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...
 
struct  SVecSVecSubExprTrait
 Evaluation of the expression type of a sparse vector/sparse vector subtraction.Via this type trait it is possible to evaluate the resulting expression type of a sparse vector/sparse vector subtraction. Given the two non-transpose sparse vector types VT1 and VT2, the nested type Type corresponds to the resulting expression type. In case either VT1 or VT2 is not a non-transpose sparse vector type, the resulting Type is set to INVALID_TYPE. More...
 
class  SVecTDVecMultExpr
 Expression object for sparse vector-dense vector outer products.The SVecTDVecMultExpr class represents the compile time expression for sparse vector-dense vector outer products. More...
 
struct  SVecTDVecMultExprTrait
 Evaluation of the expression type of a sparse vector/transpose dense vector multiplication.Via this type trait it is possible to evaluate the resulting expression type of a sparse vector/transpose dense vector multiplication (outer product). Given the non-transpose sparse vector type VT1 and the transpose dense vector type VT2, the nested type Type corresponds to the resulting expression type. In case either VT1 is not a non-transpose sparse vector type or VT2 is not a transpose dense vector type, the resulting Type is set to INVALID_TYPE. More...
 
class  SVecTransExpr
 Expression object for sparse vector transpositions.The SVecTransExpr class represents the compile time expression for transpositions of sparse vectors. More...
 
struct  SVecTransExprTrait
 Evaluation of the expression type of a sparse vector transpose operation.Via this type trait it is possible to evaluate the resulting expression type of a sparse vector transpose operation. Given the non-transpose sparse vector type VT, the nested type Type corresponds to the resulting expression type. In case VT is not a non-transpose sparse vector type, the resulting Type is set to INVALID_TYPE. 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  SVecTSVecMultExpr
 Expression object for sparse vector-sparse vector outer products.The SVecTSVecMultExpr class represents the compile time expression for sparse vector-sparse vector outer products. More...
 
struct  SVecTSVecMultExprTrait
 Evaluation of the expression type of a sparse vector/transpose sparse vector multiplication.Via this type trait it is possible to evaluate the resulting expression type of a sparse vector/transpose sparse vector multiplication (outer product). Given the non-transpose sparse vector type VT1 and the transpose sparse vector type VT2, the nested type Type corresponds to the resulting expression type. In case either VT1 is not a non-transpose sparse vector type or VT2 is not a transpose sparse vector type, the resulting Type is set to INVALID_TYPE. 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 $ a_{ij} $ via iterator is also applied to element $ a_{ji} $. The following example illustrates this by means of a $ 3 \times 3 $ dense Hermitian matrix: More...
 
class  SymmetricMatrix
 Matrix adapter for symmetric $ N \times N $ matrices. More...
 
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 $ a_{ij} $ via iterator is also applied to the value $ a_{ji} $. The following example illustrates this by means of a $ 3 \times 3 $ sparse symmetric matrix: More...
 
class  SystemClock
 System clock of the Blaze library.The SystemClock class represents the system clock of the Blaze library. The system clock is the central timing functionality that can be used to query for the start time of the process, the current timestamp and the elapsed time since the start of the process. The following example demonstrates how the single system clock instance is acquired via the theSystemClock() functcion and how the system clock can be used: More...
 
struct  Tan
 Generic wrapper for the tan() function. More...
 
struct  Tanh
 Generic wrapper for the tanh() function. More...
 
struct  TDMatCTransExprTrait
 Evaluation of the expression type of a dense matrix conjugate transpose operation.Via this type trait it is possible to evaluate the resulting expression type of a dense matrix conjugate transpose operation. Given the column-major dense matrix type MT, the nested type Type corresponds to the resulting expression type. In case MT is not a column-major dense matrix type, the resulting Type is set to INVALID_TYPE. More...
 
struct  TDMatDMatAddExprTrait
 Evaluation of the expression type of a transpose dense matrix/dense matrix addition.Via this type trait it is possible to evaluate the resulting expression type of a transpose dense matrix/dense matrix addition. Given the column-major dense matrix type MT1 and the row-major dense matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a column-major dense matrix type or MT2 is not a row-major dense matrix type, the resulting data type Type is set to INVALID_TYPE. 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...
 
struct  TDMatDMatMultExprTrait
 Evaluation of the expression type of a transpose dense matrix/dense matrix multiplication.Via this type trait it is possible to evaluate the resulting expression type of a transpose dense matrix/dense matrix multiplication. Given the column-major dense matrix type MT1 and the row-major dense matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a column-major dense matrix type or MT2 is not a row-major dense matrix type, the resulting data type Type is set to INVALID_TYPE. More...
 
struct  TDMatDMatSubExprTrait
 Evaluation of the expression type of a transpose dense matrix/dense matrix subtraction.Via this type trait it is possible to evaluate the resulting expression type of a transpose dense matrix/dense matrix subtraction. Given the column-major dense matrix type MT1 and the row-major dense matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a column-major dense matrix type or MT2 is not a row-major dense matrix type, the resulting data type Type is set to INVALID_TYPE. 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...
 
struct  TDMatDVecMultExprTrait
 Evaluation of the expression type of a transpose dense matrix/dense vector multiplication.Via this type trait it is possible to evaluate the resulting expression type of a transpose dense matrix/dense vector multiplication. Given the column-major dense matrix type MT and the non-transpose dense vector type VT, the nested type Type corresponds to the resulting expression type. In case either MT is not a column-major dense matrix type or VT is not a non-transpose dense vector type, the resulting data type Type is set to INVALID_TYPE. More...
 
struct  TDMatEvalExprTrait
 Evaluation of the expression type of a dense matrix evaluation operation.Via this type trait it is possible to evaluate the resulting expression type of a dense matrix evaluation operation. Given the column-major dense matrix type MT, the nested type Type corresponds to the resulting expression type. In case MT is not a column-major dense matrix type, the resulting Type is set to INVALID_TYPE. More...
 
struct  TDMatForEachExprTrait
 Evaluation of the expression type of a dense matrix custom operation.Via this type trait it is possible to evaluate the resulting expression type of a dense matrix custom operation. Given the column-major dense matrix type MT and the custom operation type OP, the nested type Type corresponds to the resulting expression type. In case MT is not a column-major dense matrix type, the resulting Type is set to INVALID_TYPE. More...
 
struct  TDMatInvExprTrait
 Evaluation of the expression type of a dense matrix inversion operation.Via this type trait it is possible to evaluate the resulting expression type of a dense matrix inversion operation. Given the column-major dense matrix type MT, the nested type Type corresponds to the resulting expression type. In case MT is not a column-major dense matrix type, the resulting Type is set to INVALID_TYPE. More...
 
struct  TDMatScalarDivExprTrait
 Evaluation of the expression type of a transpose dense matrix/scalar division.Via this type trait it is possible to evaluate the resulting expression type of a transpose dense matrix/scalar division. Given the column-major dense matrix type MT and the scalar type ST, the nested type Type corresponds to the resulting expression type. In case either MT is not a column-major dense matrix type or ST is not a scalar type, the resulting Type is set to INVALID_TYPE. More...
 
struct  TDMatScalarMultExprTrait
 Evaluation of the expression type of a transpose dense matrix/scalar multiplication.Via this type trait it is possible to evaluate the resulting expression type of a transpose dense matrix/scalar multiplication. Given the column-major dense matrix type MT and the scalar type ST, the nested type Type corresponds to the resulting expression type. In case either MT is not a column-major dense matrix type or ST is not a scalar type, the resulting Type is set to INVALID_TYPE. More...
 
struct  TDMatSerialExprTrait
 Evaluation of the expression type of a dense matrix serial evaluation operation.Via this type trait it is possible to evaluate the resulting expression type of a dense matrix serial evaluation operation. Given the column-major dense matrix type MT, the nested type Type corresponds to the resulting expression type. In case MT is not a column-major dense matrix type, the resulting Type is set to INVALID_TYPE. 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...
 
struct  TDMatSMatAddExprTrait
 Evaluation of the expression type of a transpose dense matrix/sparse matrix addition.Via this type trait it is possible to evaluate the resulting expression type of a transpose dense matrix/sparse matrix addition. Given the column-major dense matrix type MT1 and the row-major sparse matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a column-major dense matrix type or MT2 is not a row-major sparse matrix type, the resulting data type Type is set to INVALID_TYPE. 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...
 
struct  TDMatSMatMultExprTrait
 Evaluation of the expression type of a transpose dense matrix/sparse matrix multiplication.Via this type trait it is possible to evaluate the resulting expression type of a transpose dense matrix/sparse matrix multiplication. Given the column-major dense matrix type MT1 and the row-major sparse matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a column-major dense matrix type or MT2 is not a row-major sparse matrix type, the resulting data type Type is set to INVALID_TYPE. 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...
 
struct  TDMatSMatSubExprTrait
 Evaluation of the expression type of a transpose dense matrix/sparse matrix subtraction.Via this type trait it is possible to evaluate the resulting expression type of a transpose dense matrix/sparse matrix subtraction. Given the column-major dense matrix type MT1 and the row-major sparse matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a column-major dense matrix type or MT2 is not a row-major sparse matrix type, the resulting data type Type is set to INVALID_TYPE. 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...
 
struct  TDMatSVecMultExprTrait
 Evaluation of the expression type of a transpose dense matrix/sparse vector multiplication.Via this type trait it is possible to evaluate the resulting expression type of a transpose dense matrix/sparse vector multiplication. Given the column-major dense matrix type MT and the non-transpose sparse vector type VT, the nested type Type corresponds to the resulting expression type. In case either MT is not a column-major dense matrix type or VT is not a non-transpose sparse vector type, the resulting data type Type is set to INVALID_TYPE. More...
 
struct  TDMatTDMatAddExprTrait
 Evaluation of the expression type of a transpose dense matrix/transpose dense matrix addition.Via this type trait it is possible to evaluate the resulting expression type of a transpose dense matrix/transpose dense matrix addition. Given the two column-major dense matrix types MT1 and MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 or MT2 is not a column-major dense matrix, the resulting data type Type is set to INVALID_TYPE. 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...
 
struct  TDMatTDMatMultExprTrait
 Evaluation of the expression type of a transpose dense matrix/transpose dense matrix multiplication.Via this type trait it is possible to evaluate the resulting expression type of a transpose dense matrix/transpose dense matrix multiplication. Given the two column-major dense matrix types MT1 and MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 or MT2 is not a column-major dense matrix, the resulting data type Type is set to INVALID_TYPE. More...
 
struct  TDMatTDMatSubExprTrait
 Evaluation of the expression type of a transpose dense matrix/transpose dense matrix subtraction.Via this type trait it is possible to evaluate the resulting expression type of a transpose dense matrix/transpose dense matrix subtraction. Given the two column-major dense matrix types MT1 and MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 or MT2 is not a column-major dense matrix, the resulting data type Type is set to INVALID_TYPE. More...
 
struct  TDMatTransExprTrait
 Evaluation of the expression type of a dense matrix transpose operation.Via this type trait it is possible to evaluate the resulting expression type of a dense matrix transpose operation. Given the column-major dense matrix type MT, the nested type Type corresponds to the resulting expression type. In case MT is not a column-major dense matrix type, the resulting Type is set to INVALID_TYPE. More...
 
struct  TDMatTSMatAddExprTrait
 Evaluation of the expression type of a transpose dense matrix/transpose sparse matrix addition.Via this type trait it is possible to evaluate the resulting expression type of a transpose dense matrix/transpose sparse matrix addition. Given the column-major dense matrix type MT1 and the column-major sparse matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a column-major dense matrix type or MT2 is not a column-major sparse matrix type, the resulting data type Type is set to INVALID_TYPE. 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...
 
struct  TDMatTSMatMultExprTrait
 Evaluation of the expression type of a transpose dense matrix/transpose sparse matrix multiplication.Via this type trait it is possible to evaluate the resulting expression type of a transpose dense matrix/transpose sparse matrix multiplication. Given the column-major dense matrix type MT1 and the column-major sparse matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a column-major dense matrix type or MT2 is not a column-major sparse matrix type, the resulting data type Type is set to INVALID_TYPE. More...
 
struct  TDMatTSMatSubExprTrait
 Evaluation of the expression type of a transpose dense matrix/transpose sparse matrix subtraction.Via this type trait it is possible to evaluate the resulting expression type of a transpose dense matrix/transpose sparse matrix subtraction. Given the column-major dense matrix type MT1 and the column-major sparse matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a column-major dense matrix type or MT2 is not a column-major sparse matrix type, the resulting data type Type is set to INVALID_TYPE. More...
 
struct  TDVecCTransExprTrait
 Evaluation of the expression type of a dense vector conjugate transpose operation.Via this type trait it is possible to evaluate the resulting expression type of a dense vector conjugate transpose operation. Given the transpose dense vector type VT, the nested type Type corresponds to the resulting expression type. In case VT is not a transpose dense vector type, the resulting Type is set to INVALID_TYPE. 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...
 
struct  TDVecDMatMultExprTrait
 Evaluation of the expression type of a dense vector/dense matrix multiplication.Via this type trait it is possible to evaluate the resulting expression type of a dense vector/dense matrix multiplication. Given the transpose dense vector type VT and the row-major dense matrix type MT, the nested type Type corresponds to the resulting expression type. In case either VT is not a transpose dense vector type or MT is not a row-major dense matrix type, the resulting data type Type is set to INVALID_TYPE. More...
 
struct  TDVecDVecMultExprTrait
 Evaluation of the expression type of a transpose dense vector/dense vector multiplication.Via this type trait it is possible to evaluate the resulting expression type of a transpose dense vector/dense vector multiplication (inner product). Given the transpose dense vector type VT1 and the non-transpose dense vector type VT2, the nested type Type corresponds to the resulting expression type. In case either VT1 is not a transpose dense vector type or VT2 is not a non-transpose dense vector type, the resulting Type is set to INVALID_TYPE. More...
 
struct  TDVecEvalExprTrait
 Evaluation of the expression type of a dense vector evaluation operation.Via this type trait it is possible to evaluate the resulting expression type of a dense vector evaluation operation. Given the transpose dense vector type VT, the nested type Type corresponds to the resulting expression type. In case VT is not a transpose dense vector type, the resulting Type is set to INVALID_TYPE. More...
 
struct  TDVecForEachExprTrait
 Evaluation of the expression type of a dense vector custom operation.Via this type trait it is possible to evaluate the resulting expression type of a dense vector custom operation. Given the transpose dense vector type VT and the custom operation type OP, the nested type Type corresponds to the resulting expression type. In case VT is not a transpose dense vector type, the resulting Type is set to INVALID_TYPE. More...
 
struct  TDVecScalarDivExprTrait
 Evaluation of the expression type of a transpose dense vector/scalar division.Via this type trait it is possible to evaluate the resulting expression type of a transpose dense vector/scalar division. Given the transpose dense vector type VT and the scalar type ST, the nested type Type corresponds to the resulting expression type. In case either VT is not a transpose dense vector type or ST is not a scalar type, the resulting Type is set to INVALID_TYPE. More...
 
struct  TDVecScalarMultExprTrait
 Evaluation of the expression type of a transpose dense vector/scalar multiplication.Via this type trait it is possible to evaluate the resulting expression type of a transpose dense vector/scalar multiplication. Given the transpose dense vector type VT and the scalar type ST, the nested type Type corresponds to the resulting expression type. In case either VT is not a transpose dense vector type or ST is not a scalar type, the resulting Type is set to INVALID_TYPE. More...
 
struct  TDVecSerialExprTrait
 Evaluation of the expression type of a dense vector serial evaluation operation.Via this type trait it is possible to evaluate the resulting expression type of a dense vector serial evaluation operation. Given the transpose dense vector type VT, the nested type Type corresponds to the resulting expression type. In case VT is not a transpose dense vector type, the resulting Type is set to INVALID_TYPE. 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...
 
struct  TDVecSMatMultExprTrait
 Evaluation of the expression type of a dense vector/sparse matrix multiplication.Via this type trait it is possible to evaluate the resulting expression type of a dense vector/sparse matrix multiplication. Given the transpose dense vector type VT and the row-major sparse matrix type MT, the nested type Type corresponds to the resulting expression type. In case either VT is not a transpose dense vector type or MT is not a row-major sparse matrix type, the resulting data type Type is set to INVALID_TYPE. More...
 
struct  TDVecSVecMultExprTrait
 Evaluation of the expression type of a transpose dense vector/sparse vector multiplication.Via this type trait it is possible to evaluate the resulting expression type of a transpose dense vector/sparse vector multiplication (inner product). Given the transpose dense vector type VT1 and the non-transpose sparse vector type VT2, the nested type Type corresponds to the resulting expression type. In case either VT1 is not a transpose dense vector type or VT2 is not a non-transpose sparse vector type, the resulting Type is set to INVALID_TYPE. 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...
 
struct  TDVecTDMatMultExprTrait
 Evaluation of the expression type of a dense vector/transpose dense matrix multiplication.Via this type trait it is possible to evaluate the resulting expression type of a dense vector/transpose dense matrix multiplication. Given the transpose dense vector type VT and the column-major dense matrix type MT, the nested type Type corresponds to the resulting expression type. In case either VT is not a transpose dense vector type or MT is not a column-major dense matrix type, the resulting data type Type is set to INVALID_TYPE. More...
 
struct  TDVecTDVecAddExprTrait
 Evaluation of the expression type of a transpose dense vector/transpose dense vector addition.Via this type trait it is possible to evaluate the resulting expression type of a transpose dense vector/transpose dense vector addition. Given the two transpose dense vector types VT1 and VT2, the nested type Type corresponds to the resulting expression type. In case either VT1 or VT2 is not a transpose dense vector type, the resulting Type is set to INVALID_TYPE. More...
 
struct  TDVecTDVecCrossExprTrait
 Evaluation of the expression type of a dense vector/dense vector cross product.Via this type trait it is possible to evaluate the resulting expression type of a dense vector/dense vector cross product. Given the two transpose dense vector types VT1 and VT2, the nested type Type corresponds to the resulting expression type. In case either VT1 or VT2 is not a transpose dense vector type, the resulting Type is set to INVALID_TYPE. More...
 
struct  TDVecTDVecDivExprTrait
 Evaluation of the expression type of a transpose dense vector/transpose dense vector division.Via this type trait it is possible to evaluate the resulting expression type of a transpose dense vector/transpose dense vector division. Given the two transpose dense vector types VT1 and VT2, the nested type Type corresponds to the resulting expression type. In case either VT1 or VT2 is not a transpose dense vector type, the resulting Type is set to INVALID_TYPE. More...
 
struct  TDVecTDVecMultExprTrait
 Evaluation of the expression type of a transpose dense vector/transpose dense vector multiplication.Via this type trait it is possible to evaluate the resulting expression type of a transpose dense vector/transpose dense vector multiplication. Given the two transpose dense vector types VT1 and VT2, the nested type Type corresponds to the resulting expression type. In case either VT1 or VT2 is not a transpose dense vector type, the resulting Type is set to INVALID_TYPE. More...
 
struct  TDVecTDVecSubExprTrait
 Evaluation of the expression type of a transpose dense vector/transpose dense vector subtraction.Via this type trait it is possible to evaluate the resulting expression type of a transpose dense vector/transpose dense vector subtraction. Given the two transpose dense vector types VT1 and VT2, the nested type Type corresponds to the resulting expression type. In case either VT1 or VT2 is not a transpose dense vector type, the resulting Type is set to INVALID_TYPE. More...
 
struct  TDVecTransExprTrait
 Evaluation of the expression type of a dense vector transpose operation.Via this type trait it is possible to evaluate the resulting expression type of a dense vector transpose operation. Given the transpose dense vector type VT, the nested type Type corresponds to the resulting expression type. In case VT is not a transpose dense vector type, the resulting Type is set to INVALID_TYPE. 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...
 
struct  TDVecTSMatMultExprTrait
 Evaluation of the expression type of a dense vector/transpose sparse matrix multiplication.Via this type trait it is possible to evaluate the resulting expression type of a dense vector/transpose sparse matrix multiplication. Given the transpose dense vector type VT and the column-major sparse matrix type MT, the nested type Type corresponds to the resulting expression type. In case either VT is not a transpose dense vector type or MT is not a column-major sparse matrix type, the resulting data type Type is set to INVALID_TYPE. More...
 
struct  TDVecTSVecAddExprTrait
 Evaluation of the expression type of a transpose dense vector/transpose sparse vector addition.Via this type trait it is possible to evaluate the resulting expression type of a transpose dense vector/transpose sparse vector addition. Given the transpose dense vector type VT1 and the transpose sparse vector type VT2, the nested type Type corresponds to the resulting expression type. In case either VT1 is not a transpose dense vector type or VT2 is not a transpose sparse vector type, the resulting Type is set to INVALID_TYPE. More...
 
struct  TDVecTSVecCrossExprTrait
 Evaluation of the expression type of a dense vector/sparse vector cross product.Via this type trait it is possible to evaluate the resulting expression type of a dense vector/sparse vector cross product. Given the transpose dense vector type VT1 and the transpose sparse vector typeVT2, the nested type Type corresponds to the resulting expression type. In case either VT1 is not a transpose dense vector type or VT2 is not a transpose sparse vector type, the resulting Type is set to INVALID_TYPE. More...
 
struct  TDVecTSVecMultExprTrait
 Evaluation of the expression type of a transpose dense vector/transpose sparse vector multiplication.Via this type trait it is possible to evaluate the resulting expression type of a transpose dense vector/transpose sparse vector multiplication. Given the transpose dense vector type VT1 and the transpose sparse vector type VT2, the nested type Type corresponds to the resulting expression type. In case either VT1 is not a transpose dense vector type or VT2 is not a transpose sparse vector type, the resulting Type is set to INVALID_TYPE. More...
 
struct  TDVecTSVecSubExprTrait
 Evaluation of the expression type of a transpose dense vector/transpose sparse vector subtraction.Via this type trait it is possible to evaluate the resulting expression type of a transpose dense vector/transpose sparse vector subtraction. Given the transpose dense vector type VT1 and the transpose sparse vector type VT2, the nested type Type corresponds to the resulting expression type. In case either VT1 is not a transpose dense vector type or VT2 is not a transpose sparse vector type, the resulting Type is set to INVALID_TYPE. More...
 
class  Thread
 Implementation of a single thread of execution. More...
 
class  ThreadPool
 Implementation of a thread pool. More...
 
struct  Times
 Compile time integral multiplication.The Times class template returns the product of the two given template arguments T1 and T2. In order for Times 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...
 
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 from this class in order to qualify as transposition expression template. Only in case a class is derived from the TransExpr base class, the IsTransExpr type trait recognizes the class as valid transposition expression template. More...
 
struct  TransExprTrait
 Evaluation of the return type of a transpose expression.Via this type trait it is possible to evaluate the return type of a transpose expression. Given the type T, which must either be a vector or matrix type, the nested type Type corresponds to the resulting return type. In case the type of T doesn't fit or if no transpose operation exists for the type, the resulting data type Type is set to INVALID_TYPE. 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  TSMatCTransExprTrait
 Evaluation of the expression type of a sparse matrix conjugate transpose operation.Via this type trait it is possible to evaluate the resulting expression type of a sparse matrix conjugate transpose operation. Given the column-major sparse matrix type MT, the nested type Type corresponds to the resulting expression type. In case MT is not a column-major sparse matrix type, the resulting Type is set to INVALID_TYPE. More...
 
struct  TSMatDMatAddExprTrait
 Evaluation of the expression type of a transpose sparse matrix/dense matrix addition.Via this type trait it is possible to evaluate the resulting expression type of a transpose sparse matrix/dense matrix addition. Given the column-major sparse matrix type MT1 and the row-major dense matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a column-major sparse matrix type or MT2 is not a row-major dense matrix type, the resulting data type Type is set to INVALID_TYPE. 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...
 
struct  TSMatDMatMultExprTrait
 Evaluation of the expression type of a transpose sparse matrix/dense matrix multiplication.Via this type trait it is possible to evaluate the resulting expression type of a transpose sparse matrix/dense matrix multiplication. Given the column-major sparse matrix type MT1 and the row-major dense matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a column-major sparse matrix type or MT2 is not a row-major dense matrix type, the resulting data type Type is set to INVALID_TYPE. 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...
 
struct  TSMatDMatSubExprTrait
 Evaluation of the expression type of a transpose sparse matrix/dense matrix subtraction.Via this type trait it is possible to evaluate the resulting expression type of a transpose sparse matrix/dense matrix subtraction. Given the column-major sparse matrix type MT1 and the row-major dense matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a column-major sparse matrix type or MT2 is not a row-major dense matrix type, the resulting data type Type is set to INVALID_TYPE. 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...
 
struct  TSMatDVecMultExprTrait
 Evaluation of the expression type of a transpose sparse matrix/dense vector multiplication.Via this type trait it is possible to evaluate the resulting expression type of a transpose sparse matrix/dense vector multiplication. Given the column-major sparse matrix type MT and the non-transpose dense vector type VT, the nested type Type corresponds to the resulting expression type. In case either MT is not a column-major sparse matrix type or VT is not a non-transpose dense vector type, the resulting data type Type is set to INVALID_TYPE. More...
 
struct  TSMatEvalExprTrait
 Evaluation of the expression type of a sparse matrix evaluation operation.Via this type trait it is possible to evaluate the resulting expression type of a sparse matrix evaluation operation. Given the column-major sparse matrix type MT, the nested type Type corresponds to the resulting expression type. In case MT is not a column-major sparse matrix type, the resulting Type is set to INVALID_TYPE. More...
 
struct  TSMatForEachExprTrait
 Evaluation of the expression type of a sparse matrix for-each operation.Via this type trait it is possible to evaluate the resulting expression type of a sparse matrix for-each operation. Given the column-major sparse matrix type MT and the custom operation type OP, the nested type Type corresponds to the resulting expression type. In case MT is not a column-major sparse matrix type, the resulting Type is set to INVALID_TYPE. More...
 
struct  TSMatScalarDivExprTrait
 Evaluation of the expression type of a transpose sparse matrix/scalar division.Via this type trait it is possible to evaluate the resulting expression type of a transpose sparse matrix/scalar division. Given the column-major sparse matrix type MT and the scalar type ST, the nested type Type corresponds to the resulting expression type. In case either MT is not a column-major sparse matrix type or ST is not a scalar type, the resulting Type is set to INVALID_TYPE. More...
 
struct  TSMatScalarMultExprTrait
 Evaluation of the expression type of a transpose sparse matrix/scalar multiplication.Via this type trait it is possible to evaluate the resulting expression type of a transpose sparse matrix/scalar multiplication. Given the column-major sparse matrix type MT and the scalar type ST, the nested type Type corresponds to the resulting expression type. In case either MT is not a column-major sparse matrix type or ST is not a scalar type, the resulting Type is set to INVALID_TYPE. More...
 
struct  TSMatSerialExprTrait
 Evaluation of the expression type of a sparse matrix serial evaluation operation.Via this type trait it is possible to evaluate the resulting expression type of a sparse matrix serial evaluation operation. Given the column-major sparse matrix type MT, the nested type Type corresponds to the resulting expression type. In case MT is not a column-major sparse matrix type, the resulting Type is set to INVALID_TYPE. More...
 
struct  TSMatSMatAddExprTrait
 Evaluation of the expression type of a transpose sparse matrix/sparse matrix addition.Via this type trait it is possible to evaluate the resulting expression type of a transpose sparse matrix/sparse matrix addition. Given the column-major sparse matrix type MT1 and the row-major sparse matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a column-major sparse matrix type or MT2 is not a row-major sparse matrix type, the resulting data type Type is set to INVALID_TYPE. 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...
 
struct  TSMatSMatMultExprTrait
 Evaluation of the expression type of a transpose sparse matrix/sparse matrix multiplication.Via this type trait it is possible to evaluate the resulting expression type of a transpose sparse matrix/sparse matrix multiplication. Given the column-major sparse matrix type MT1 and the row-major sparse matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a column-major sparse matrix type or MT2 is not a row-major sparse matrix type, the resulting data type Type is set to INVALID_TYPE. 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...
 
struct  TSMatSMatSubExprTrait
 Evaluation of the expression type of a transpose sparse matrix/sparse matrix subtraction.Via this type trait it is possible to evaluate the resulting expression type of a transpose sparse matrix/sparse matrix subtraction. Given the column-major sparse matrix type MT1 and the row-major sparse matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a column-major sparse matrix type or MT2 is not a row-major sparse matrix type, the resulting data type Type is set to INVALID_TYPE. 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...
 
struct  TSMatSVecMultExprTrait
 Evaluation of the expression type of a transpose sparse matrix/sparse vector multiplication.Via this type trait it is possible to evaluate the resulting expression type of a transpose sparse matrix/sparse vector multiplication. Given the column-major sparse matrix type MT and the non-transpose sparse vector type VT, the nested type Type corresponds to the resulting expression type. In case either MT is not a column-major sparse matrix type or VT is not a non-transpose sparse vector type, the resulting data type Type is set to INVALID_TYPE. More...
 
struct  TSMatTDMatAddExprTrait
 Evaluation of the expression type of a transpose sparse matrix/transpose dense matrix addition.Via this type trait it is possible to evaluate the resulting expression type of a transpose sparse matrix/transpose dense matrix addition. Given the column-major sparse matrix type MT1 and the column-major dense matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a column-major sparse matrix type or MT2 is not a column-major dense matrix type, the resulting data type Type is set to INVALID_TYPE. 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...
 
struct  TSMatTDMatMultExprTrait
 Evaluation of the expression type of a transpose sparse matrix/transpose dense matrix multiplication.Via this type trait it is possible to evaluate the resulting expression type of a transpose sparse matrix/transpose dense matrix multiplication. Given the column-major sparse matrix type MT1 and the column-major dense matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a column-major sparse matrix type or MT2 is not a column-major dense matrix type, the resulting data type Type is set to INVALID_TYPE. More...
 
struct  TSMatTDMatSubExprTrait
 Evaluation of the expression type of a transpose sparse matrix/transpose dense matrix subtraction.Via this type trait it is possible to evaluate the resulting expression type of a transpose sparse matrix/transpose dense matrix subtraction. Given the column-major sparse matrix type MT1 and the column-major dense matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a column-major sparse matrix type or MT2 is not a column-major dense matrix type, the resulting data type Type is set to INVALID_TYPE. More...
 
struct  TSMatTransExprTrait
 Evaluation of the expression type of a sparse matrix transpose operation.Via this type trait it is possible to evaluate the resulting expression type of a sparse matrix transpose operation. Given the column-major sparse matrix type MT, the nested type Type corresponds to the resulting expression type. In case MT is not a column-major sparse matrix type, the resulting Type is set to INVALID_TYPE. 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...
 
struct  TSMatTSMatAddExprTrait
 Evaluation of the expression type of a transpose sparse matrix/transpose sparse matrix addition.Via this type trait it is possible to evaluate the resulting expression type of a transpose sparse matrix/transpose sparse matrix addition. Given the two column-major sparse matrix types MT1 and MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 or MT2 is not a column-major sparse matrix, the resulting data type Type is set to INVALID_TYPE. 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...
 
struct  TSMatTSMatMultExprTrait
 Evaluation of the expression type of a transpose sparse matrix/transpose sparse matrix multiplication.Via this type trait it is possible to evaluate the resulting expression type of a transpose sparse matrix/transpose sparse matrix multiplication. Given the two column-major sparse matrix types MT1 and MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 or MT2 is not a column-major sparse matrix, the resulting data type Type is set to INVALID_TYPE. 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...
 
struct  TSMatTSMatSubExprTrait
 Evaluation of the expression type of a transpose sparse matrix/transpose sparse matrix subtraction.Via this type trait it is possible to evaluate the resulting expression type of a transpose sparse matrix/transpose sparse matrix subtraction. Given the two column-major sparse matrix types MT1 and MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 or MT2 is not a column-major sparse matrix, the resulting data type Type is set to INVALID_TYPE. More...
 
struct  TSVecCTransExprTrait
 Evaluation of the expression type of a sparse vector conjugate transpose operation.Via this type trait it is possible to evaluate the resulting expression type of a sparse vector conjugate transpose operation. Given the transpose sparse vector type VT, the nested type Type corresponds to the resulting expression type. In case VT is not a transpose sparse vector type, the resulting Type is set to INVALID_TYPE. 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...
 
struct  TSVecDMatMultExprTrait
 Evaluation of the expression type of a sparse vector/dense matrix multiplication.Via this type trait it is possible to evaluate the resulting expression type of a sparse vector/dense matrix multiplication. Given the transpose sparse vector type VT and the row-major dense matrix type MT, the nested type Type corresponds to the resulting expression type. In case either VT is not a transpose sparse vector type or MT is not a row-major dense matrix type, the resulting data type Type is set to INVALID_TYPE. More...
 
struct  TSVecDVecMultExprTrait
 Evaluation of the expression type of a transpose sparse vector/dense vector multiplication.Via this type trait it is possible to evaluate the resulting expression type of a transpose sparse vector/dense vector multiplication (inner product). Given the transpose sparse vector type VT1 and the non-transpose dense vector type VT2, the nested type Type corresponds to the resulting expression type. In case either VT1 is not a transpose sparse vector type or VT2 is not a non-transpose dense vector type, the resulting Type is set to INVALID_TYPE. More...
 
struct  TSVecEvalExprTrait
 Evaluation of the expression type of a sparse vector evaluation operation.Via this type trait it is possible to evaluate the resulting expression type of a sparse vector evaluation operation. Given the transpose sparse vector type VT, the nested type Type corresponds to the resulting expression type. In case VT is not a transpose sparse vector type, the resulting Type is set to INVALID_TYPE. More...
 
struct  TSVecForEachExprTrait
 Evaluation of the expression type of a sparse vector for-each operation.Via this type trait it is possible to evaluate the resulting expression type of a sparse vector custom operation. Given the transpose sparse vector type VT and the custom operation type OP, the nested type Type corresponds to the resulting expression type. In case VT is not a transpose sparse vector type, the resulting Type is set to INVALID_TYPE. More...
 
struct  TSVecScalarDivExprTrait
 Evaluation of the expression type of a transpose sparse vector/scalar division.Via this type trait it is possible to evaluate the resulting expression type of a transpose sparse vector/scalar division. Given the transpose sparse vector type VT and the scalar type ST, the nested type Type corresponds to the resulting expression type. In case either VT is not a transpose sparse vector type or ST is not a scalar type, the resulting Type is set to INVALID_TYPE. More...
 
struct  TSVecScalarMultExprTrait
 Evaluation of the expression type of a transpose sparse vector/scalar multiplication.Via this type trait it is possible to evaluate the resulting expression type of a transpose sparse vector/scalar multiplication. Given the transpose sparse vector type VT and the scalar type ST, the nested type Type corresponds to the resulting expression type. In case either VT is not a transpose sparse vector type or ST is not a scalar type, the resulting Type is set to INVALID_TYPE. More...
 
struct  TSVecSerialExprTrait
 Evaluation of the expression type of a sparse vector serial evaluation operation.Via this type trait it is possible to evaluate the resulting expression type of a sparse vector serial evaluation operation. Given the transpose sparse vector type VT, the nested type Type corresponds to the resulting expression type. In case VT is not a transpose sparse vector type, the resulting Type is set to INVALID_TYPE. 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...
 
struct  TSVecSMatMultExprTrait
 Evaluation of the expression type of a sparse vector/sparse matrix multiplication.Via this type trait it is possible to evaluate the resulting expression type of a sparse vector/sparse matrix multiplication. Given the transpose sparse vector type VT and the row-major sparse matrix type MT, the nested type Type corresponds to the resulting expression type. In case either VT is not a transpose sparse vector type or MT is not a row-major sparse matrix type, the resulting data type Type is set to INVALID_TYPE. More...
 
struct  TSVecSVecMultExprTrait
 Evaluation of the expression type of a transpose sparse vector/sparse vector multiplication.Via this type trait it is possible to evaluate the resulting expression type of a transpose sparse vector/sparse vector multiplication (inner product). Given the transpose sparse vector type VT1 and the non-transpose sparse vector type VT2, the nested type Type corresponds to the resulting expression type. In case either VT1 is not a transpose sparse vector type or VT2 is not a non-transpose sparse vector type, the resulting Type is set to INVALID_TYPE. 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...
 
struct  TSVecTDMatMultExprTrait
 Evaluation of the expression type of a sparse vector/transpose dense matrix multiplication.Via this type trait it is possible to evaluate the resulting expression type of a sparse vector/transpose dense matrix multiplication. Given the transpose sparse vector type VT and the column-major dense matrix type MT, the nested type Type corresponds to the resulting expression type. In case either VT is not a transpose sparse vector type or MT is not a column-major dense matrix type, the resulting data type Type is set to INVALID_TYPE. More...
 
struct  TSVecTDVecAddExprTrait
 Evaluation of the expression type of a transpose sparse vector/transpose dense vector addition.Via this type trait it is possible to evaluate the resulting expression type of a transpose sparse vector/transpose dense vector addition. Given the transpose sparse vector type VT1 and the transpose dense vector type VT2, the nested type Type corresponds to the resulting expression type. In case either VT1 is not a transpose sparse vector type or VT2 is not a transpose dense vector type, the resulting Type is set to INVALID_TYPE. More...
 
struct  TSVecTDVecCrossExprTrait
 Evaluation of the expression type of a sparse vector/dense vector cross product.Via this type trait it is possible to evaluate the resulting expression type of a sparse vector/dense vector cross product. Given the transpose sparse vector type VT1 and the transpose dense vector typeVT2, the nested type Type corresponds to the resulting expression type. In case either VT1 is not a transpose sparse vector type or VT2 is not a transpose dense vector type, the resulting Type is set to INVALID_TYPE. More...
 
struct  TSVecTDVecDivExprTrait
 Evaluation of the expression type of a transpose sparse vector/transpose dense vector division.Via this type trait it is possible to evaluate the resulting expression type of a transpose sparse vector/transpose dense vector division. Given the transpose sparse vector type VT1 and the transpose dense vector type VT2, the nested type Type corresponds to the resulting expression type. In case either VT1 is not a transpose sparse vector type or VT2 is not a transpose dense vector type, the resulting Type is set to INVALID_TYPE. More...
 
struct  TSVecTDVecMultExprTrait
 Evaluation of the expression type of a transpose sparse vector/transpose dense vector multiplication.Via this type trait it is possible to evaluate the resulting expression type of a transpose sparse vector/transpose dense vector multiplication. Given the transpose sparse vector type VT1 and the transpose dense vector type VT2, the nested type Type corresponds to the resulting expression type. In case either VT1 is not a transpose sparse vector type or VT2 is not a transpose dense vector type, the resulting Type is set to INVALID_TYPE. More...
 
struct  TSVecTDVecSubExprTrait
 Evaluation of the expression type of a transpose sparse vector/transpose dense vector subtraction.Via this type trait it is possible to evaluate the resulting expression type of a transpose sparse vector/transpose dense vector subtraction. Given the transpose sparse vector type VT1 and the transpose dense vector type VT2, the nested type Type corresponds to the resulting expression type. In case either VT1 is not a transpose sparse vector type or VT2 is not a transpose dense vector type, the resulting Type is set to INVALID_TYPE. More...
 
struct  TSVecTransExprTrait
 Evaluation of the expression type of a sparse vector transpose operation.Via this type trait it is possible to evaluate the resulting expression type of a sparse vector transpose operation. Given the transpose sparse vector type VT, the nested type Type corresponds to the resulting expression type. In case VT is not a transpose sparse vector type, the resulting Type is set to INVALID_TYPE. 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  TSVecTSMatMultExprTrait
 Evaluation of the expression type of a sparse vector/transpose sparse matrix multiplication.Via this type trait it is possible to evaluate the resulting expression type of a sparse vector/transpose sparse matrix multiplication. Given the transpose sparse vector type VT and the column-major sparse matrix type MT, the nested type Type corresponds to the resulting expression type. In case either VT is not a transpose sparse vector type or MT is not a column-major sparse matrix type, the resulting data type Type is set to INVALID_TYPE. More...
 
struct  TSVecTSVecAddExprTrait
 Evaluation of the expression type of a transpose sparse vector/transpose sparse vector addition.Via this type trait it is possible to evaluate the resulting expression type of a transpose sparse vector/transpose sparse vector addition. Given the two transpose sparse vector types VT1 and VT2, the nested type Type corresponds to the resulting expression type. In case either VT1 or VT2 is not a transpose sparse vector type, the resulting Type is set to INVALID_TYPE. More...
 
struct  TSVecTSVecCrossExprTrait
 Evaluation of the expression type of a sparse vector/sparse vector cross product.Via this type trait it is possible to evaluate the resulting expression type of a sparse vector/sparse vector cross product. Given the two transpose sparse vector types VT1 and VT2, the nested type Type corresponds to the resulting expression type. In case either VT1 or VT2 is not a transpose sparse vector type, the resulting Type is set to INVALID_TYPE. More...
 
struct  TSVecTSVecMultExprTrait
 Evaluation of the expression type of a transpose sparse vector/transpose sparse vector multiplication.Via this type trait it is possible to evaluate the resulting expression type of a transpose sparse vector/transpose sparse vector multiplication. Given the two transpose sparse vector types VT1 and VT2, the nested type Type corresponds to the resulting expression type. In case either VT1 or VT2 is not a transpose sparse vector type, the resulting Type is set to INVALID_TYPE. More...
 
struct  TSVecTSVecSubExprTrait
 Evaluation of the expression type of a transpose sparse vector/transpose sparse vector subtraction.Via this type trait it is possible to evaluate the resulting expression type of a transpose sparse vector/transpose sparse vector subtraction. Given the two transpose sparse vector types VT1 and VT2, the nested type Type corresponds to the resulting expression type. In case either VT1 or VT2 is not a transpose sparse vector type, the resulting Type is set to INVALID_TYPE. 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 from this class in order to qualify as vector/matrix multiplication expression template. Only in case a class is derived from the TVecMatMultExpr base class, the IsTVecMatMultExpr type trait recognizes the class as valid vector/matrix multiplication expression template. More...
 
class  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 Result. The following example gives an impression of the use of the TypeAt class: More...
 
struct  TypeList
 Implementation of a type list.The TypeList class is an implementation of a type list according to the example of Andrei Alexandrescu. The type list merely consists of the two data types Head and Tail. In order to create type lists of more data types, the TypeList class is used recursively: 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  UnderlyingBuiltin
 Evaluation of the underlying builtin element type of a given data type.Via this type trait it is possible to evaluate the underlying fundamental element type at the heart of a given data type. Examples: More...
 
struct  UnderlyingElement
 Evaluation of the element type of a given data type.Via this type trait it is possible to evaluate the element type of a given data type. Examples: More...
 
struct  UnderlyingNumeric
 Evaluation of the underlying numeric element type of a given data type.Via this type trait it is possible to evaluate the underlying numeric (fundamental or complex) element type at the heart of a given data type. Examples: 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 $ 3 \times 3 $ sparse lower unitriangular matrix: More...
 
class  UniLowerMatrix
 Matrix adapter for lower unitriangular $ N \times N $ matrices. More...
 
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 $ 3 \times 3 $ dense lower unitriangular matrix: More...
 
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 $ 3 \times 3 $ sparse lower unitriangular matrix: More...
 
class  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 $ 3 \times 3 $ sparse upper unitriangular matrix: More...
 
class  UniUpperMatrix
 Matrix adapter for upper unitriangular $ N \times N $ matrices. More...
 
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 $ 3 \times 3 $ dense upper unitriangular matrix: More...
 
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 $ 3 \times 3 $ sparse upper unitriangular matrix: More...
 
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 $ N \times N $ matrices. More...
 
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 $ 3 \times 3 $ dense upper matrix: More...
 
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 from this class in order to qualify as vector evaluation expression template. Only in case a class is derived from the VecEvalExpr base class, the IsVecEvalExpr type trait recognizes the class as valid vector evaluation expression template. More...
 
struct  VecForEachExpr
 Base class for all vector for-each expression templates.The VecForEachExpr class serves as a tag for all expression templates that represent a unary, custom operation on a vector. All classes, that represent a vector custom operation and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as vector for-each expression template. Only in case a class is derived from the VecForEachExpr base class, the IsVecForEachExpr type trait recognizes the class as valid vector for-each expression template. More...
 
struct  VecScalarDivExpr
 Base class for all vector/scalar division expression templates.The VecScalarDivExpr class serves as a tag for all expression templates that implement a vector/scalar division. All classes, that represent a vector/scalar division and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as vector/scalar division expression template. Only in case a class is derived from the VecScalarDivExpr base class, the IsVecScalarDivExpr type trait recognizes the class as valid vector/scalar division expression template. More...
 
struct  VecScalarMultExpr
 Base class for all vector/scalar multiplication expression templates.The VecScalarMultExpr class serves as a tag for all expression templates that implement a vector/scalar multiplication. All classes, that represent a vector/scalar multiplication and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as vector/scalar multiplication expression template. Only in case a class is derived from the VecScalarMultExpr base class, the IsVecScalarMultExpr type trait recognizes the class as valid vector/scalar multiplication expression template. More...
 
struct  VecSerialExpr
 Base class for all vector serial evaluation expression templates.The VecSerialExpr class serves as a tag for all expression templates that enforce a serial evaluation of a vector. All classes, that represent a vector serialization operation and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as vector serial evaluation expression template. Only in case a class is derived from the VecSerialExpr base class, the IsVecSerialExpr type trait recognizes the class as valid vector serial evaluation expression template. More...
 
struct  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 from this class in order to qualify as vector transposition expression template. Only in case a class is derived from the VecTransExpr base class, the IsVecTransExpr type trait recognizes the class as valid vector transposition expression template. More...
 
struct  VecTVecMultExpr
 Base class for all outer product expression templates.The VecTVecMultExpr class serves as a tag for all expression templates that implement mathematical outer products (i.e. multiplications between a column vector and a row vector). All classes, that represent a mathematical outer product and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as outer product expression template. Only in case a class is derived from the VecTVecMultExpr base class, the IsVecTVecMultExpr type trait recognizes the class as valid outer product expression template. More...
 
struct  VecVecAddExpr
 Base class for all vector/vector addition expression templates.The VecVecAddExpr class serves as a tag for all expression templates that implement a vector/vector addition. All classes, that represent a vector addition and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as vector addition expression template. Only in case a class is derived from the VecVecAddExpr base class, the IsVecVecAddExpr type trait recognizes the class as valid vector addition expression template. More...
 
struct  VecVecDivExpr
 Base class for all vector/vector division expression templates.The VecVecDivExpr class serves as a tag for all expression templates that implement a vector/vector division. All classes, that represent a vector division and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as vector division expression template. Only in case a class is derived from the VecVecDivExpr base class, the IsVecVecDivExpr type trait recognizes the class as valid vector division expression template. More...
 
struct  VecVecMultExpr
 Base class for all vector/vector multiplication expression templates.The VecVecMultExpr class serves as a tag for all expression templates that implement a vector/vector multiplication. All classes, that represent a vector multiplication and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as vector multiplication expression template. Only in case a class is derived from the VecVecMultExpr base class, the IsVecVecMultExpr type trait recognizes the class as valid vector multiplication expression template. More...
 
struct  VecVecSubExpr
 Base class for all vector/vector subtraction expression templates.The VecVecSubExpr class serves as a tag for all expression templates that implement a vector/vector subtraction. All classes, that represent a vector subtraction and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as vector subtraction expression template. Only in case a class is derived from the VecVecSubExpr base class, the IsVecVecSubExpr type trait recognizes the class as valid vector subtraction expression template. More...
 
struct  View
 Base class for all views.The View class serves as a tag for all views (subvectors, submatrices, rows, columns, ...). All classes that represent a view and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as a view. Only in case a class is derived from the View base class, the IsView type trait recognizes the class as valid view. More...
 
struct  Xor
 Compile time logical xor evaluation.The Xor class template performs at compile time a logical xor evaluation of the two given compile time conditions: More...
 

Typedefs

typedef double real_t
 Floating point data type of the Blaze library.This type definition offers the possibility to switch the floating point precision of the Blaze library between float, double and long double. More...
 
typedef std::mt19937 RNG
 Type of the random number generator of the Blaze library.This type definition represents the type of the random number generated used in the Blaze library. The default random number generator is the std::mt19937 mersenne-twister pseudo random number generator. For more information see the following reference documentation: More...
 
template<typename T >
using BaseType_ = typename T::BaseType
 Alias declaration for nested BaseType type definitions.The BaseType_ 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_ = typename T::CompositeType
 Alias declaration for nested CompositeType type definitions.The CompositeType_ 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_ = typename T::ConstIterator
 Alias declaration for nested ConstIterator type definitions.The ConstIterator_ 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_ = typename T::ConstPointer
 Alias declaration for nested ConstPointer type definitions.The ConstPointer_ 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_ = typename T::ConstReference
 Alias declaration for nested ConstReference type definitions.The ConstReference_ 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_ = typename T::ElementType
 Alias declaration for nested ElementType type definitions.The ElementType_ 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_ = typename T::Iterator
 Alias declaration for nested Iterator type definitions.The Iterator_ 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_ = typename T::LeftOperand
 Alias declaration for nested LeftOperand type definitions.The LeftOperand_ 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 Operand_ = typename T::Operand
 Alias declaration for nested Operand type definitions.The Operand_ 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_ = typename T::OppositeType
 Alias declaration for nested OppositeType type definitions.The OppositeType_ 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_ = typename T::Pointer
 Alias declaration for nested Pointer type definitions.The Pointer_ 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 T >
using Reference_ = typename T::Reference
 Alias declaration for nested Reference type definitions.The Reference_ 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_ = typename T::RepresentedType
 Alias declaration for nested RepresentedType type definitions.The RepresentedType_ 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 >
using ResultType_ = typename T::ResultType
 Alias declaration for nested ResultType type definitions.The ResultType_ 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_ = typename T::ReturnType
 Alias declaration for nested ReturnType type definitions.The ReturnType_ 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_ = typename T::RightOperand
 Alias declaration for nested RightOperand type definitions.The RightOperand_ 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_ = typename T::SIMDType
 Alias declaration for nested SIMDType type definitions.The SIMDType_ 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_ = typename T::TransposeType
 Alias declaration for nested TransposeType type definitions.The TransposeType_ 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_ = typename T::ValueType
 Alias declaration for nested ValueType type definitions.The ValueType_ 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...
 
typedef SIMDTrait< char >::Type SIMDchar
 The SIMD data type for 'char'.
 
typedef SIMDTrait< signed char >::Type SIMDschar
 The SIMD data type for 'signed char'.
 
typedef SIMDTrait< unsigned char >::Type SIMDuchar
 The SIMD data type for 'unsigned char'.
 
typedef SIMDTrait< wchar_t >::Type SIMDwchar
 The SIMD data type for 'wchar_t'.
 
typedef SIMDTrait< complex< char > >::Type SIMDcchar
 The SIMD data type for 'complex<char>'.
 
typedef SIMDTrait< complex< signed char > >::Type SIMDcschar
 The SIMD data type for 'complex<signed char>'.
 
typedef SIMDTrait< complex< unsigned char > >::Type SIMDcuchar
 The SIMD data type for 'complex<unsigned char>'.
 
typedef SIMDTrait< complex< wchar_t > >::Type SIMDcwchar
 The SIMD data type for 'complex<wchar_t>'.
 
typedef SIMDTrait< short >::Type SIMDshort
 The SIMD data type for 'short'.
 
typedef SIMDTrait< unsigned short >::Type SIMDushort
 The SIMD data type for 'unsigned short'.
 
typedef SIMDTrait< complex< short > >::Type SIMDcshort
 The SIMD data type for 'complex<short>'.
 
typedef SIMDTrait< complex< unsigned short > >::Type SIMDcushort
 The SIMD data type for 'complex<unsigned short>'.
 
typedef SIMDTrait< int >::Type SIMDint
 The SIMD data type for 'int'.
 
typedef SIMDTrait< unsigned int >::Type SIMDuint
 The SIMD data type for 'unsigned int'.
 
typedef SIMDTrait< complex< int > >::Type SIMDcint
 The SIMD data type for 'complex<int>'.
 
typedef SIMDTrait< complex< unsigned int > >::Type SIMDcuint
 The SIMD data type for 'complex<unsigned int>'.
 
typedef SIMDTrait< long >::Type SIMDlong
 The SIMD data type for 'long int'.
 
typedef SIMDTrait< unsigned long >::Type SIMDulong
 The SIMD data type for 'unsigned long int'.
 
typedef SIMDTrait< complex< long > >::Type SIMDclong
 The SIMD data type for 'complex<long int>'.
 
typedef SIMDTrait< complex< unsigned long > >::Type SIMDculong
 The SIMD data type for 'complex<unsigned long int>'.
 
template<typename T >
using SIMDTrait_ = typename SIMDTrait< T >::Type
 Auxiliary alias declaration for the SIMDTrait class template.The SIMDTrait_ 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...
 
typedef CompressedMatrix< Type, true > This
 Type of this CompressedMatrix instance.
 
typedef SparseMatrix< This, true > BaseType
 Base type of this CompressedMatrix instance.
 
typedef This ResultType
 Result type for expression template evaluations.
 
typedef CompressedMatrix< Type, false > OppositeType
 Result type with opposite storage order for expression template evaluations.
 
typedef CompressedMatrix< Type, false > TransposeType
 Transpose type for expression template evaluations.
 
typedef Type ElementType
 Type of the sparse matrix elements.
 
typedef const Type & ReturnType
 Return type for expression template evaluations.
 
typedef const ThisCompositeType
 Data type for composite expression templates.
 
typedef MatrixAccessProxy< ThisReference
 Reference to a non-constant matrix value.
 
typedef const Type & ConstReference
 Reference to a constant matrix value.
 
typedef Element * Iterator
 Iterator over non-constant elements.
 
typedef const Element * ConstIterator
 Iterator over constant elements.
 
template<typename T1 , typename T2 >
using AddExprTrait_ = typename AddExprTrait< T1, T2 >::Type
 Auxiliary alias declaration for the AddExprTrait class template.The AddExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the AddExprTrait class template. For instance, given the types T1 and T2 the following two type definitions are identical: More...
 
template<typename T1 , typename T2 >
using AddTrait_ = typename AddTrait< T1, T2 >::Type
 Auxiliary alias declaration for the AddTrait class template.The AddTrait_ 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 >
using ColumnExprTrait_ = typename ColumnExprTrait< MT >::Type
 Auxiliary alias declaration for the ColumnExprTrait type trait.The ColumnExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the ColumnExprTrait class template. For instance, given the matrix type MT the following two type definitions are identical: More...
 
template<typename MT >
using ColumnTrait_ = typename ColumnTrait< MT >::Type
 Auxiliary alias declaration for the ColumnTrait type trait.The ColumnTrait_ 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 CrossExprTrait_ = typename CrossExprTrait< T1, T2 >::Type
 Auxiliary alias declaration for the CrossExprTrait class template.The CrossExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the CrossExprTrait class template. For instance, given the types T1 and T2 the following two type definitions are identical: More...
 
template<typename T1 , typename T2 >
using CrossTrait_ = typename CrossTrait< T1, T2 >::Type
 Auxiliary alias declaration for the CrossTrait class template.The CrossTrait_ 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 T >
using CTransExprTrait_ = typename CTransExprTrait< T >::Type
 Auxiliary alias declaration for the CTransExprTrait class template.The CTransExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the CTransExprTrait class template. For instance, given the type T the following two type definitions are identical: More...
 
template<typename T >
using DerestrictTrait_ = typename DerestrictTrait< T >::Type
 Auxiliary alias declaration for the DerestrictTrait type trait.The DerestrictTrait_ 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 DivExprTrait_ = typename DivExprTrait< T1, T2 >::Type
 Auxiliary alias declaration for the DivExprTrait class template.The DivExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the DivExprTrait class template. For instance, given the types T1 and T2 the following two type definitions are identical: More...
 
template<typename T1 , typename T2 >
using DivTrait_ = typename DivTrait< T1, T2 >::Type
 Auxiliary alias declaration for the DivTrait class template.The DivTrait_ 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 MT >
using DMatCTransExprTrait_ = typename DMatCTransExprTrait< MT >::Type
 Auxiliary alias declaration for the DMatCTransExprTrait class template.The DMatCTransExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the DMatCTransExprTrait class template. For instance, given the row-major dense matrix type MT the following two type definitions are identical: More...
 
template<typename MT1 , typename MT2 >
using DMatDMatAddExprTrait_ = typename DMatDMatAddExprTrait< MT1, MT2 >::Type
 Auxiliary alias declaration for the DMatDMatAddExprTrait class template.The DMatDMatAddExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the DMatDMatAddExprTrait class template. For instance, given the row-major dense matrix types MT1 and MT2 the following two type definitions are identical: More...
 
template<typename MT1 , typename MT2 >
using DMatDMatMultExprTrait_ = typename DMatDMatMultExprTrait< MT1, MT2 >::Type
 Auxiliary alias declaration for the DMatDMatMultExprTrait class template.The DMatDMatMultExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the DMatDMatMultExprTrait class template. For instance, given the row-major dense matrix types MT1 and MT2 the following two type definitions are identical: More...
 
template<typename MT1 , typename MT2 >
using DMatDMatSubExprTrait_ = typename DMatDMatSubExprTrait< MT1, MT2 >::Type
 Auxiliary alias declaration for the DMatDMatSubExprTrait class template.The DMatDMatSubExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the DMatDMatSubExprTrait class template. For instance, given the row-major dense matrix types MT1 and MT2 the following two type definitions are identical: More...
 
template<typename MT , typename VT >
using DMatDVecMultExprTrait_ = typename DMatDVecMultExprTrait< MT, VT >::Type
 Auxiliary alias declaration for the DMatDVecMultExprTrait class template.The DMatDVecMultExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the DMatDVecMultExprTrait class template. For instance, given the row-major dense matrix type MT and the non-transpose dense vector type VT the following two type definitions are identical: More...
 
template<typename MT >
using DMatEvalExprTrait_ = typename DMatEvalExprTrait< MT >::Type
 Auxiliary alias declaration for the DMatEvalExprTrait class template.The DMatEvalExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the DMatEvalExprTrait class template. For instance, given the row-major dense matrix type MT the following two type definitions are identical: More...
 
template<typename MT , typename OP >
using DMatForEachExprTrait_ = typename DMatForEachExprTrait< MT, OP >::Type
 Auxiliary alias declaration for the DMatForEachExprTrait class template.The DMatForEachExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the DMatForEachExprTrait class template. For instance, given the row-major dense matrix type MT and the custom operation type OP the following two type definitions are identical: More...
 
template<typename MT >
using DMatInvExprTrait_ = typename DMatInvExprTrait< MT >::Type
 Auxiliary alias declaration for the DMatInvExprTrait class template.The DMatInvExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the DMatInvExprTrait class template. For instance, given the row-major dense matrix type MT the following two type definitions are identical: More...
 
template<typename MT , typename ST >
using DMatScalarDivExprTrait_ = typename DMatScalarDivExprTrait< MT, ST >::Type
 Auxiliary alias declaration for the DMatScalarDivExprTrait class template.The DMatScalarDivExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the DMatScalarDivExprTrait class template. For instance, given the row-major dense matrix type MT and the scalar type ST the following two type definitions are identical: More...
 
template<typename MT , typename ST >
using DMatScalarMultExprTrait_ = typename DMatScalarMultExprTrait< MT, ST >::Type
 Auxiliary alias declaration for the DMatScalarMultExprTrait class template.The DMatScalarMultExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the DMatScalarMultExprTrait class template. For instance, given the row-major dense matrix type MT and the scalar type ST the following two type definitions are identical: More...
 
template<typename MT >
using DMatSerialExprTrait_ = typename DMatSerialExprTrait< MT >::Type
 Auxiliary alias declaration for the DMatSerialExprTrait class template.The DMatSerialExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the DMatSerialExprTrait class template. For instance, given the row-major dense matrix type MT the following two type definitions are identical: More...
 
template<typename MT1 , typename MT2 >
using DMatSMatAddExprTrait_ = typename DMatSMatAddExprTrait< MT1, MT2 >::Type
 Auxiliary alias declaration for the DMatSMatAddExprTrait class template.The DMatSMatAddExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the DMatSMatAddExprTrait class template. For instance, given the row-major dense matrix type MT1 and the row-major sparse matrix type MT2 the following two type definitions are identical: More...
 
template<typename MT1 , typename MT2 >
using DMatSMatMultExprTrait_ = typename DMatSMatMultExprTrait< MT1, MT2 >::Type
 Auxiliary alias declaration for the DMatSMatMultExprTrait class template.The DMatSMatMultExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the DMatSMatMultExprTrait class template. For instance, given the row-major dense matrix type MT1 and the row-major sparse matrix type MT2 the following two type definitions are identical: More...
 
template<typename MT1 , typename MT2 >
using DMatSMatSubExprTrait_ = typename DMatSMatSubExprTrait< MT1, MT2 >::Type
 Auxiliary alias declaration for the DMatSMatSubExprTrait class template.The DMatSMatSubExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the DMatSMatSubExprTrait class template. For instance, given the row-major dense matrix type MT1 and the row-major sparse matrix type MT2 the following two type definitions are identical: More...
 
template<typename MT , typename VT >
using DMatSVecMultExprTrait_ = typename DMatSVecMultExprTrait< MT, VT >::Type
 Auxiliary alias declaration for the DMatSVecMultExprTrait class template.The DMatSVecMultExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the DMatSVecMultExprTrait class template. For instance, given the row-major dense matrix type MT and the non-transpose sparse vector type VT the following two type definitions are identical: More...
 
template<typename MT1 , typename MT2 >
using DMatTDMatAddExprTrait_ = typename DMatTDMatAddExprTrait< MT1, MT2 >::Type
 Auxiliary alias declaration for the DMatTDMatAddExprTrait class template.The DMatTDMatAddExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the DMatTDMatAddExprTrait class template. For instance, given the row-major dense matrix type MT1 and the column-major dense matrix type MT2 the following two type definitions are identical: More...
 
template<typename MT1 , typename MT2 >
using DMatTDMatMultExprTrait_ = typename DMatTDMatMultExprTrait< MT1, MT2 >::Type
 Auxiliary alias declaration for the DMatTDMatMultExprTrait class template.The DMatTDMatMultExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the DMatTDMatMultExprTrait class template. For instance, given the row-major dense matrix type MT1 and the column-major dense matrix type MT2 the following two type definitions are identical: More...
 
template<typename MT1 , typename MT2 >
using DMatTDMatSubExprTrait_ = typename DMatTDMatSubExprTrait< MT1, MT2 >::Type
 Auxiliary alias declaration for the DMatTDMatSubExprTrait class template.The DMatTDMatSubExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the DMatTDMatSubExprTrait class template. For instance, given the row-major dense matrix type MT1 and the column-major dense matrix type MT2 the following two type definitions are identical: More...
 
template<typename MT >
using DMatTransExprTrait_ = typename DMatTransExprTrait< MT >::Type
 Auxiliary alias declaration for the DMatTransExprTrait class template.The DMatTransExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the DMatTransExprTrait class template. For instance, given the row-major dense matrix type MT the following two type definitions are identical: More...
 
template<typename MT1 , typename MT2 >
using DMatTSMatAddExprTrait_ = typename DMatTSMatAddExprTrait< MT1, MT2 >::Type
 Auxiliary alias declaration for the DMatTSMatAddExprTrait class template.The DMatTSMatAddExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the DMatTSMatAddExprTrait class template. For instance, given the row-major dense matrix type MT1 and the column-major sparse matrix type MT2 the following two type definitions are identical: More...
 
template<typename MT1 , typename MT2 >
using DMatTSMatMultExprTrait_ = typename DMatTSMatMultExprTrait< MT1, MT2 >::Type
 Auxiliary alias declaration for the DMatTSMatMultExprTrait class template.The DMatTSMatMultExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the DMatTSMatMultExprTrait class template. For instance, given the row-major dense matrix type MT1 and the column-major sparse matrix type MT2 the following two type definitions are identical: More...
 
template<typename MT1 , typename MT2 >
using DMatTSMatSubExprTrait_ = typename DMatTSMatSubExprTrait< MT1, MT2 >::Type
 Auxiliary alias declaration for the DMatTSMatSubExprTrait class template.The DMatTSMatSubExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the DMatTSMatSubExprTrait class template. For instance, given the row-major dense matrix type MT1 and the column-major sparse matrix type MT2 the following two type definitions are identical: More...
 
template<typename VT >
using DVecCTransExprTrait_ = typename DVecCTransExprTrait< VT >::Type
 Auxiliary alias declaration for the DVecCTransExprTrait class template.The DVecCTransExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the DVecCTransExprTrait class template. For instance, given the non-transpose dense vector type VT the following two type definitions are identical: More...
 
template<typename VT1 , typename VT2 >
using DVecDVecAddExprTrait_ = typename DVecDVecAddExprTrait< VT1, VT2 >::Type
 Auxiliary alias declaration for the DVecDVecAddExprTrait class template.The DVecDVecAddExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the DVecDVecAddExprTrait class template. For instance, given the non-transpose dense vector types VT1 and VT2 the following two type definitions are identical: More...
 
template<typename VT1 , typename VT2 >
using DVecDVecCrossExprTrait_ = typename DVecDVecCrossExprTrait< VT1, VT2 >::Type
 Auxiliary alias declaration for the DVecDVecCrossExprTrait class template.The DVecDVecCrossExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the DVecDVecCrossExprTrait class template. For instance, given the non-transpose dense vector types VT1 and VT2 the following two type definitions are identical: More...
 
template<typename VT1 , typename VT2 >
using DVecDVecDivExprTrait_ = typename DVecDVecDivExprTrait< VT1, VT2 >::Type
 Auxiliary alias declaration for the DVecDVecDivExprTrait class template.The DVecDVecDivExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the DVecDVecDivExprTrait class template. For instance, given the non-transpose dense vector types VT1 and VT2 the following two type definitions are identical: More...
 
template<typename VT1 , typename VT2 >
using DVecDVecMultExprTrait_ = typename DVecDVecMultExprTrait< VT1, VT2 >::Type
 Auxiliary alias declaration for the DVecDVecMultExprTrait class template.The DVecDVecMultExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the DVecDVecMultExprTrait class template. For instance, given the non-transpose dense vector types VT1 and VT2 the following two type definitions are identical: More...
 
template<typename VT1 , typename VT2 >
using DVecDVecSubExprTrait_ = typename DVecDVecSubExprTrait< VT1, VT2 >::Type
 Auxiliary alias declaration for the DVecDVecSubExprTrait class template.The DVecDVecSubExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the DVecDVecSubExprTrait class template. For instance, given the non-transpose dense vector types VT1 and VT2 the following two type definitions are identical: More...
 
template<typename VT >
using DVecEvalExprTrait_ = typename DVecEvalExprTrait< VT >::Type
 Auxiliary alias declaration for the DVecEvalExprTrait class template.The DVecEvalExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the DVecEvalExprTrait class template. For instance, given the non-transpose dense vector type VT the following two type definitions are identical: More...
 
template<typename VT , typename OP >
using DVecForEachExprTrait_ = typename DVecForEachExprTrait< VT, OP >::Type
 Auxiliary alias declaration for the DVecForEachExprTrait class template.The DVecForEachExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the DVecForEachExprTrait class template. For instance, given the non-transpose dense vector type VT and the custom operation type OP the following two type definitions are identical: More...
 
template<typename VT , typename ST >
using DVecScalarDivExprTrait_ = typename DVecScalarDivExprTrait< VT, ST >::Type
 Auxiliary alias declaration for the DVecScalarDivExprTrait class template.The DVecScalarDivExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the DVecScalarDivExprTrait class template. For instance, given the non-transpose dense vector type VT and the scalar type ST the following two type definitions are identical: More...
 
template<typename VT , typename ST >
using DVecScalarMultExprTrait_ = typename DVecScalarMultExprTrait< VT, ST >::Type
 Auxiliary alias declaration for the DVecScalarMultExprTrait class template.The DVecScalarMultExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the DVecScalarMultExprTrait class template. For instance, given the non-transpose dense vector type VT and the scalar type ST the following two type definitions are identical: More...
 
template<typename VT >
using DVecSerialExprTrait_ = typename DVecSerialExprTrait< VT >::Type
 Auxiliary alias declaration for the DVecSerialExprTrait class template.The DVecSerialExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the DVecSerialExprTrait class template. For instance, given the non-transpose dense vector type VT the following two type definitions are identical: More...
 
template<typename VT1 , typename VT2 >
using DVecSVecAddExprTrait_ = typename DVecSVecAddExprTrait< VT1, VT2 >::Type
 Auxiliary alias declaration for the DVecSVecAddExprTrait class template.The DVecSVecAddExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the DVecSVecAddExprTrait class template. For instance, given the non-transpose dense vector type VT1 and the non-transpose sparse vector type VT2 the following two type definitions are identical: More...
 
template<typename VT1 , typename VT2 >
using DVecSVecCrossExprTrait_ = typename DVecSVecCrossExprTrait< VT1, VT2 >::Type
 Auxiliary alias declaration for the DVecSVecCrossExprTrait class template.The DVecSVecCrossExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the DVecSVecCrossExprTrait class template. For instance, given the non-transpose dense vector type VT1 and the non-transpose sparse vector type VT2 the following two type definitions are identical: More...
 
template<typename VT1 , typename VT2 >
using DVecSVecMultExprTrait_ = typename DVecSVecMultExprTrait< VT1, VT2 >::Type
 Auxiliary alias declaration for the DVecSVecMultExprTrait class template.The DVecSVecMultExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the DVecSVecMultExprTrait class template. For instance, given the non-transpose dense vector type VT1 and the non-transpose sparse vector type VT2 the following two type definitions are identical: More...
 
template<typename VT1 , typename VT2 >
using DVecSVecSubExprTrait_ = typename DVecSVecSubExprTrait< VT1, VT2 >::Type
 Auxiliary alias declaration for the DVecSVecSubExprTrait class template.The DVecSVecSubExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the DVecSVecSubExprTrait class template. For instance, given the non-transpose dense vector type VT1 and the non-transpose sparse vector type VT2 the following two type definitions are identical: More...
 
template<typename VT1 , typename VT2 >
using DVecTDVecMultExprTrait_ = typename DVecTDVecMultExprTrait< VT1, VT2 >::Type
 Auxiliary alias declaration for the DVecTDVecMultExprTrait class template.The DVecTDVecMultExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the DVecTDVecMultExprTrait class template. For instance, given the non-transpose dense vector type VT1 and the transpose dense vector type VT2 the following two type definitions are identical: More...
 
template<typename VT >
using DVecTransExprTrait_ = typename DVecTransExprTrait< VT >::Type
 Auxiliary alias declaration for the DVecTransExprTrait class template.The DVecTransExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the DVecTransExprTrait class template. For instance, given the non-transpose dense vector type VT the following two type definitions are identical: More...
 
template<typename VT1 , typename VT2 >
using DVecTSVecMultExprTrait_ = typename DVecTSVecMultExprTrait< VT1, VT2 >::Type
 Auxiliary alias declaration for the DVecTSVecMultExprTrait class template.The DVecTSVecMultExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the DVecTSVecMultExprTrait class template. For instance, given the non-transpose dense vector type VT1 and the transpose sparse vector type VT2 the following two type definitions are identical: More...
 
template<typename T >
using EvalExprTrait_ = typename EvalExprTrait< T >::Type
 Auxiliary alias declaration for the EvalExprTrait class template.The EvalExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the EvalExprTrait class template. For instance, given the type T the following two type definitions are identical: More...
 
template<typename T , typename OP >
using ForEachExprTrait_ = typename ForEachExprTrait< T, OP >::Type
 Auxiliary alias declaration for the ForEachExprTrait class template.The ForEachExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the ForEachExprTrait class template. For instance, given the data type T and custom operation type OP the following two type definitions are identical: More...
 
template<typename T , typename OP >
using ForEachTrait_ = typename ForEachTrait< T, OP >::Type
 Auxiliary alias declaration for the ForEachTrait class template.The ForEachTrait_ alias declaration provides a convenient shortcut to access the nested Type of the ForEachTrait class template. For instance, given the type T and the custom operation type OP the following two type definitions are identical: More...
 
template<typename T >
using ImagTrait_ = typename ImagTrait< T >::Type
 Auxiliary alias declaration for the ImagTrait class template.The ImagTrait_ alias declaration provides a convenient shortcut to access the nested Type of the ImagTrait class template. For instance, given the type T the following two type definitions are identical: More...
 
template<typename T >
using InvExprTrait_ = typename InvExprTrait< T >::Type
 Auxiliary alias declaration for the InvExprTrait class template.The InvExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the InvExprTrait class template. For instance, given the type T the following two type definitions are identical: More...
 
template<typename T1 , typename T2 >
using MultExprTrait_ = typename MultExprTrait< T1, T2 >::Type
 Auxiliary alias declaration for the MultExprTrait class template.The MultExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the MultExprTrait class template. For instance, given the types T1 and T2 the following two type definitions are identical: More...
 
template<typename T1 , typename T2 >
using MultTrait_ = typename MultTrait< T1, T2 >::Type
 Auxiliary alias declaration for the MultTrait class template.The MultTrait_ 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 >
using RealTrait_ = typename RealTrait< T >::Type
 Auxiliary alias declaration for the RealTrait class template.The RealTrait_ alias declaration provides a convenient shortcut to access the nested Type of the RealTrait class template. For instance, given the type T the following two type definitions are identical: More...
 
template<typename MT >
using RowExprTrait_ = typename RowExprTrait< MT >::Type
 Auxiliary alias declaration for the RowExprTrait type trait.The RowExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the RowExprTrait class template. For instance, given the matrix type MT the following two type definitions are identical: More...
 
template<typename MT >
using RowTrait_ = typename RowTrait< MT >::Type
 Auxiliary alias declaration for the RowTrait type trait.The RowTrait_ 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 T >
using SerialExprTrait_ = typename SerialExprTrait< T >::Type
 Auxiliary alias declaration for the SerialExprTrait class template.The SerialExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the SerialExprTrait class template. For instance, given the type T the following two type definitions are identical: More...
 
template<typename MT >
using SMatCTransExprTrait_ = typename SMatCTransExprTrait< MT >::Type
 Auxiliary alias declaration for the SMatCTransExprTrait class template.The SMatCTransExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the SMatCTransExprTrait class template. For instance, given the row-major sparse matrix type MT the following two type definitions are identical: More...
 
template<typename MT1 , typename MT2 >
using SMatDMatAddExprTrait_ = typename SMatDMatAddExprTrait< MT1, MT2 >::Type
 Auxiliary alias declaration for the SMatDMatAddExprTrait class template.The SMatDMatAddExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the SMatDMatAddExprTrait class template. For instance, given the row-major sparse matrix type MT1 and the row-major dense matrix type MT2 the following two type definitions are identical: More...
 
template<typename MT1 , typename MT2 >
using SMatDMatMultExprTrait_ = typename SMatDMatMultExprTrait< MT1, MT2 >::Type
 Auxiliary alias declaration for the SMatDMatMultExprTrait class template.The SMatDMatMultExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the SMatDMatMultExprTrait class template. For instance, given the row-major sparse matrix type MT1 and the row-major dense matrix type MT2 the following two type definitions are identical: More...
 
template<typename MT1 , typename MT2 >
using SMatDMatSubExprTrait_ = typename SMatDMatSubExprTrait< MT1, MT2 >::Type
 Auxiliary alias declaration for the SMatDMatSubExprTrait class template.The SMatDMatSubExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the SMatDMatSubExprTrait class template. For instance, given the row-major sparse matrix type MT1 and the row-major dense matrix type MT2 the following two type definitions are identical: More...
 
template<typename MT , typename VT >
using SMatDVecMultExprTrait_ = typename SMatDVecMultExprTrait< MT, VT >::Type
 Auxiliary alias declaration for the SMatDVecMultExprTrait class template.The SMatDVecMultExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the SMatDVecMultExprTrait class template. For instance, given the row-major sparse matrix type MT and the non-transpose dense vector type VT the following two type definitions are identical: More...
 
template<typename MT >
using SMatEvalExprTrait_ = typename SMatEvalExprTrait< MT >::Type
 Auxiliary alias declaration for the SMatEvalExprTrait class template.The SMatEvalExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the SMatEvalExprTrait class template. For instance, given the row-major sparse matrix type MT the following two type definitions are identical: More...
 
template<typename MT , typename OP >
using SMatForEachExprTrait_ = typename SMatForEachExprTrait< MT, OP >::Type
 Auxiliary alias declaration for the SMatForEachExprTrait class template.The SMatForEachExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the SMatForEachExprTrait class template. For instance, given the row-major sparse matrix type MT and the custom operation type OP the following two type definitions are identical: More...
 
template<typename MT , typename ST >
using SMatScalarDivExprTrait_ = typename SMatScalarDivExprTrait< MT, ST >::Type
 Auxiliary alias declaration for the SMatScalarDivExprTrait class template.The SMatScalarDivExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the SMatScalarDivExprTrait class template. For instance, given the row-major sparse matrix type MT and the scalar type ST the following two type definitions are identical: More...
 
template<typename MT , typename ST >
using SMatScalarMultExprTrait_ = typename SMatScalarMultExprTrait< MT, ST >::Type
 Auxiliary alias declaration for the SMatScalarMultExprTrait class template.The SMatScalarMultExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the SMatScalarMultExprTrait class template. For instance, given the row-major sparse matrix type MT and the scalar type ST the following two type definitions are identical: More...
 
template<typename MT >
using SMatSerialExprTrait_ = typename SMatSerialExprTrait< MT >::Type
 Auxiliary alias declaration for the SMatSerialExprTrait class template.The SMatSerialExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the SMatSerialExprTrait class template. For instance, given the row-major sparse matrix type MT the following two type definitions are identical: More...
 
template<typename MT1 , typename MT2 >
using SMatSMatAddExprTrait_ = typename SMatSMatAddExprTrait< MT1, MT2 >::Type
 Auxiliary alias declaration for the SMatSMatAddExprTrait class template.The SMatSMatAddExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the SMatSMatAddExprTrait class template. For instance, given the row-major sparse matrix types MT1 and MT2 the following two type definitions are identical: More...
 
template<typename MT1 , typename MT2 >
using SMatSMatMultExprTrait_ = typename SMatSMatMultExprTrait< MT1, MT2 >::Type
 Auxiliary alias declaration for the SMatSMatMultExprTrait class template.The SMatSMatMultExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the SMatSMatMultExprTrait class template. For instance, given the row-major sparse matrix types MT1 and MT2 the following two type definitions are identical: More...
 
template<typename MT1 , typename MT2 >
using SMatSMatSubExprTrait_ = typename SMatSMatSubExprTrait< MT1, MT2 >::Type
 Auxiliary alias declaration for the SMatSMatSubExprTrait class template.The SMatSMatSubExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the SMatSMatSubExprTrait class template. For instance, given the row-major sparse matrix types MT1 and MT2 the following two type definitions are identical: More...
 
template<typename MT , typename VT >
using SMatSVecMultExprTrait_ = typename SMatSVecMultExprTrait< MT, VT >::Type
 Auxiliary alias declaration for the SMatSVecMultExprTrait class template.The SMatSVecMultExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the SMatSVecMultExprTrait class template. For instance, given the row-major sparse matrix type MT and the non-transpose sparse vector type VT the following two type definitions are identical: More...
 
template<typename MT1 , typename MT2 >
using SMatTDMatAddExprTrait_ = typename SMatTDMatAddExprTrait< MT1, MT2 >::Type
 Auxiliary alias declaration for the SMatTDMatAddExprTrait class template.The SMatTDMatAddExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the SMatTDMatAddExprTrait class template. For instance, given the row-major sparse matrix type MT1 and the column-major dense matrix type MT2 the following two type definitions are identical: More...
 
template<typename MT1 , typename MT2 >
using SMatTDMatMultExprTrait_ = typename SMatTDMatMultExprTrait< MT1, MT2 >::Type
 Auxiliary alias declaration for the SMatTDMatMultExprTrait class template.The SMatTDMatMultExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the SMatTDMatMultExprTrait class template. For instance, given the row-major sparse matrix type MT1 and the column-major dense matrix type MT2 the following two type definitions are identical: More...
 
template<typename MT1 , typename MT2 >
using SMatTDMatSubExprTrait_ = typename SMatTDMatSubExprTrait< MT1, MT2 >::Type
 Auxiliary alias declaration for the SMatTDMatSubExprTrait class template.The SMatTDMatSubExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the SMatTDMatSubExprTrait class template. For instance, given the row-major sparse matrix type MT1 and the column-major dense matrix type MT2 the following two type definitions are identical: More...
 
template<typename MT >
using SMatTransExprTrait_ = typename SMatTransExprTrait< MT >::Type
 Auxiliary alias declaration for the SMatTransExprTrait class template.The SMatTransExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the SMatTransExprTrait class template. For instance, given the row-major sparse matrix type MT the following two type definitions are identical: More...
 
template<typename MT1 , typename MT2 >
using SMatTSMatAddExprTrait_ = typename SMatTSMatAddExprTrait< MT1, MT2 >::Type
 Auxiliary alias declaration for the SMatTSMatAddExprTrait class template.The SMatTSMatAddExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the SMatTSMatAddExprTrait class template. For instance, given the row-major sparse matrix type MT1 and the column-major sparse matrix type MT2 the following two type definitions are identical: More...
 
template<typename MT1 , typename MT2 >
using SMatTSMatMultExprTrait_ = typename SMatTSMatMultExprTrait< MT1, MT2 >::Type
 Auxiliary alias declaration for the SMatTSMatMultExprTrait class template.The SMatTSMatMultExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the SMatTSMatMultExprTrait class template. For instance, given the row-major sparse matrix type MT1 and the column-major sparse matrix type MT2 the following two type definitions are identical: More...
 
template<typename MT1 , typename MT2 >
using SMatTSMatSubExprTrait_ = typename SMatTSMatSubExprTrait< MT1, MT2 >::Type
 Auxiliary alias declaration for the SMatTSMatSubExprTrait class template.The SMatTSMatSubExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the SMatTSMatSubExprTrait class template. For instance, given the row-major sparse matrix type MT1 and the column-major sparse matrix type MT2 the following two type definitions are identical: More...
 
template<typename T1 , typename T2 >
using SubExprTrait_ = typename SubExprTrait< T1, T2 >::Type
 Auxiliary alias declaration for the SubExprTrait class template.The SubExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the SubExprTrait class template. For instance, given the types T1 and T2 the following two type definitions are identical: More...
 
template<typename MT , bool AF>
using SubmatrixExprTrait_ = typename SubmatrixExprTrait< MT, AF >::Type
 Auxiliary alias declaration for the SubmatrixExprTrait type trait.The SubmatrixExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the SubmatrixExprTrait class template. For instance, given the matrix type MT and the alignment flag AF the following two type definitions are identical: More...
 
template<typename MT >
using SubmatrixTrait_ = typename SubmatrixTrait< MT >::Type
 Auxiliary alias declaration for the SubmatrixTrait type trait.The SubmatrixTrait_ 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_ = typename SubTrait< T1, T2 >::Type
 Auxiliary alias declaration for the SubTrait class template.The SubTrait_ 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 , bool AF>
using SubvectorExprTrait_ = typename SubvectorExprTrait< VT, AF >::Type
 Auxiliary alias declaration for the SubvectorExprTrait type trait.The SubvectorExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the SubvectorExprTrait class template. For instance, given the vector type VT the following two type definitions are identical: More...
 
template<typename VT >
using SubvectorTrait_ = typename SubvectorTrait< VT >::Type
 Auxiliary alias declaration for the SubvectorTrait type trait.The SubvectorTrait_ 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 VT >
using SVecCTransExprTrait_ = typename SVecCTransExprTrait< VT >::Type
 Auxiliary alias declaration for the SVecCTransExprTrait class template.The SVecCTransExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the SVecCTransExprTrait class template. For instance, given the non-transpose sparse vector type VT the following two type definitions are identical: More...
 
template<typename VT1 , typename VT2 >
using SVecDVecAddExprTrait_ = typename SVecDVecAddExprTrait< VT1, VT2 >::Type
 Auxiliary alias declaration for the SVecDVecAddExprTrait class template.The SVecDVecAddExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the SVecDVecAddExprTrait class template. For instance, given the non-transpose sparse vector types VT1 and the non-transpose dense vector type VT2 the following two type definitions are identical: More...
 
template<typename VT1 , typename VT2 >
using SVecDVecCrossExprTrait_ = typename SVecDVecCrossExprTrait< VT1, VT2 >::Type
 Auxiliary alias declaration for the SVecDVecCrossExprTrait class template.The SVecDVecCrossExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the SVecDVecCrossExprTrait class template. For instance, given the non-transpose sparse vector types VT1 and the non-transpose dense vector type VT2 the following two type definitions are identical: More...
 
template<typename VT1 , typename VT2 >
using SVecDVecDivExprTrait_ = typename SVecDVecDivExprTrait< VT1, VT2 >::Type
 Auxiliary alias declaration for the SVecDVecDivExprTrait class template.The SVecDVecDivExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the SVecDVecDivExprTrait class template. For instance, given the non-transpose sparse vector types VT1 and the non-transpose dense vector type VT2 the following two type definitions are identical: More...
 
template<typename VT1 , typename VT2 >
using SVecDVecMultExprTrait_ = typename SVecDVecMultExprTrait< VT1, VT2 >::Type
 Auxiliary alias declaration for the SVecDVecMultExprTrait class template.The SVecDVecMultExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the SVecDVecMultExprTrait class template. For instance, given the non-transpose sparse vector types VT1 and the non-transpose dense vector type VT2 the following two type definitions are identical: More...
 
template<typename VT1 , typename VT2 >
using SVecDVecSubExprTrait_ = typename SVecDVecSubExprTrait< VT1, VT2 >::Type
 Auxiliary alias declaration for the SVecDVecSubExprTrait class template.The SVecDVecSubExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the SVecDVecSubExprTrait class template. For instance, given the non-transpose sparse vector types VT1 and the non-transpose dense vector type VT2 the following two type definitions are identical: More...
 
template<typename VT >
using SVecEvalExprTrait_ = typename SVecEvalExprTrait< VT >::Type
 Auxiliary alias declaration for the SVecEvalExprTrait class template.The SVecEvalExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the SVecEvalExprTrait class template. For instance, given the non-transpose sparse vector type VT the following two type definitions are identical: More...
 
template<typename VT , typename OP >
using SVecForEachExprTrait_ = typename SVecForEachExprTrait< VT, OP >::Type
 Auxiliary alias declaration for the SVecForEachExprTrait class template.The SVecForEachExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the SVecForEachExprTrait class template. For instance, given the non-transpose sparse vector type VT and the custom operation type OP the following two type definitions are identical: More...
 
template<typename VT , typename ST >
using SVecScalarDivExprTrait_ = typename SVecScalarDivExprTrait< VT, ST >::Type
 Auxiliary alias declaration for the SVecScalarDivExprTrait class template.The SVecScalarDivExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the SVecScalarDivExprTrait class template. For instance, given the non-transpose sparse vector type VT and the scalar type ST the following two type definitions are identical: More...
 
template<typename VT , typename ST >
using SVecScalarMultExprTrait_ = typename SVecScalarMultExprTrait< VT, ST >::Type
 Auxiliary alias declaration for the SVecScalarMultExprTrait class template.The SVecScalarMultExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the SVecScalarMultExprTrait class template. For instance, given the non-transpose sparse vector type VT and the scalar type ST the following two type definitions are identical: More...
 
template<typename VT >
using SVecSerialExprTrait_ = typename SVecSerialExprTrait< VT >::Type
 Auxiliary alias declaration for the SVecSerialExprTrait class template.The SVecSerialExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the SVecSerialExprTrait class template. For instance, given the non-transpose sparse vector type VT the following two type definitions are identical: More...
 
template<typename VT1 , typename VT2 >
using SVecSVecAddExprTrait_ = typename SVecSVecAddExprTrait< VT1, VT2 >::Type
 Auxiliary alias declaration for the SVecSVecAddExprTrait class template.The SVecSVecAddExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the SVecSVecAddExprTrait class template. For instance, given the non-transpose sparse vector types VT1 and VT2 the following two type definitions are identical: More...
 
template<typename VT1 , typename VT2 >
using SVecSVecCrossExprTrait_ = typename SVecSVecCrossExprTrait< VT1, VT2 >::Type
 Auxiliary alias declaration for the SVecSVecCrossExprTrait class template.The SVecSVecCrossExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the SVecSVecCrossExprTrait class template. For instance, given the non-transpose sparse vector types VT1 and VT2 the following two type definitions are identical: More...
 
template<typename VT1 , typename VT2 >
using SVecSVecMultExprTrait_ = typename SVecSVecMultExprTrait< VT1, VT2 >::Type
 Auxiliary alias declaration for the SVecSVecMultExprTrait class template.The SVecSVecMultExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the SVecSVecMultExprTrait class template. For instance, given the non-transpose sparse vector types VT1 and VT2 the following two type definitions are identical: More...
 
template<typename VT1 , typename VT2 >
using SVecSVecSubExprTrait_ = typename SVecSVecSubExprTrait< VT1, VT2 >::Type
 Auxiliary alias declaration for the SVecSVecSubExprTrait class template.The SVecSVecSubExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the SVecSVecSubExprTrait class template. For instance, given the non-transpose sparse vector types VT1 and VT2 the following two type definitions are identical: More...
 
template<typename VT1 , typename VT2 >
using SVecTDVecMultExprTrait_ = typename SVecTDVecMultExprTrait< VT1, VT2 >::Type
 Auxiliary alias declaration for the SVecTDVecMultExprTrait class template.The SVecTDVecMultExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the SVecTDVecMultExprTrait class template. For instance, given the non-transpose sparse vector type VT1 and the transpose dense vector type VT2 the following two type definitions are identical: More...
 
template<typename VT >
using SVecTransExprTrait_ = typename SVecTransExprTrait< VT >::Type
 Auxiliary alias declaration for the SVecTransExprTrait class template.The SVecTransExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the SVecTransExprTrait class template. For instance, given the non-transpose sparse vector type VT the following two type definitions are identical: More...
 
template<typename VT1 , typename VT2 >
using SVecTSVecMultExprTrait_ = typename SVecTSVecMultExprTrait< VT1, VT2 >::Type
 Auxiliary alias declaration for the SVecTSVecMultExprTrait class template.The SVecTSVecMultExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the SVecTSVecMultExprTrait class template. For instance, given the non-transpose sparse vector type VT1 and the transpose sparse vector type VT2 the following two type definitions are identical: More...
 
template<typename MT >
using TDMatCTransExprTrait_ = typename TDMatCTransExprTrait< MT >::Type
 Auxiliary alias declaration for the TDMatCTransExprTrait class template.The TDMatCTransExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the TDMatCTransExprTrait class template. For instance, given the column-major dense matrix type MT the following two type definitions are identical: More...
 
template<typename MT1 , typename MT2 >
using TDMatDMatAddExprTrait_ = typename TDMatDMatAddExprTrait< MT1, MT2 >::Type
 Auxiliary alias declaration for the TDMatDMatAddExprTrait class template.The TDMatDMatAddExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the TDMatDMatAddExprTrait class template. For instance, given the column-major dense matrix type MT1 and the row-major dense matrix type MT2 the following two type definitions are identical: More...
 
template<typename MT1 , typename MT2 >
using TDMatDMatMultExprTrait_ = typename TDMatDMatMultExprTrait< MT1, MT2 >::Type
 Auxiliary alias declaration for the TDMatDMatMultExprTrait class template.The TDMatDMatMultExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the TDMatDMatMultExprTrait class template. For instance, given the column-major dense matrix type MT1 and the row-major dense matrix type MT2 the following two type definitions are identical: More...
 
template<typename MT1 , typename MT2 >
using TDMatDMatSubExprTrait_ = typename TDMatDMatSubExprTrait< MT1, MT2 >::Type
 Auxiliary alias declaration for the TDMatDMatSubExprTrait class template.The TDMatDMatSubExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the TDMatDMatSubExprTrait class template. For instance, given the column-major dense matrix type MT1 and the row-major dense matrix type MT2 the following two type definitions are identical: More...
 
template<typename MT , typename VT >
using TDMatDVecMultExprTrait_ = typename TDMatDVecMultExprTrait< MT, VT >::Type
 Auxiliary alias declaration for the TDMatDVecMultExprTrait class template.The TDMatDVecMultExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the TDMatDVecMultExprTrait class template. For instance, given the column-major dense matrix type MT and the non-transpose dense vector type VT the following two type definitions are identical: More...
 
template<typename MT >
using TDMatEvalExprTrait_ = typename TDMatEvalExprTrait< MT >::Type
 Auxiliary alias declaration for the TDMatEvalExprTrait class template.The TDMatEvalExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the TDMatEvalExprTrait class template. For instance, given the column-major dense matrix type MT the following two type definitions are identical: More...
 
template<typename MT , typename OP >
using TDMatForEachExprTrait_ = typename TDMatForEachExprTrait< MT, OP >::Type
 Auxiliary alias declaration for the TDMatForEachExprTrait class template.The TDMatForEachExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the TDMatForEachExprTrait class template. For instance, given the column-major dense matrix type MT and the custom operation type OP the following two type definitions are identical: More...
 
template<typename MT >
using TDMatInvExprTrait_ = typename TDMatInvExprTrait< MT >::Type
 Auxiliary alias declaration for the TDMatInvExprTrait class template.The TDMatInvExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the TDMatInvExprTrait class template. For instance, given the column-major dense matrix type MT the following two type definitions are identical: More...
 
template<typename MT , typename ST >
using TDMatScalarDivExprTrait_ = typename TDMatScalarDivExprTrait< MT, ST >::Type
 Auxiliary alias declaration for the TDMatScalarDivExprTrait class template.The TDMatScalarDivExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the TDMatScalarDivExprTrait class template. For instance, given the column-major dense matrix type MT and the scalar type ST the following two type definitions are identical: More...
 
template<typename MT , typename ST >
using TDMatScalarMultExprTrait_ = typename TDMatScalarMultExprTrait< MT, ST >::Type
 Auxiliary alias declaration for the TDMatScalarMultExprTrait class template.The TDMatScalarMultExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the TDMatScalarMultExprTrait class template. For instance, given the column-major dense matrix type MT and the scalar type ST the following two type definitions are identical: More...
 
template<typename MT >
using TDMatSerialExprTrait_ = typename TDMatSerialExprTrait< MT >::Type
 Auxiliary alias declaration for the TDMatSerialExprTrait class template.The TDMatSerialExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the TDMatSerialExprTrait class template. For instance, given the column-major dense matrix type MT the following two type definitions are identical: More...
 
template<typename MT1 , typename MT2 >
using TDMatSMatAddExprTrait_ = typename TDMatSMatAddExprTrait< MT1, MT2 >::Type
 Auxiliary alias declaration for the TDMatSMatAddExprTrait class template.The TDMatSMatAddExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the TDMatSMatAddExprTrait class template. For instance, given the column-major dense matrix type MT1 and the row-major sparse matrix type MT2 the following two type definitions are identical: More...
 
template<typename MT1 , typename MT2 >
using TDMatSMatMultExprTrait_ = typename TDMatSMatMultExprTrait< MT1, MT2 >::Type
 Auxiliary alias declaration for the TDMatSMatMultExprTrait class template.The TDMatSMatMultExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the TDMatSMatMultExprTrait class template. For instance, given the column-major dense matrix type MT1 and the row-major sparse matrix type MT2 the following two type definitions are identical: More...
 
template<typename MT1 , typename MT2 >
using TDMatSMatSubExprTrait_ = typename TDMatSMatSubExprTrait< MT1, MT2 >::Type
 Auxiliary alias declaration for the TDMatSMatSubExprTrait class template.The TDMatSMatSubExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the TDMatSMatSubExprTrait class template. For instance, given the column-major dense matrix type MT1 and the row-major sparse matrix type MT2 the following two type definitions are identical: More...
 
template<typename MT , typename VT >
using TDMatSVecMultExprTrait_ = typename TDMatSVecMultExprTrait< MT, VT >::Type
 Auxiliary alias declaration for the TDMatSVecMultExprTrait class template.The TDMatSVecMultExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the TDMatSVecMultExprTrait class template. For instance, given the column-major dense matrix type MT and the non-transpose sparse vector type VT the following two type definitions are identical: More...
 
template<typename MT1 , typename MT2 >
using TDMatTDMatAddExprTrait_ = typename TDMatTDMatAddExprTrait< MT1, MT2 >::Type
 Auxiliary alias declaration for the TDMatTDMatAddExprTrait class template.The TDMatTDMatAddExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the TDMatTDMatAddExprTrait class template. For instance, given the column-major dense matrix types MT1 and MT2 the following two type definitions are identical: More...
 
template<typename MT1 , typename MT2 >
using TDMatTDMatMultExprTrait_ = typename TDMatTDMatMultExprTrait< MT1, MT2 >::Type
 Auxiliary alias declaration for the TDMatTDMatMultExprTrait class template.The TDMatTDMatMultExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the TDMatTDMatMultExprTrait class template. For instance, given the column-major dense matrix types MT1 and MT2 the following two type definitions are identical: More...
 
template<typename MT1 , typename MT2 >
using TDMatTDMatSubExprTrait_ = typename TDMatTDMatSubExprTrait< MT1, MT2 >::Type
 Auxiliary alias declaration for the TDMatTDMatSubExprTrait class template.The TDMatTDMatSubExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the TDMatTDMatSubExprTrait class template. For instance, given the column-major dense matrix types MT1 and MT2 the following two type definitions are identical: More...
 
template<typename MT >
using TDMatTransExprTrait_ = typename TDMatTransExprTrait< MT >::Type
 Auxiliary alias declaration for the TDMatTransExprTrait class template.The TDMatTransExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the TDMatTransExprTrait class template. For instance, given the column-major dense matrix type MT the following two type definitions are identical: More...
 
template<typename MT1 , typename MT2 >
using TDMatTSMatAddExprTrait_ = typename TDMatTSMatAddExprTrait< MT1, MT2 >::Type
 Auxiliary alias declaration for the TDMatTSMatAddExprTrait class template.The TDMatTSMatAddExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the TDMatTSMatAddExprTrait class template. For instance, given the column-major dense matrix type MT1 and the column-major sparse matrix type MT2 the following two type definitions are identical: More...
 
template<typename MT1 , typename MT2 >
using TDMatTSMatMultExprTrait_ = typename TDMatTSMatMultExprTrait< MT1, MT2 >::Type
 Auxiliary alias declaration for the TDMatTSMatMultExprTrait class template.The TDMatTSMatMultExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the TDMatTSMatMultExprTrait class template. For instance, given the column-major dense matrix type MT1 and the column-major sparse matrix type MT2 the following two type definitions are identical: More...
 
template<typename MT1 , typename MT2 >
using TDMatTSMatSubExprTrait_ = typename TDMatTSMatSubExprTrait< MT1, MT2 >::Type
 Auxiliary alias declaration for the TDMatTSMatSubExprTrait class template.The TDMatTSMatSubExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the TDMatTSMatSubExprTrait class template. For instance, given the column-major dense matrix type MT1 and the column-major sparse matrix type MT2 the following two type definitions are identical: More...
 
template<typename VT >
using TDVecCTransExprTrait_ = typename TDVecCTransExprTrait< VT >::Type
 Auxiliary alias declaration for the TDVecCTransExprTrait class template.The TDVecCTransExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the TDVecCTransExprTrait class template. For instance, given the transpose dense vector type VT the following two type definitions are identical: More...
 
template<typename VT , typename MT >
using TDVecDMatMultExprTrait_ = typename TDVecDMatMultExprTrait< VT, MT >::Type
 Auxiliary alias declaration for the TDVecDMatMultExprTrait class template.The TDVecDMatMultExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the TDVecDMatMultExprTrait class template. For instance, given the transpose dense vector type VT and the row-major dense matrix type MT the following two type definitions are identical: More...
 
template<typename VT1 , typename VT2 >
using TDVecDVecMultExprTrait_ = typename TDVecDVecMultExprTrait< VT1, VT2 >::Type
 Auxiliary alias declaration for the TDVecDVecMultExprTrait class template.The TDVecDVecMultExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the TDVecDVecMultExprTrait class template. For instance, given the transpose dense vector type VT1 and non-transpose dense vector type VT2 the following two type definitions are identical: More...
 
template<typename VT >
using TDVecEvalExprTrait_ = typename TDVecEvalExprTrait< VT >::Type
 Auxiliary alias declaration for the TDVecEvalExprTrait class template.The TDVecEvalExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the TDVecEvalExprTrait class template. For instance, given the transpose dense vector type VT the following two type definitions are identical: More...
 
template<typename VT , typename OP >
using TDVecForEachExprTrait_ = typename TDVecForEachExprTrait< VT, OP >::Type
 Auxiliary alias declaration for the TDVecForEachExprTrait class template.The TDVecForEachExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the TDVecForEachExprTrait class template. For instance, given the transpose dense vector type VT and the custom operation type OP the following two type definitions are identical: More...
 
template<typename VT , typename ST >
using TDVecScalarDivExprTrait_ = typename TDVecScalarDivExprTrait< VT, ST >::Type
 Auxiliary alias declaration for the TDVecScalarDivExprTrait class template.The TDVecScalarDivExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the TDVecScalarDivExprTrait class template. For instance, given the transpose dense vector type VT and the scalar type ST the following two type definitions are identical: More...
 
template<typename VT , typename ST >
using TDVecScalarMultExprTrait_ = typename TDVecScalarMultExprTrait< VT, ST >::Type
 Auxiliary alias declaration for the TDVecScalarMultExprTrait class template.The TDVecScalarMultExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the TDVecScalarMultExprTrait class template. For instance, given the transpose dense vector type VT and the scalar type ST the following two type definitions are identical: More...
 
template<typename VT >
using TDVecSerialExprTrait_ = typename TDVecSerialExprTrait< VT >::Type
 Auxiliary alias declaration for the TDVecSerialExprTrait class template.The TDVecSerialExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the TDVecSerialExprTrait class template. For instance, given the transpose dense vector type VT the following two type definitions are identical: More...
 
template<typename VT , typename MT >
using TDVecSMatMultExprTrait_ = typename TDVecSMatMultExprTrait< VT, MT >::Type
 Auxiliary alias declaration for the TDVecSMatMultExprTrait class template.The TDVecSMatMultExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the TDVecSMatMultExprTrait class template. For instance, given the transpose dense vector type VT and the row-major sparse matrix type MT the following two type definitions are identical: More...
 
template<typename VT1 , typename VT2 >
using TDVecSVecMultExprTrait_ = typename TDVecSVecMultExprTrait< VT1, VT2 >::Type
 Auxiliary alias declaration for the TDVecSVecMultExprTrait class template.The TDVecSVecMultExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the TDVecSVecMultExprTrait class template. For instance, given the transpose dense vector type VT1 and non-transpose sparse vector type VT2 the following two type definitions are identical: More...
 
template<typename VT , typename MT >
using TDVecTDMatMultExprTrait_ = typename TDVecTDMatMultExprTrait< VT, MT >::Type
 Auxiliary alias declaration for the TDVecTDMatMultExprTrait class template.The TDVecTDMatMultExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the TDVecTDMatMultExprTrait class template. For instance, given the transpose dense vector type VT and the column-major dense matrix type MT the following two type definitions are identical: More...
 
template<typename VT1 , typename VT2 >
using TDVecTDVecAddExprTrait_ = typename TDVecTDVecAddExprTrait< VT1, VT2 >::Type
 Auxiliary alias declaration for the TDVecTDVecAddExprTrait class template.The TDVecTDVecAddExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the TDVecTDVecAddExprTrait class template. For instance, given the transpose dense vector types VT1 and VT2 the following two type definitions are identical: More...
 
template<typename VT1 , typename VT2 >
using TDVecTDVecCrossExprTrait_ = typename TDVecTDVecCrossExprTrait< VT1, VT2 >::Type
 Auxiliary alias declaration for the TDVecTDVecCrossExprTrait class template.The TDVecTDVecCrossExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the TDVecTDVecCrossExprTrait class template. For instance, given the transpose dense vector types VT1 and VT2 the following two type definitions are identical: More...
 
template<typename VT1 , typename VT2 >
using TDVecTDVecDivExprTrait_ = typename TDVecTDVecDivExprTrait< VT1, VT2 >::Type
 Auxiliary alias declaration for the TDVecTDVecDivExprTrait class template.The TDVecTDVecDivExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the TDVecTDVecDivExprTrait class template. For instance, given the transpose dense vector types VT1 and VT2 the following two type definitions are identical: More...
 
template<typename VT1 , typename VT2 >
using TDVecTDVecMultExprTrait_ = typename TDVecTDVecMultExprTrait< VT1, VT2 >::Type
 Auxiliary alias declaration for the TDVecTDVecMultExprTrait class template.The TDVecTDVecMultExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the TDVecTDVecMultExprTrait class template. For instance, given the transpose dense vector types VT1 and VT2 the following two type definitions are identical: More...
 
template<typename VT1 , typename VT2 >
using TDVecTDVecSubExprTrait_ = typename TDVecTDVecSubExprTrait< VT1, VT2 >::Type
 Auxiliary alias declaration for the TDVecTDVecSubExprTrait class template.The TDVecTDVecSubExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the TDVecTDVecSubExprTrait class template. For instance, given the transpose dense vector types VT1 and VT2 the following two type definitions are identical: More...
 
template<typename VT >
using TDVecTransExprTrait_ = typename TDVecTransExprTrait< VT >::Type
 Auxiliary alias declaration for the TDVecTransExprTrait class template.The TDVecTransExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the TDVecTransExprTrait class template. For instance, given the transpose dense vector type VT the following two type definitions are identical: More...
 
template<typename VT , typename MT >
using TDVecTSMatMultExprTrait_ = typename TDVecTSMatMultExprTrait< VT, MT >::Type
 Auxiliary alias declaration for the TDVecTSMatMultExprTrait class template.The TDVecTSMatMultExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the TDVecTSMatMultExprTrait class template. For instance, given the transpose dense vector type VT and the column-major sparse matrix type MT the following two type definitions are identical: More...
 
template<typename VT1 , typename VT2 >
using TDVecTSVecAddExprTrait_ = typename TDVecTSVecAddExprTrait< VT1, VT2 >::Type
 Auxiliary alias declaration for the TDVecTSVecAddExprTrait class template.The TDVecTSVecAddExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the TDVecTSVecAddExprTrait class template. For instance, given the transpose dense vector type VT1 and the transpose sparse vector type VT2 the following two type definitions are identical: More...
 
template<typename VT1 , typename VT2 >
using TDVecTSVecCrossExprTrait_ = typename TDVecTSVecCrossExprTrait< VT1, VT2 >::Type
 Auxiliary alias declaration for the TDVecTSVecCrossExprTrait class template.The TDVecTSVecCrossExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the TDVecTSVecCrossExprTrait class template. For instance, given the transpose dense vector type VT1 and the transpose sparse vector type VT2 the following two type definitions are identical: More...
 
template<typename VT1 , typename VT2 >
using TDVecTSVecMultExprTrait_ = typename TDVecTSVecMultExprTrait< VT1, VT2 >::Type
 Auxiliary alias declaration for the TDVecTSVecMultExprTrait class template.The TDVecTSVecMultExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the TDVecTSVecMultExprTrait class template. For instance, given the transpose dense vector type VT1 and the transpose sparse vector type VT2 the following two type definitions are identical: More...
 
template<typename VT1 , typename VT2 >
using TDVecTSVecSubExprTrait_ = typename TDVecTSVecSubExprTrait< VT1, VT2 >::Type
 Auxiliary alias declaration for the TDVecTSVecSubExprTrait class template.The TDVecTSVecSubExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the TDVecTSVecSubExprTrait class template. For instance, given the transpose dense vector type VT1 and the transpose sparse vector type VT2 the following two type definitions are identical: More...
 
template<typename T >
using TransExprTrait_ = typename TransExprTrait< T >::Type
 Auxiliary alias declaration for the TransExprTrait class template.The TransExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the TransExprTrait class template. For instance, given the type T the following two type definitions are identical: More...
 
template<typename MT >
using TSMatCTransExprTrait_ = typename TSMatCTransExprTrait< MT >::Type
 Auxiliary alias declaration for the TSMatCTransExprTrait class template.The TSMatCTransExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the TSMatCTransExprTrait class template. For instance, given the column-major sparse matrix type MT the following two type definitions are identical: More...
 
template<typename MT1 , typename MT2 >
using TSMatDMatAddExprTrait_ = typename TSMatDMatAddExprTrait< MT1, MT2 >::Type
 Auxiliary alias declaration for the TSMatDMatAddExprTrait class template.The TSMatDMatAddExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the TSMatDMatAddExprTrait class template. For instance, given the column-major sparse matrix type MT1 and the row-major dense matrix type MT2 the following two type definitions are identical: More...
 
template<typename MT1 , typename MT2 >
using TSMatDMatMultExprTrait_ = typename TSMatDMatMultExprTrait< MT1, MT2 >::Type
 Auxiliary alias declaration for the TSMatDMatMultExprTrait class template.The TSMatDMatMultExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the TSMatDMatMultExprTrait class template. For instance, given the column-major sparse matrix type MT1 and the row-major dense matrix type MT2 the following two type definitions are identical: More...
 
template<typename MT1 , typename MT2 >
using TSMatDMatSubExprTrait_ = typename TSMatDMatSubExprTrait< MT1, MT2 >::Type
 Auxiliary alias declaration for the TSMatDMatSubExprTrait class template.The TSMatDMatSubExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the TSMatDMatSubExprTrait class template. For instance, given the column-major sparse matrix type MT1 and the row-major dense matrix type MT2 the following two type definitions are identical: More...
 
template<typename MT , typename VT >
using TSMatDVecMultExprTrait_ = typename TSMatDVecMultExprTrait< MT, VT >::Type
 Auxiliary alias declaration for the TSMatDVecMultExprTrait class template.The TSMatDVecMultExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the TSMatDVecMultExprTrait class template. For instance, given the column-major sparse matrix type MT and the non-transpose dense vector type VT the following two type definitions are identical: More...
 
template<typename MT >
using TSMatEvalExprTrait_ = typename TSMatEvalExprTrait< MT >::Type
 Auxiliary alias declaration for the TSMatEvalExprTrait class template.The TSMatEvalExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the TSMatEvalExprTrait class template. For instance, given the column-major sparse matrix type MT the following two type definitions are identical: More...
 
template<typename MT , typename OP >
using TSMatForEachExprTrait_ = typename TSMatForEachExprTrait< MT, OP >::Type
 Auxiliary alias declaration for the TSMatForEachExprTrait class template.The SMatForEachExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the SMatForEachExprTrait class template. For instance, given the column-major sparse matrix type MT and the custom operation type OP the following two type definitions are identical: More...
 
template<typename MT , typename ST >
using TSMatScalarDivExprTrait_ = typename TSMatScalarDivExprTrait< MT, ST >::Type
 Auxiliary alias declaration for the TSMatScalarDivExprTrait class template.The TSMatScalarDivExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the TSMatScalarDivExprTrait class template. For instance, given the column-major sparse matrix type MT and the scalar type ST the following two type definitions are identical: More...
 
template<typename MT , typename ST >
using TSMatScalarMultExprTrait_ = typename TSMatScalarMultExprTrait< MT, ST >::Type
 Auxiliary alias declaration for the TSMatScalarMultExprTrait class template.The TSMatScalarMultExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the TSMatScalarMultExprTrait class template. For instance, given the column-major sparse matrix type MT and the scalar type ST the following two type definitions are identical: More...
 
template<typename MT >
using TSMatSerialExprTrait_ = typename TSMatSerialExprTrait< MT >::Type
 Auxiliary alias declaration for the TSMatSerialExprTrait class template.The TSMatSerialExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the TSMatSerialExprTrait class template. For instance, given the column-major sparse matrix type MT the following two type definitions are identical: More...
 
template<typename MT1 , typename MT2 >
using TSMatSMatAddExprTrait_ = typename TSMatSMatAddExprTrait< MT1, MT2 >::Type
 Auxiliary alias declaration for the TSMatSMatAddExprTrait class template.The TSMatSMatAddExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the TSMatSMatAddExprTrait class template. For instance, given the column-major sparse matrix type MT1 and the row-major sparse matrix type MT2 the following two type definitions are identical: More...
 
template<typename MT1 , typename MT2 >
using TSMatSMatMultExprTrait_ = typename TSMatSMatMultExprTrait< MT1, MT2 >::Type
 Auxiliary alias declaration for the TSMatSMatMultExprTrait class template.The TSMatSMatMultExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the TSMatSMatMultExprTrait class template. For instance, given the column-major sparse matrix type MT1 and the row-major sparse matrix type MT2 the following two type definitions are identical: More...
 
template<typename MT1 , typename MT2 >
using TSMatSMatSubExprTrait_ = typename TSMatSMatSubExprTrait< MT1, MT2 >::Type
 Auxiliary alias declaration for the TSMatSMatSubExprTrait class template.The TSMatSMatSubExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the TSMatSMatSubExprTrait class template. For instance, given the column-major sparse matrix type MT1 and the row-major sparse matrix type MT2 the following two type definitions are identical: More...
 
template<typename MT , typename VT >
using TSMatSVecMultExprTrait_ = typename TSMatSVecMultExprTrait< MT, VT >::Type
 Auxiliary alias declaration for the TSMatSVecMultExprTrait class template.The TSMatSVecMultExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the TSMatSVecMultExprTrait class template. For instance, given the column-major sparse matrix type MT and the non-transpose sparse vector type VT the following two type definitions are identical: More...
 
template<typename MT1 , typename MT2 >
using TSMatTDMatAddExprTrait_ = typename TSMatTDMatAddExprTrait< MT1, MT2 >::Type
 Auxiliary alias declaration for the TSMatTDMatAddExprTrait class template.The TSMatTDMatAddExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the TSMatTDMatAddExprTrait class template. For instance, given the column-major sparse matrix type MT1 and the column-major dense matrix type MT2 the following two type definitions are identical: More...
 
template<typename MT1 , typename MT2 >
using TSMatTDMatMultExprTrait_ = typename TSMatTDMatMultExprTrait< MT1, MT2 >::Type
 Auxiliary alias declaration for the TSMatTDMatMultExprTrait class template.The TSMatTDMatMultExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the TSMatTDMatMultExprTrait class template. For instance, given the column-major sparse matrix type MT1 and the column-major dense matrix type MT2 the following two type definitions are identical: More...
 
template<typename MT1 , typename MT2 >
using TSMatTDMatSubExprTrait_ = typename TSMatTDMatSubExprTrait< MT1, MT2 >::Type
 Auxiliary alias declaration for the TSMatTDMatSubExprTrait class template.The TSMatTDMatSubExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the TSMatTDMatSubExprTrait class template. For instance, given the column-major sparse matrix type MT1 and the column-major dense matrix type MT2 the following two type definitions are identical: More...
 
template<typename MT >
using TSMatTransExprTrait_ = typename TSMatTransExprTrait< MT >::Type
 Auxiliary alias declaration for the TSMatTransExprTrait class template.The TSMatTransExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the TSMatTransExprTrait class template. For instance, given the column-major sparse matrix type MT the following two type definitions are identical: More...
 
template<typename MT1 , typename MT2 >
using TSMatTSMatAddExprTrait_ = typename TSMatTSMatAddExprTrait< MT1, MT2 >::Type
 Auxiliary alias declaration for the TSMatTSMatAddExprTrait class template.The TSMatTSMatAddExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the TSMatTSMatAddExprTrait class template. For instance, given the column-major sparse matrix types MT1 and MT2 the following two type definitions are identical: More...
 
template<typename MT1 , typename MT2 >
using TSMatTSMatMultExprTrait_ = typename TSMatTSMatMultExprTrait< MT1, MT2 >::Type
 Auxiliary alias declaration for the TSMatTSMatMultExprTrait class template.The TSMatTSMatMultExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the TSMatTSMatMultExprTrait class template. For instance, given the column-major sparse matrix types MT1 and MT2 the following two type definitions are identical: More...
 
template<typename MT1 , typename MT2 >
using TSMatTSMatSubExprTrait_ = typename TSMatTSMatSubExprTrait< MT1, MT2 >::Type
 Auxiliary alias declaration for the TSMatTSMatSubExprTrait class template.The TSMatTSMatSubExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the TSMatTSMatSubExprTrait class template. For instance, given the column-major sparse matrix types MT1 and MT2 the following two type definitions are identical: More...
 
template<typename VT >
using TSVecCTransExprTrait_ = typename TSVecCTransExprTrait< VT >::Type
 Auxiliary alias declaration for the TSVecCTransExprTrait class template.The TSVecCTransExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the TSVecCTransExprTrait class template. For instance, given the transpose sparse vector type VT the following two type definitions are identical: More...
 
template<typename VT , typename MT >
using TSVecDMatMultExprTrait_ = typename TSVecDMatMultExprTrait< VT, MT >::Type
 Auxiliary alias declaration for the TSVecDMatMultExprTrait class template.The TSVecDMatMultExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the TSVecDMatMultExprTrait class template. For instance, given the transpose sparse vector type VT and the row-major dense matrix type MT the following two type definitions are identical: More...
 
template<typename VT1 , typename VT2 >
using TSVecDVecMultExprTrait_ = typename TSVecDVecMultExprTrait< VT1, VT2 >::Type
 Auxiliary alias declaration for the TSVecDVecMultExprTrait class template.The TSVecDVecMultExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the TSVecDVecMultExprTrait class template. For instance, given the transpose sparse vector type VT1 and non-transpose dense vector type VT2 the following two type definitions are identical: More...
 
template<typename VT >
using TSVecEvalExprTrait_ = typename TSVecEvalExprTrait< VT >::Type
 Auxiliary alias declaration for the TSVecEvalExprTrait class template.The TSVecEvalExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the TSVecEvalExprTrait class template. For instance, given the transpose sparse vector type VT the following two type definitions are identical: More...
 
template<typename VT , typename OP >
using TSVecForEachExprTrait_ = typename TSVecForEachExprTrait< VT, OP >::Type
 Auxiliary alias declaration for the TSVecForEachExprTrait class template.The TSVecForEachExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the TSVecForEachExprTrait class template. For instance, given the transpose sparse vector type VT and the custom operation type OP the following two type definitions are identical: More...
 
template<typename VT , typename ST >
using TSVecScalarDivExprTrait_ = typename TSVecScalarDivExprTrait< VT, ST >::Type
 Auxiliary alias declaration for the TSVecScalarDivExprTrait class template.The TSVecScalarDivExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the TSVecScalarDivExprTrait class template. For instance, given the transpose sparse vector type VT and the scalar type ST the following two type definitions are identical: More...
 
template<typename VT , typename ST >
using TSVecScalarMultExprTrait_ = typename TSVecScalarMultExprTrait< VT, ST >::Type
 Auxiliary alias declaration for the TSVecScalarMultExprTrait class template.The TSVecScalarMultExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the TSVecScalarMultExprTrait class template. For instance, given the transpose sparse vector type VT and the scalar type ST the following two type definitions are identical: More...
 
template<typename VT >
using TSVecSerialExprTrait_ = typename TSVecSerialExprTrait< VT >::Type
 Auxiliary alias declaration for the TSVecSerialExprTrait class template.The TSVecSerialExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the TSVecSerialExprTrait class template. For instance, given the transpose sparse vector type VT the following two type definitions are identical: More...
 
template<typename VT , typename MT >
using TSVecSMatMultExprTrait_ = typename TSVecSMatMultExprTrait< VT, MT >::Type
 Auxiliary alias declaration for the TSVecSMatMultExprTrait class template.The TSVecSMatMultExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the TSVecSMatMultExprTrait class template. For instance, given the transpose sparse vector type VT and the row-major sparse matrix type MT the following two type definitions are identical: More...
 
template<typename VT1 , typename VT2 >
using TSVecSVecMultExprTrait_ = typename TSVecSVecMultExprTrait< VT1, VT2 >::Type
 Auxiliary alias declaration for the TSVecSVecMultExprTrait class template.The TSVecSVecMultExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the TSVecSVecMultExprTrait class template. For instance, given the transpose sparse vector type VT1 and non-transpose sparse vector type VT2 the following two type definitions are identical: More...
 
template<typename VT , typename MT >
using TSVecTDMatMultExprTrait_ = typename TSVecTDMatMultExprTrait< VT, MT >::Type
 Auxiliary alias declaration for the TSVecTDMatMultExprTrait class template.The TSVecTDMatMultExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the TSVecTDMatMultExprTrait class template. For instance, given the transpose sparse vector type VT and the column-major dense matrix type MT the following two type definitions are identical: More...
 
template<typename VT1 , typename VT2 >
using TSVecTDVecAddExprTrait_ = typename TSVecTDVecAddExprTrait< VT1, VT2 >::Type
 Auxiliary alias declaration for the TSVecTDVecAddExprTrait class template.The TSVecTDVecAddExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the TSVecTDVecAddExprTrait class template. For instance, given the transpose sparse vector types VT1 and the transpose dense vector type VT2 the following two type definitions are identical: More...
 
template<typename VT1 , typename VT2 >
using TSVecTDVecCrossExprTrait_ = typename TSVecTDVecCrossExprTrait< VT1, VT2 >::Type
 Auxiliary alias declaration for the TSVecTDVecCrossExprTrait class template.The TSVecTDVecCrossExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the TSVecTDVecCrossExprTrait class template. For instance, given the transpose sparse vector types VT1 and the transpose dense vector type VT2 the following two type definitions are identical: More...
 
template<typename VT1 , typename VT2 >
using TSVecTDVecDivExprTrait_ = typename TSVecTDVecDivExprTrait< VT1, VT2 >::Type
 Auxiliary alias declaration for the TSVecTDVecDivExprTrait class template.The TSVecTDVecDivExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the TSVecTDVecDivExprTrait class template. For instance, given the transpose sparse vector types VT1 and the transpose dense vector type VT2 the following two type definitions are identical: More...
 
template<typename VT1 , typename VT2 >
using TSVecTDVecMultExprTrait_ = typename TSVecTDVecMultExprTrait< VT1, VT2 >::Type
 Auxiliary alias declaration for the TSVecTDVecMultExprTrait class template.The TSVecTDVecMultExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the TSVecTDVecMultExprTrait class template. For instance, given the transpose sparse vector types VT1 and the transpose dense vector type VT2 the following two type definitions are identical: More...
 
template<typename VT1 , typename VT2 >
using TSVecTDVecSubExprTrait_ = typename TSVecTDVecSubExprTrait< VT1, VT2 >::Type
 Auxiliary alias declaration for the TSVecTDVecSubExprTrait class template.The TSVecTDVecSubExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the TSVecTDVecSubExprTrait class template. For instance, given the transpose sparse vector types VT1 and the transpose dense vector type VT2 the following two type definitions are identical: More...
 
template<typename VT >
using TSVecTransExprTrait_ = typename TSVecTransExprTrait< VT >::Type
 Auxiliary alias declaration for the TSVecTransExprTrait class template.The TSVecTransExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the TSVecTransExprTrait class template. For instance, given the transpose sparse vector type VT the following two type definitions are identical: More...
 
template<typename VT , typename MT >
using TSVecTSMatMultExprTrait_ = typename TSVecTSMatMultExprTrait< VT, MT >::Type
 Auxiliary alias declaration for the TSVecTSMatMultExprTrait class template.The TSVecTSMatMultExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the TSVecTSMatMultExprTrait class template. For instance, given the transpose sparse vector type VT and the column-major sparse matrix type MT the following two type definitions are identical: More...
 
template<typename VT1 , typename VT2 >
using TSVecTSVecAddExprTrait_ = typename TSVecTSVecAddExprTrait< VT1, VT2 >::Type
 Auxiliary alias declaration for the TSVecTSVecAddExprTrait class template.The TSVecTSVecAddExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the TSVecTSVecAddExprTrait class template. For instance, given the transpose sparse vector types VT1 and VT2 the following two type definitions are identical: More...
 
template<typename VT1 , typename VT2 >
using TSVecTSVecCrossExprTrait_ = typename TSVecTSVecCrossExprTrait< VT1, VT2 >::Type
 Auxiliary alias declaration for the TSVecTSVecCrossExprTrait class template.The TSVecTSVecCrossExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the TSVecTSVecCrossExprTrait class template. For instance, given the transpose sparse vector types VT1 and VT2 the following two type definitions are identical: More...
 
template<typename VT1 , typename VT2 >
using TSVecTSVecMultExprTrait_ = typename TSVecTSVecMultExprTrait< VT1, VT2 >::Type
 Auxiliary alias declaration for the TSVecTSVecMultExprTrait class template.The TSVecTSVecMultExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the TSVecTSVecMultExprTrait class template. For instance, given the transpose sparse vector types VT1 and VT2 the following two type definitions are identical: More...
 
template<typename VT1 , typename VT2 >
using TSVecTSVecSubExprTrait_ = typename TSVecTSVecSubExprTrait< VT1, VT2 >::Type
 Auxiliary alias declaration for the TSVecTSVecSubExprTrait class template.The TSVecTSVecSubExprTrait_ alias declaration provides a convenient shortcut to access the nested Type of the TSVecTSVecSubExprTrait class template. For instance, given the transpose sparse vector types VT1 and VT2 the following two type definitions are identical: More...
 
template<typename T >
using RemoveAdaptor_ = typename RemoveAdaptor< T >::Type
 Auxiliary alias declaration for the RemoveAdaptor type trait.The RemoveAdaptor_ 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...
 
template<typename T >
using UnderlyingBuiltin_ = typename UnderlyingBuiltin< T >::Type
 Auxiliary alias declaration for the UnderlyingBuiltin type trait.The UnderlyingBuiltin_ 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_ = typename UnderlyingElement< T >::Type
 Auxiliary alias declaration for the UnderlyingElement type trait.The UnderlyingElement_ 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_ = typename UnderlyingNumeric< T >::Type
 Auxiliary alias declaration for the UnderlyingNumeric type trait.The UnderlyingNumeric_ 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...
 
template<bool Condition, typename T = void>
using DisableIfTrue_ = typename DisableIfTrue< Condition, T >::Type
 Auxiliary type for the DisableIfTrue class template.The DisableIfTrue_ alias declaration provides a convenient shortcut to access the nested Type of the DisableIfTrue class template. For instance, given the type T the following two type definitions are identical: More...
 
template<typename Condition , typename T = void>
using DisableIf_ = typename DisableIf< Condition, T >::Type
 Auxiliary type for the DisableIf class template.The DisableIf_ 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 EnableIfTrue_ = typename EnableIfTrue< Condition, T >::Type
 Auxiliary type for the EnableIfTrue class template.The EnableIfTrue_ alias declaration provides a convenient shortcut to access the nested Type of the EnableIfTrue class template. For instance, given the type T the following two type definitions are identical: More...
 
template<typename Condition , typename T = void>
using EnableIf_ = typename EnableIf< Condition, T >::Type
 Auxiliary alias declaration for the EnableIf class template.The EnableIf_ 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...
 
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.
 
template<bool B>
using BoolConstant = IntegralConstant< bool, B >
 Generic wrapper for a compile time constant boolean value.The BoolConstant class 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...
 
template<bool Condition, typename T1 , typename T2 >
using IfTrue_ = typename IfTrue< Condition, T1, T2 >::Type
 Auxiliary alias declaration for the IfTrue class template.The IfTrue_ alias declaration provides a convenient shortcut to access the nested Type of the IfTrue class template. For instance, given the types C, T1, and T2 the following two type definitions are identical: More...
 
template<typename T1 , typename T2 , typename T3 >
using If_ = typename If< T1, T2, T3 >::Type
 Auxiliary alias declaration for the If class template.The If_ alias declaration provides a convenient shortcut to access the nested Type of the If class template. For instance, given the types T1, T2, and T3 the following two type definitions are identical: More...
 
typedef std::shared_ptr< SystemClockSystemClockID
 Handle for the system clock of the Blaze library.
 
typedef std::shared_ptr< const SystemClockConstSystemClockID
 Handle for the system clock of the Blaze library.
 
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.
 
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.
 
template<typename T >
using AddConst_ = typename AddConst< T >::Type
 Auxiliary alias declaration for the AddConst type trait.The AddConst_ 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_ = typename AddCV< T >::Type
 Auxiliary alias declaration for the AddCV type trait.The AddCV_ 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_ = typename AddPointer< T >::Type
 Auxiliary alias declaration for the AddPointer type trait.The AddPointer_ 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_ = typename AddReference< T >::Type
 Auxiliary alias declaration for the AddReference type trait.The AddReference_ 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_ = typename AddVolatile< T >::Type
 Auxiliary alias declaration for the AddVolatile type trait.The AddVolatile_ 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_ = typename CommonType< T... >::Type
 Auxiliary alias declaration for the CommonType type trait.The CommonType_ 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_ = typename Decay< T >::Type
 Auxiliary alias declaration for the Decay type trait.The Decay_ 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_ = typename MakeSigned< T >::Type
 Auxiliary alias declaration for the MakeSigned type trait.The MakeSigned_ 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_ = typename MakeUnsigned< T >::Type
 Auxiliary alias declaration for the MakeUnsigned type trait.The MakeUnsigned_ 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_ = typename RemoveAllExtents< T >::Type
 Auxiliary alias declaration for the RemoveAllExtents type trait.The RemoveAllExtents_ 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_ = typename RemoveConst< T >::Type
 Auxiliary alias declaration for the RemoveConst type trait.The RemoveConst_ 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_ = typename RemoveCV< T >::Type
 Auxiliary alias declaration for the RemoveCV type trait.The RemoveCV_ 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 RemoveExtent_ = typename RemoveExtent< T >::Type
 Auxiliary alias declaration for the RemoveExtent type trait.The RemoveExtent_ 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_ = typename RemovePointer< T >::Type
 Auxiliary alias declaration for the RemovePointer type trait.The RemovePointer_ 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_ = typename RemoveReference< T >::Type
 Auxiliary alias declaration for the RemoveReference type trait.The RemoveReference_ 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_ = typename RemoveVolatile< T >::Type
 Auxiliary alias declaration for the RemoveVolatile type trait.The RemoveVolatile_ 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...
 

Enumerations

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...
 
enum  : bool { smpAssignable = !IsSMPAssignable<Type>::value }
 Compilation flag for SMP assignments. More...
 

Functions

template<typename A , typename T >
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 >
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 >
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 >
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 T1 , typename T2 , bool SO>
EnableIf_< IsNumeric< T1 >, bool > operator== (T1 scalar, const DenseMatrix< T2, SO > &mat)
 Equality operator for the comparison of a scalar value and a dense matrix. More...
 
template<typename T1 , typename T2 , bool SO>
EnableIf_< IsNumeric< T1 >, bool > operator!= (T1 scalar, const DenseMatrix< T2, SO > &mat)
 Inequality operator for the comparison of a scalar value and a dense matrix. More...
 
template<typename E , typename T >
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 >
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 >
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 >
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 T1 , typename T2 , bool SO>
const DMatDMatAddExpr< T1, T2, SO > operator+ (const DenseMatrix< T1, SO > &lhs, const DenseMatrix< T2, SO > &rhs)
 Addition operator for the addition of two dense matrices with identical storage order ( $ A=B+C $). More...
 
template<typename T1 , typename T2 >
const DMatDMatMultExpr< T1, T2 > operator* (const DenseMatrix< T1, false > &lhs, const DenseMatrix< T2, false > &rhs)
 Multiplication operator for the multiplication of two row-major dense matrices ( $ A=B*C $). More...
 
template<typename T1 , typename T2 , bool SO>
const DMatDMatSubExpr< T1, T2, SO > operator- (const DenseMatrix< T1, SO > &lhs, const DenseMatrix< T2, SO > &rhs)
 Subtraction operator for the subtraction of two dense matrices with identical storage order ( $ A=B-C $). More...
 
template<typename T1 , typename T2 >
const DisableIf_< IsMatMatMultExpr< T1 >, DMatDVecMultExpr< T1, T2 > > operator* (const DenseMatrix< T1, false > &mat, const DenseVector< T2, false > &vec)
 Multiplication operator for the multiplication of a row-major dense matrix and a dense vector ( $ \vec{y}=A*\vec{x} $). More...
 
template<typename T1 , bool SO, typename T2 >
const EnableIf_< IsMatMatMultExpr< T1 >, MultExprTrait_< T1, T2 > > operator* (const DenseMatrix< T1, SO > &mat, const DenseVector< T2, false > &vec)
 Multiplication operator for the multiplication of a dense matrix-matrix multiplication expression and a dense vector ( $ \vec{y}=(A*B)*\vec{x} $). More...
 
template<typename MT , bool SO>
const DMatEvalExpr< MT, SO > eval (const DenseMatrix< MT, SO > &dm)
 Forces the evaluation of the given dense matrix expression dm. More...
 
template<typename MT , bool SO, typename OP >
const DMatForEachExpr< MT, OP, SO > 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>
const DMatForEachExpr< MT, Abs, SO > 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>
const DMatForEachExpr< MT, Floor, SO > 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>
const DMatForEachExpr< MT, Ceil, SO > 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>
const DMatForEachExpr< MT, Conj, SO > 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>
const CTransExprTrait_< MT > ctrans (const DenseMatrix< MT, SO > &dm)
 Returns the conjugate transpose matrix of dm. More...
 
template<typename MT , bool SO>
const DMatForEachExpr< MT, Real, SO > 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>
const DMatForEachExpr< MT, Imag, SO > 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>
const DMatForEachExpr< MT, Sqrt, SO > 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>
const DMatForEachExpr< MT, InvSqrt, SO > 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>
const DMatForEachExpr< MT, Cbrt, SO > 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>
const DMatForEachExpr< MT, InvCbrt, SO > 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 >
const DMatForEachExpr< MT, Clip< DT >, SO > clip (const DenseMatrix< MT, SO > &dm, const DT &min, const DT &max)
 Restricts each single element of the dense matrix dm to the range $[min..max]$. More...
 
template<typename MT , bool SO, typename ET >
const DMatForEachExpr< MT, Pow< ET >, SO > pow (const DenseMatrix< MT, SO > &dm, ET exp)
 Computes the exponential value for each single element of the dense matrix dm. More...
 
template<typename MT , bool SO>
const DMatForEachExpr< MT, Exp, SO > exp (const DenseMatrix< MT, SO > &dm)
 Computes $ e^x $ for each single element of the dense matrix dm. More...
 
template<typename MT , bool SO>
const DMatForEachExpr< MT, Log, SO > 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>
const DMatForEachExpr< MT, Log10, SO > 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>
const DMatForEachExpr< MT, Sin, SO > sin (const DenseMatrix< MT, SO > &dm)
 Computes the sine for each single element of the dense matrix dm. More...
 
template<typename MT , bool SO>
const DMatForEachExpr< MT, Asin, SO > 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>
const DMatForEachExpr< MT, Sinh, SO > 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>
const DMatForEachExpr< MT, Asinh, SO > 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>
const DMatForEachExpr< MT, Cos, SO > cos (const DenseMatrix< MT, SO > &dm)
 Computes the cosine for each single element of the dense matrix dm. More...
 
template<typename MT , bool SO>
const DMatForEachExpr< MT, Acos, SO > 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>
const DMatForEachExpr< MT, Cosh, SO > 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>
const DMatForEachExpr< MT, Acosh, SO > 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>
const DMatForEachExpr< MT, Tan, SO > tan (const DenseMatrix< MT, SO > &dm)
 Computes the tangent for each single element of the dense matrix dm. More...
 
template<typename MT , bool SO>
const DMatForEachExpr< MT, Atan, SO > 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>
const DMatForEachExpr< MT, Tanh, SO > 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>
const DMatForEachExpr< MT, Atanh, SO > 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>
const DMatForEachExpr< MT, Erf, SO > 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>
const DMatForEachExpr< MT, Erfc, SO > 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>
const DMatInvExpr< MT, SO > inv (const DenseMatrix< MT, SO > &dm)
 Calculation of the inverse of the given dense matrix. More...
 
template<typename T1 , bool SO, typename T2 >
const EnableIf_< IsNumeric< T2 >, DivExprTrait_< T1, T2 > > operator/ (const DenseMatrix< T1, SO > &mat, T2 scalar)
 Division operator for the division of a dense matrix by a scalar value ( $ A=B/s $). More...
 
template<typename MT , bool SO>
const DMatScalarMultExpr< MT, UnderlyingBuiltin_< MT >, SO > operator- (const DenseMatrix< MT, SO > &dm)
 Unary minus operator for the negation of a dense matrix ( $ A = -B $). More...
 
template<typename T1 , bool SO, typename T2 >
const EnableIf_< IsNumeric< T2 >, MultExprTrait_< T1, T2 > > operator* (const DenseMatrix< T1, SO > &mat, T2 scalar)
 Multiplication operator for the multiplication of a dense matrix and a scalar value ( $ A=B*s $). More...
 
template<typename T1 , typename T2 , bool SO>
const EnableIf_< IsNumeric< T1 >, MultExprTrait_< T1, T2 > > operator* (T1 scalar, const DenseMatrix< T2, SO > &mat)
 Multiplication operator for the multiplication of a scalar value and a dense matrix ( $ A=s*B $). More...
 
template<typename MT , bool SO>
const DMatSerialExpr< MT, SO > serial (const DenseMatrix< MT, SO > &dm)
 Forces the serial evaluation of the given dense matrix expression dm. More...
 
template<typename T1 , typename T2 , bool SO>
const DMatSMatAddExpr< T1, T2, SO > operator+ (const DenseMatrix< T1, SO > &lhs, const SparseMatrix< T2, SO > &rhs)
 Addition operator for the addition of a dense matrix and a sparse matrix ( $ A=B+C $). More...
 
template<typename T1 , typename T2 , bool SO>
const DMatSMatAddExpr< T2, T1, SO > operator+ (const SparseMatrix< T1, SO > &lhs, const DenseMatrix< T2, SO > &rhs)
 Addition operator for the addition of a sparse matrix and a dense matrix ( $ A=B+C $). More...
 
template<typename T1 , typename T2 >
const DMatSMatMultExpr< T1, T2 > operator* (const DenseMatrix< T1, false > &lhs, const SparseMatrix< T2, false > &rhs)
 Multiplication operator for the multiplication of a row-major dense matrix and a row-major sparse matrix ( $ A=B*C $). More...
 
template<typename T1 , typename T2 , bool SO>
const DMatSMatSubExpr< T1, T2, SO > operator- (const DenseMatrix< T1, SO > &lhs, const SparseMatrix< T2, SO > &rhs)
 Subtraction operator for the subtraction of a dense matrix and a sparse matrix with identical storage order ( $ A=B+C $). More...
 
template<typename T1 , typename T2 >
const DisableIf_< Or< IsSymmetric< T1 >, IsMatMatMultExpr< T1 > >, DMatSVecMultExpr< T1, T2 > > operator* (const DenseMatrix< T1, false > &mat, const SparseVector< T2, false > &vec)
 Multiplication operator for the multiplication of a row-major dense matrix and a sparse vector ( $ \vec{y}=A*\vec{x} $). More...
 
template<typename T1 , typename T2 >
EnableIf_< And< Not< IsSymmetric< T1 > >, Not< IsSymmetric< T2 > > >, const DMatTDMatAddExpr< T1, T2 > > operator+ (const DenseMatrix< T1, false > &lhs, const DenseMatrix< T2, true > &rhs)
 Addition operator for the addition of a row-major and a colum-major dense matrix ( $ A=B+C $). More...
 
template<typename T1 , typename T2 >
EnableIf_< And< Not< IsSymmetric< T1 > >, Not< IsSymmetric< T2 > > >, const DMatTDMatAddExpr< T2, T1 > > operator+ (const DenseMatrix< T1, true > &lhs, const DenseMatrix< T2, false > &rhs)
 Addition operator for the addition of a column-major and a row-major dense matrix ( $ A=B+C $). More...
 
template<typename T1 , typename T2 >
const DMatTDMatMultExpr< T1, T2 > operator* (const DenseMatrix< T1, false > &lhs, const DenseMatrix< T2, true > &rhs)
 Multiplication operator for the multiplication of a row-major dense matrix and a column-major dense matrix ( $ A=B*C $). More...
 
template<typename T1 , typename T2 >
EnableIf_< And< Not< IsSymmetric< T1 > >, Not< IsSymmetric< T2 > > >, const DMatTDMatSubExpr< T1, T2 > > operator- (const DenseMatrix< T1, false > &lhs, const DenseMatrix< T2, true > &rhs)
 Subtraction operator for the subtraction of a row-major and a column-major dense matrix ( $ A=B-C $). More...
 
template<typename T1 , typename T2 >
EnableIf_< And< Not< IsSymmetric< T1 > >, Not< IsSymmetric< T2 > > >, const DMatTDMatSubExpr< T1, T2 > > operator- (const DenseMatrix< T1, true > &lhs, const DenseMatrix< T2, false > &rhs)
 Subtraction operator for the subtraction of a column-major and a row-major dense matrix ( $ A=B-C $). More...
 
template<typename MT , bool SO>
const DMatTransExpr< MT,!SO > trans (const DenseMatrix< MT, SO > &dm)
 Calculation of the transpose of the given dense matrix. More...
 
template<typename T1 , typename T2 >
const DMatTSMatAddExpr< T1, T2 > operator+ (const DenseMatrix< T1, false > &lhs, const SparseMatrix< T2, true > &rhs)
 Addition operator for the addition of a row-major dense matrix and a column-major sparse matrix ( $ A=B+C $). More...
 
template<typename T1 , typename T2 >
const DMatTSMatAddExpr< T1, T2 > operator+ (const SparseMatrix< T2, true > &lhs, const DenseMatrix< T1, false > &rhs)
 Addition operator for the addition of a column-major sparse matrix and a row-major dense matrix ( $ A=B+C $). More...
 
template<typename T1 , typename T2 >
const DMatTSMatMultExpr< T1, T2 > operator* (const DenseMatrix< T1, false > &lhs, const SparseMatrix< T2, true > &rhs)
 Multiplication operator for the multiplication of a row-major dense matrix and a column-major sparse matrix ( $ A=B*C $). More...
 
template<typename T1 , typename T2 >
const DMatTSMatSubExpr< T1, T2 > operator- (const DenseMatrix< T1, false > &lhs, const SparseMatrix< T2, true > &rhs)
 Subtraction operator for the subtraction of a row-major dense matrix and a column-major sparse matrix ( $ A=B+C $). More...
 
template<typename T1 , typename T2 , bool TF>
const DVecDVecAddExpr< T1, T2, TF > operator+ (const DenseVector< T1, TF > &lhs, const DenseVector< T2, TF > &rhs)
 Addition operator for the addition of two dense vectors ( $ \vec{a}=\vec{b}+\vec{c} $). More...
 
template<typename T1 , typename T2 , bool TF>
const DVecDVecCrossExpr< T1, T2, TF > operator% (const DenseVector< T1, TF > &lhs, const DenseVector< T2, TF > &rhs)
 Operator for the cross product of two dense vectors ( $ \vec{a}=\vec{b} \times \vec{c} $). More...
 
template<typename T1 , typename T2 , bool TF>
const DVecDVecCrossExpr< T1, T2, TF > cross (const DenseVector< T1, TF > &lhs, const DenseVector< T2, TF > &rhs)
 Cross product of two dense vectors ( $ \vec{a}=\vec{b} \times \vec{c} $). More...
 
template<typename T1 , typename T2 , bool TF>
const DVecDVecDivExpr< T1, T2, TF > operator/ (const DenseVector< T1, TF > &lhs, const DenseVector< T2, TF > &rhs)
 Division operator for the componentwise product of two dense vectors ( $ \vec{a}=\vec{b}/\vec{c} $). More...
 
template<typename T1 , typename T2 , bool TF>
const DVecDVecMultExpr< T1, T2, TF > operator* (const DenseVector< T1, TF > &lhs, const DenseVector< T2, TF > &rhs)
 Multiplication operator for the componentwise product of two dense vectors ( $ \vec{a}=\vec{b}*\vec{c} $). More...
 
template<typename T1 , typename T2 , bool TF>
const DVecDVecSubExpr< T1, T2, TF > operator- (const DenseVector< T1, TF > &lhs, const DenseVector< T2, TF > &rhs)
 Subtraction operator for the subtraction of two dense vectors ( $ \vec{a}=\vec{b}-\vec{c} $). More...
 
template<typename VT , bool TF>
const DVecEvalExpr< VT, TF > eval (const DenseVector< VT, TF > &dv)
 Forces the evaluation of the given dense vector expression dv. More...
 
template<typename VT , bool TF, typename OP >
const DVecForEachExpr< VT, OP, TF > 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>
const DVecForEachExpr< VT, Abs, TF > 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>
const DVecForEachExpr< VT, Floor, TF > 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>
const DVecForEachExpr< VT, Ceil, TF > 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>
const DVecForEachExpr< VT, Conj, TF > 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>
const CTransExprTrait_< VT > ctrans (const DenseVector< VT, TF > &dv)
 Returns the conjugate transpose vector of dv. More...
 
template<typename VT , bool TF>
const DVecForEachExpr< VT, Real, TF > 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>
const DVecForEachExpr< VT, Imag, TF > 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>
const DVecForEachExpr< VT, Sqrt, TF > 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>
const DVecForEachExpr< VT, InvSqrt, TF > 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>
const DVecForEachExpr< VT, Cbrt, TF > 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>
const DVecForEachExpr< VT, InvCbrt, TF > 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 >
const DVecForEachExpr< VT, Clip< DT >, TF > clip (const DenseVector< VT, TF > &dv, const DT &min, const DT &max)
 Restricts each single element of the dense vector dv to the range $[min..max]$. More...
 
template<typename VT , bool TF, typename ET >
const DVecForEachExpr< VT, Pow< ET >, TF > pow (const DenseVector< VT, TF > &dv, ET exp)
 Computes the exponential value for each single element of the dense vector dv. More...
 
template<typename VT , bool TF>
const DVecForEachExpr< VT, Exp, TF > exp (const DenseVector< VT, TF > &dv)
 Computes $ e^x $ for each single element of the dense vector dv. More...
 
template<typename VT , bool TF>
const DVecForEachExpr< VT, Log, TF > 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>
const DVecForEachExpr< VT, Log10, TF > 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>
const DVecForEachExpr< VT, Sin, TF > sin (const DenseVector< VT, TF > &dv)
 Computes the sine for each single element of the dense vector dv. More...
 
template<typename VT , bool TF>
const DVecForEachExpr< VT, Asin, TF > 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>
const DVecForEachExpr< VT, Sinh, TF > 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>
const DVecForEachExpr< VT, Asinh, TF > 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>
const DVecForEachExpr< VT, Cos, TF > cos (const DenseVector< VT, TF > &dv)
 Computes the cosine for each single element of the dense vector dv. More...
 
template<typename VT , bool TF>
const DVecForEachExpr< VT, Acos, TF > 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>
const DVecForEachExpr< VT, Cosh, TF > 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>
const DVecForEachExpr< VT, Acosh, TF > 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>
const DVecForEachExpr< VT, Tan, TF > tan (const DenseVector< VT, TF > &dv)
 Computes the tangent for each single element of the dense vector dv. More...
 
template<typename VT , bool TF>
const DVecForEachExpr< VT, Atan, TF > 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>
const DVecForEachExpr< VT, Tanh, TF > 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>
const DVecForEachExpr< VT, Atanh, TF > 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>
const DVecForEachExpr< VT, Erf, TF > 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>
const DVecForEachExpr< VT, Erfc, TF > erfc (const DenseVector< VT, TF > &dv)
 Computes the complementary error function for each single element of the dense vector dv. More...
 
template<typename T1 , typename T2 , bool TF>
const EnableIf_< IsNumeric< T2 >, DivExprTrait_< T1, T2 > > operator/ (const DenseVector< T1, TF > &vec, T2 scalar)
 Division operator for the divison of a dense vector by a scalar value ( $ \vec{a}=\vec{b}/s $). More...
 
template<typename VT , bool TF>
const DVecScalarMultExpr< VT, UnderlyingBuiltin_< VT >, TF > operator- (const DenseVector< VT, TF > &dv)
 Unary minus operator for the negation of a dense vector ( $ \vec{a} = -\vec{b} $). More...
 
template<typename T1 , typename T2 , bool TF>
const EnableIf_< IsNumeric< T2 >, MultExprTrait_< T1, T2 > > operator* (const DenseVector< T1, TF > &vec, T2 scalar)
 Multiplication operator for the multiplication of a dense vector and a scalar value ( $ \vec{a}=\vec{b}*s $). More...
 
template<typename T1 , typename T2 , bool TF>
const EnableIf_< IsNumeric< T1 >, MultExprTrait_< T1, T2 > > operator* (T1 scalar, const DenseVector< T2, TF > &vec)
 Multiplication operator for the multiplication of a scalar value and a dense vector ( $ \vec{a}=s*\vec{b} $). More...
 
template<typename VT , bool TF>
const DVecScalarMultExpr< VT, ElementType_< VT >, TF > normalize (const DenseVector< VT, TF > &vec)
 Normalization of the dense vector ( $|\vec{a}|=1$). More...
 
template<typename VT , bool TF>
const DVecSerialExpr< VT, TF > serial (const DenseVector< VT, TF > &dv)
 Forces the serial evaluation of the given dense vector expression dv. More...
 
template<typename T1 , typename T2 , bool TF>
const DVecSVecAddExpr< T1, T2, TF > operator+ (const DenseVector< T1, TF > &lhs, const SparseVector< T2, TF > &rhs)
 Addition operator for the addition of a dense vector and a sparse vector ( $ \vec{a}=\vec{b}+\vec{c} $). More...
 
template<typename T1 , typename T2 , bool TF>
const DVecSVecAddExpr< T2, T1, TF > operator+ (const SparseVector< T1, TF > &lhs, const DenseVector< T2, TF > &rhs)
 Addition operator for the addition of a sparse vector and a dense vector ( $ \vec{a}=\vec{b}+\vec{c} $). More...
 
template<typename T1 , typename T2 , bool TF>
const DVecSVecCrossExpr< T1, T2, TF > operator% (const DenseVector< T1, TF > &lhs, const SparseVector< T2, TF > &rhs)
 Operator for the cross product of a dense vector and a sparse vector ( $ \vec{a}=\vec{b} \times \vec{c} $). More...
 
template<typename T1 , typename T2 , bool TF>
const DVecSVecCrossExpr< T1, T2, TF > cross (const DenseVector< T1, TF > &lhs, const SparseVector< T2, TF > &rhs)
 Cross product of a dense vector and a sparse vector ( $ \vec{a}=\vec{b} \times \vec{c} $). More...
 
template<typename T1 , typename T2 , bool TF>
const DVecSVecMultExpr< T1, T2, TF > operator* (const DenseVector< T1, TF > &lhs, const SparseVector< T2, TF > &rhs)
 Multiplication operator for the componentwise product of a dense vector and a sparse vector ( $ \vec{a}=\vec{b}*\vec{c} $). More...
 
template<typename T1 , typename T2 , bool TF>
const DVecSVecSubExpr< T1, T2, TF > operator- (const DenseVector< T1, TF > &lhs, const SparseVector< T2, TF > &rhs)
 Subtraction operator for the subtraction of a dense vector and a sparse vector ( $ \vec{a}=\vec{b}-\vec{c} $). More...
 
template<typename T1 , typename T2 >
const DVecTDVecMultExpr< T1, T2 > operator* (const DenseVector< T1, false > &lhs, const DenseVector< T2, true > &rhs)
 Multiplication operator for the outer product of two dense vectors ( $ A=\vec{b}*\vec{c}^T $). More...
 
template<typename VT , bool TF>
const DVecTransExpr< VT,!TF > trans (const DenseVector< VT, TF > &dv)
 Calculation of the transpose of the given dense vector. More...
 
template<typename T1 , typename T2 >
const DVecTSVecMultExpr< T1, T2 > operator* (const DenseVector< T1, false > &lhs, const SparseVector< T2, true > &rhs)
 Multiplication operator for the dense vector-sparse vector outer product ( $ A=\vec{b}*\vec{c}^T $). More...
 
template<typename VT , bool TF>
const SVecTransExpr< VT,!TF > trans (const SparseVector< VT, TF > &sv)
 Calculation of the transpose of the given sparse vector. More...
 
template<typename MT , bool SO>
const SMatTransExpr< MT,!SO > trans (const SparseMatrix< MT, SO > &sm)
 Calculation of the transpose of the given sparse matrix. More...
 
template<typename VT , bool TF>
const SVecSerialExpr< VT, TF > serial (const SparseVector< VT, TF > &sv)
 Forces the serial evaluation of the given sparse vector expression sv. More...
 
template<typename MT , bool SO>
const SMatSerialExpr< MT, SO > 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 >
const SVecForEachExpr< VT, OP, TF > 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 MT , bool SO, typename OP >
const SMatForEachExpr< MT, OP, SO > 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>
BLAZE_ALWAYS_INLINE void ctranspose (Matrix< MT, SO > &matrix)
 In-place conjugate transpose of the given matrix. More...
 
template<typename T1 , typename T2 >
const SMatDMatMultExpr< T1, T2 > operator* (const SparseMatrix< T1, false > &lhs, const DenseMatrix< T2, false > &rhs)
 Multiplication operator for the multiplication of a row-major sparse matrix and a row-major dense matrix ( $ A=B*C $). More...
 
template<typename T1 , typename T2 , bool SO>
const SMatDMatSubExpr< T1, T2, SO > operator- (const SparseMatrix< T1, SO > &lhs, const DenseMatrix< T2, SO > &rhs)
 Subtraction operator for the subtraction of a sparse matrix and a dense matrix with identical storage order ( $ A=B+C $). More...
 
template<typename T1 , typename T2 >
const DisableIf_< IsMatMatMultExpr< T1 >, SMatDVecMultExpr< T1, T2 > > operator* (const SparseMatrix< T1, false > &mat, const DenseVector< T2, false > &vec)
 Multiplication operator for the multiplication of a row-major sparse matrix and a dense vector ( $ \vec{y}=A*\vec{x} $). More...
 
template<typename T1 , bool SO, typename T2 >
const EnableIf_< IsMatMatMultExpr< T1 >, MultExprTrait_< T1, T2 > > operator* (const SparseMatrix< T1, SO > &mat, const DenseVector< T2, false > &vec)
 Multiplication operator for the multiplication of a sparse matrix-matrix multiplication expression and a dense vector ( $ \vec{y}=(A*B)*\vec{x} $). More...
 
template<typename MT , bool SO>
const SMatEvalExpr< MT, SO > eval (const SparseMatrix< MT, SO > &sm)
 Forces the evaluation of the given sparse matrix expression sm. More...
 
template<typename MT , bool SO>
const SMatForEachExpr< MT, Abs, SO > 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>
const SMatForEachExpr< MT, Floor, SO > 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>
const SMatForEachExpr< MT, Ceil, SO > 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>
const SMatForEachExpr< MT, Conj, SO > 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>
const CTransExprTrait_< MT > ctrans (const SparseMatrix< MT, SO > &sm)
 Returns the conjugate transpose matrix of sm. More...
 
template<typename MT , bool SO>
const SMatForEachExpr< MT, Real, SO > 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>
const SMatForEachExpr< MT, Imag, SO > 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>
const SMatForEachExpr< MT, Sqrt, SO > 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>
const SMatForEachExpr< MT, InvSqrt, SO > 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>
const SMatForEachExpr< MT, Cbrt, SO > 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>
const SMatForEachExpr< MT, InvCbrt, SO > 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 >
const SMatForEachExpr< MT, Clip< DT >, SO > clip (const SparseMatrix< MT, SO > &sm, const DT &min, const DT &max)
 Restricts each single element of the sparse matrix sm to the range $[min..max]$. More...
 
template<typename MT , bool SO, typename ET >
const SMatForEachExpr< MT, Pow< ET >, SO > pow (const SparseMatrix< MT, SO > &sm, ET exp)
 Computes the exponential value for each non-zero element of the sparse matrix sm. More...
 
template<typename MT , bool SO>
const SMatForEachExpr< MT, Exp, SO > exp (const SparseMatrix< MT, SO > &sm)
 Computes $ e^x $ for each non-zero element of the sparse matrix sm. More...
 
template<typename MT , bool SO>
const SMatForEachExpr< MT, Log, SO > 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>
const SMatForEachExpr< MT, Log10, SO > 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>
const SMatForEachExpr< MT, Sin, SO > 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>
const SMatForEachExpr< MT, Asin, SO > 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>
const SMatForEachExpr< MT, Sinh, SO > 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>
const SMatForEachExpr< MT, Asinh, SO > 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>
const SMatForEachExpr< MT, Cos, SO > 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>
const SMatForEachExpr< MT, Acos, SO > 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>
const SMatForEachExpr< MT, Cosh, SO > 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>
const SMatForEachExpr< MT, Acosh, SO > 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>
const SMatForEachExpr< MT, Tan, SO > 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>
const SMatForEachExpr< MT, Atan, SO > 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>
const SMatForEachExpr< MT, Tanh, SO > 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>
const SMatForEachExpr< MT, Atanh, SO > 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>
const SMatForEachExpr< MT, Erf, SO > 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>
const SMatForEachExpr< MT, Erfc, SO > erfc (const SparseMatrix< MT, SO > &sm)
 Computes the complementary error function for each non-zero element of the sparse matrix sm. More...
 
template<typename T1 , bool SO, typename T2 >
const EnableIf_< IsNumeric< T2 >, DivExprTrait_< T1, T2 > > operator/ (const SparseMatrix< T1, SO > &mat, T2 scalar)
 Division operator for the division of a sparse matrix by a scalar value ( $ A=B/s $). More...
 
template<typename MT , bool SO>
const SMatScalarMultExpr< MT, UnderlyingBuiltin_< MT >, SO > operator- (const SparseMatrix< MT, SO > &sm)
 Unary minus operator for the negation of a sparse matrix ( $ A = -B $). More...
 
template<typename T1 , bool SO, typename T2 >
const EnableIf_< IsNumeric< T2 >, MultExprTrait_< T1, T2 > > operator* (const SparseMatrix< T1, SO > &mat, T2 scalar)
 Multiplication operator for the multiplication of a sparse matrix and a scalar value ( $ A=B*s $). More...
 
template<typename T1 , typename T2 , bool SO>
const EnableIf_< IsNumeric< T1 >, MultExprTrait_< T1, T2 > > operator* (T1 scalar, const SparseMatrix< T2, SO > &mat)
 Multiplication operator for the multiplication of a scalar value and a sparse matrix ( $ A=s*B $). More...
 
template<typename T1 , typename T2 >
const SMatSMatAddExpr< T1, T2 > operator+ (const SparseMatrix< T1, false > &lhs, const SparseMatrix< T2, false > &rhs)
 Addition operator for the addition of two row-major sparse matrices ( $ A=B+C $). More...
 
template<typename T1 , typename T2 >
const SMatSMatMultExpr< T1, T2 > operator* (const SparseMatrix< T1, false > &lhs, const SparseMatrix< T2, false > &rhs)
 Multiplication operator for the multiplication of two row-major sparse matrices ( $ A=B*C $). More...
 
template<typename T1 , typename T2 >
const SMatSMatSubExpr< T1, T2 > operator- (const SparseMatrix< T1, false > &lhs, const SparseMatrix< T2, false > &rhs)
 Subtraction operator for the subtraction of two row-major sparse matrices ( $ A=B-C $). More...
 
template<typename T1 , typename T2 >
const DisableIf_< Or< IsSymmetric< T1 >, IsMatMatMultExpr< T1 > >, SMatSVecMultExpr< T1, T2 > > operator* (const SparseMatrix< T1, false > &mat, const SparseVector< T2, false > &vec)
 Multiplication operator for the multiplication of a row-major sparse matrix and a sparse vector ( $ \vec{a}=B*\vec{c} $). More...
 
template<typename T1 , typename T2 >
const SMatTDMatMultExpr< T1, T2 > operator* (const SparseMatrix< T1, false > &lhs, const DenseMatrix< T2, true > &rhs)
 Multiplication operator for the multiplication of a row-major sparse matrix and a column-major dense matrix ( $ A=B*C $). More...
 
template<typename T1 , typename T2 >
const SMatTDMatSubExpr< T1, T2 > operator- (const SparseMatrix< T1, false > &lhs, const DenseMatrix< T2, true > &rhs)
 Subtraction operator for the subtraction of a row-major sparse matrix and a column-major dense matrix ( $ A=B+C $). More...
 
template<typename T1 , typename T2 >
const SMatTSMatAddExpr< T1, T2 > operator+ (const SparseMatrix< T1, false > &lhs, const SparseMatrix< T2, true > &rhs)
 Addition operator for the addition of a row-major and a column-major sparse matrix ( $ A=B+C $). More...
 
template<typename T1 , typename T2 >
const SMatTSMatAddExpr< T2, T1 > operator+ (const SparseMatrix< T1, true > &lhs, const SparseMatrix< T2, false > &rhs)
 Addition operator for the addition of a column-major and a row-major sparse matrix ( $ A=B+C $). More...
 
template<typename T1 , typename T2 >
const SMatTSMatMultExpr< T1, T2 > operator* (const SparseMatrix< T1, false > &lhs, const SparseMatrix< T2, true > &rhs)
 Multiplication operator for the multiplication of a row-major sparse matrix and a column-major sparse matrix ( $ A=B*C $). More...
 
template<typename T1 , typename T2 >
const SMatTSMatSubExpr< T1, T2 > operator- (const SparseMatrix< T1, false > &lhs, const SparseMatrix< T2, true > &rhs)
 Subtraction operator for the subtraction of a row-major and a column-major sparse matrix ( $ A=B-C $). More...
 
template<typename T1 , typename T2 , bool TF>
const SVecDVecCrossExpr< T1, T2, TF > operator% (const SparseVector< T1, TF > &lhs, const DenseVector< T2, TF > &rhs)
 Operator for the cross product of a sparse vector and a dense vector ( $ \vec{a}=\vec{b} \times \vec{c} $). More...
 
template<typename T1 , typename T2 , bool TF>
const SVecDVecCrossExpr< T1, T2, TF > cross (const SparseVector< T1, TF > &lhs, const DenseVector< T2, TF > &rhs)
 Cross product of a sparse vector and a dense vector ( $ \vec{a}=\vec{b} \times \vec{c} $). More...
 
template<typename T1 , typename T2 , bool TF>
const SVecDVecDivExpr< T1, T2, TF > operator/ (const SparseVector< T1, TF > &lhs, const DenseVector< T2, TF > &rhs)
 Division operator for the componentwise division of a sparse vector and a dense vector ( $ \vec{a}=\vec{b}/\vec{c} $). More...
 
template<typename T1 , typename T2 , bool TF>
const SVecDVecMultExpr< T1, T2, TF > operator* (const SparseVector< T1, TF > &lhs, const DenseVector< T2, TF > &rhs)
 Multiplication operator for the componentwise product of a sparse vector and a dense vector ( $ \vec{a}=\vec{b}*\vec{c} $). More...
 
template<typename T1 , typename T2 , bool TF>
const SVecDVecSubExpr< T1, T2, TF > operator- (const SparseVector< T1, TF > &lhs, const DenseVector< T2, TF > &rhs)
 Subtraction operator for the subtraction of a sparse vector and a dense vector ( $ \vec{a}=\vec{b}-\vec{c} $). More...
 
template<typename VT , bool TF>
const SVecEvalExpr< VT, TF > eval (const SparseVector< VT, TF > &sv)
 Forces the evaluation of the given sparse vector expression sv. More...
 
template<typename VT , bool TF>
const SVecForEachExpr< VT, Abs, TF > 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>
const SVecForEachExpr< VT, Floor, TF > 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>
const SVecForEachExpr< VT, Ceil, TF > 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>
const SVecForEachExpr< VT, Conj, TF > 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>
const CTransExprTrait_< VT > ctrans (const SparseVector< VT, TF > &sv)
 Returns the conjugate transpose vector of sv. More...
 
template<typename VT , bool TF>
const SVecForEachExpr< VT, Real, TF > 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>
const SVecForEachExpr< VT, Imag, TF > 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>
const SVecForEachExpr< VT, Sqrt, TF > 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>
const SVecForEachExpr< VT, InvSqrt, TF > 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>
const SVecForEachExpr< VT, Cbrt, TF > 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>
const SVecForEachExpr< VT, InvCbrt, TF > 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 >
const SVecForEachExpr< VT, Clip< DT >, TF > clip (const SparseVector< VT, TF > &sv, const DT &min, const DT &max)
 Restricts each single element of the sparse vector sv to the range $[min..max]$. More...
 
template<typename VT , bool TF, typename ET >
const SVecForEachExpr< VT, Pow< ET >, TF > pow (const SparseVector< VT, TF > &sv, ET exp)
 Computes the exponential value for each non-zero element of the sparse vector sv. More...
 
template<typename VT , bool TF>
const SVecForEachExpr< VT, Exp, TF > exp (const SparseVector< VT, TF > &sv)
 Computes $ e^x $ of each non-zero element of the sparse vector sv. More...
 
template<typename VT , bool TF>
const SVecForEachExpr< VT, Log, TF > 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>
const SVecForEachExpr< VT, Log10, TF > 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>
const SVecForEachExpr< VT, Sin, TF > 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>
const SVecForEachExpr< VT, Asin, TF > 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>
const SVecForEachExpr< VT, Sinh, TF > 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>
const SVecForEachExpr< VT, Asinh, TF > 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>
const SVecForEachExpr< VT, Cos, TF > 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>
const SVecForEachExpr< VT, Acos, TF > 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>
const SVecForEachExpr< VT, Cosh, TF > 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>
const SVecForEachExpr< VT, Acosh, TF > 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>
const SVecForEachExpr< VT, Tan, TF > 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>
const SVecForEachExpr< VT, Atan, TF > 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>
const SVecForEachExpr< VT, Tanh, TF > 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>
const SVecForEachExpr< VT, Atanh, TF > 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>
const SVecForEachExpr< VT, Erf, TF > 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>
const SVecForEachExpr< VT, Erfc, TF > erfc (const SparseVector< VT, TF > &sv)
 Computes the complementary error function of each non-zero element of the sparse vector sv. More...
 
template<typename T1 , typename T2 , bool TF>
const EnableIf_< IsNumeric< T2 >, DivExprTrait_< T1, T2 > > operator/ (const SparseVector< T1, TF > &vec, T2 scalar)
 Division operator for the divison of a sparse vector by a scalar value ( $ \vec{a}=\vec{b}/s $). More...
 
template<typename VT , bool TF>
const SVecScalarMultExpr< VT, UnderlyingBuiltin_< VT >, TF > operator- (const SparseVector< VT, TF > &sv)
 Unary minus operator for the negation of a sparse vector ( $ \vec{a} = -\vec{b} $). More...
 
template<typename T1 , typename T2 , bool TF>
const EnableIf_< IsNumeric< T2 >, MultExprTrait_< T1, T2 > > operator* (const SparseVector< T1, TF > &vec, T2 scalar)
 Multiplication operator for the multiplication of a sparse vector and a scalar value ( $ \vec{a}=\vec{b}*s $). More...
 
template<typename T1 , typename T2 , bool TF>
const EnableIf_< IsNumeric< T1 >, MultExprTrait_< T1, T2 > > operator* (T1 scalar, const SparseVector< T2, TF > &vec)
 Multiplication operator for the multiplication of a scalar value and a sparse vector ( $ \vec{a}=s*\vec{b} $). More...
 
template<typename VT , bool TF>
const SVecScalarMultExpr< VT, ElementType_< VT >, TF > normalize (const SparseVector< VT, TF > &vec)
 Normalization of the sparse vector ( $|\vec{a}|=1$). More...
 
template<typename T1 , typename T2 , bool TF>
const SVecSVecAddExpr< T1, T2, TF > operator+ (const SparseVector< T1, TF > &lhs, const SparseVector< T2, TF > &rhs)
 Addition operator for the addition of two sparse vectors ( $ \vec{a}=\vec{b}+\vec{c} $). More...
 
template<typename T1 , typename T2 , bool TF>
const SVecSVecCrossExpr< T1, T2, TF > operator% (const SparseVector< T1, TF > &lhs, const SparseVector< T2, TF > &rhs)
 Operator for the cross product of two sparse vectors ( $ \vec{a}=\vec{b} \times \vec{c} $). More...
 
template<typename T1 , typename T2 , bool TF>
const SVecSVecCrossExpr< T1, T2, TF > cross (const SparseVector< T1, TF > &lhs, const SparseVector< T2, TF > &rhs)
 Cross product of two sparse vectors ( $ \vec{a}=\vec{b} \times \vec{c} $). More...
 
template<typename T1 , typename T2 , bool TF>
const SVecSVecMultExpr< T1, T2, TF > operator* (const SparseVector< T1, TF > &lhs, const SparseVector< T2, TF > &rhs)
 Multiplication operator for the componentwise multiplication of two sparse vectors ( $ \vec{a}=\vec{b}*\vec{c} $). More...
 
template<typename T1 , typename T2 , bool TF>
const SVecSVecSubExpr< T1, T2, TF > operator- (const SparseVector< T1, TF > &lhs, const SparseVector< T2, TF > &rhs)
 Subtraction operator for the subtraction of two sparse vectors ( $ \vec{a}=\vec{b}-\vec{c} $). More...
 
template<typename T1 , typename T2 >
const SVecTDVecMultExpr< T1, T2 > operator* (const SparseVector< T1, false > &lhs, const DenseVector< T2, true > &rhs)
 Multiplication operator for the sparse vector-dense vector outer product ( $ A=\vec{b}*\vec{c}^T $). More...
 
template<typename T1 , typename T2 >
const SVecTSVecMultExpr< T1, T2 > operator* (const SparseVector< T1, false > &lhs, const SparseVector< T2, true > &rhs)
 Multiplication operator for the sparse vector-sparse vector outer product ( $ A=\vec{b}*\vec{c}^T $). More...
 
template<typename T1 , typename T2 >
const TDMatDMatMultExpr< T1, T2 > operator* (const DenseMatrix< T1, true > &lhs, const DenseMatrix< T2, false > &rhs)
 Multiplication operator for the multiplication of a column-major dense matrix and a row-major dense matrix ( $ A=B*C $). More...
 
template<typename T1 , typename T2 >
const DisableIf_< IsMatMatMultExpr< T1 >, TDMatDVecMultExpr< T1, T2 > > operator* (const DenseMatrix< T1, true > &mat, const DenseVector< T2, false > &vec)
 Multiplication operator for the multiplication of a column-major dense matrix and a dense vector ( $ \vec{y}=A*\vec{x} $). More...
 
template<typename T1 , typename T2 >
const TDMatSMatAddExpr< T1, T2 > operator+ (const DenseMatrix< T1, true > &lhs, const SparseMatrix< T2, false > &rhs)
 Addition operator for the addition of a column-major dense matrix and a row-major sparse matrix ( $ A=B+C $). More...
 
template<typename T1 , typename T2 >
const TDMatSMatAddExpr< T1, T2 > operator+ (const SparseMatrix< T2, false > &lhs, const DenseMatrix< T1, true > &rhs)
 Addition operator for the addition of a row-major sparse matrix and a column-major dense matrix ( $ A=B+C $). More...
 
template<typename T1 , typename T2 >
const TDMatSMatMultExpr< T1, T2 > operator* (const DenseMatrix< T1, true > &lhs, const SparseMatrix< T2, false > &rhs)
 Multiplication operator for the multiplication of a column-major dense matrix and a row-major sparse matrix ( $ A=B*C $). More...
 
template<typename T1 , typename T2 >
const TDMatSMatSubExpr< T1, T2 > operator- (const DenseMatrix< T1, true > &lhs, const SparseMatrix< T2, false > &rhs)
 Subtraction operator for the subtraction of a column-major dense matrix and a row-major sparse matrix ( $ A=B+C $). More...
 
template<typename T1 , typename T2 >
const DisableIf_< IsMatMatMultExpr< T1 >, TDMatSVecMultExpr< T1, T2 > > operator* (const DenseMatrix< T1, true > &mat, const SparseVector< T2, false > &vec)
 Multiplication operator for the multiplication of a column-major dense matrix and a sparse vector ( $ \vec{y}=A*\vec{x} $). More...
 
template<typename T1 , typename T2 >
const TDMatTDMatMultExpr< T1, T2 > operator* (const DenseMatrix< T1, true > &lhs, const DenseMatrix< T2, true > &rhs)
 Multiplication operator for the multiplication of two column-major dense matrices ( $ A=B*C $). More...
 
template<typename T1 , typename T2 >
const TDMatTSMatMultExpr< T1, T2 > operator* (const DenseMatrix< T1, true > &lhs, const SparseMatrix< T2, true > &rhs)
 Multiplication operator for the multiplication of a column-major dense matrix and a column-major sparse matrix ( $ A=B*C $). More...
 
template<typename T1 , typename T2 >
const DisableIf_< IsMatMatMultExpr< T2 >, TDVecDMatMultExpr< T1, T2 > > operator* (const DenseVector< T1, true > &vec, const DenseMatrix< T2, false > &mat)
 Multiplication operator for the multiplication of a transpose dense vector and a row-major dense matrix ( $ \vec{y}^T=\vec{x}^T*A $). More...
 
template<typename T1 , typename T2 , bool SO>
const EnableIf_< IsMatMatMultExpr< T2 >, MultExprTrait_< T1, T2 > > operator* (const DenseVector< T1, true > &vec, const DenseMatrix< T2, SO > &mat)
 Multiplication operator for the multiplication of a transpose dense vector and a dense matrix-matrix multiplication expression ( $ \vec{y}^T=\vec{x}^T*(A*B) $). More...
 
template<typename T1 , typename T2 >
DisableIf_< TDVecDVecMultExprHelper< T1, T2 >, const MultTrait_< ElementType_< T1 >, ElementType_< T2 > > > operator* (const DenseVector< T1, true > &lhs, const DenseVector< T2, false > &rhs)
 Default multiplication operator for the scalar product (inner product) of two dense vectors ( $ s=\vec{a}*\vec{b} $). More...
 
template<typename T1 , typename T2 >
EnableIf_< TDVecDVecMultExprHelper< T1, T2 >, const MultTrait_< ElementType_< T1 >, ElementType_< T2 > > > operator* (const DenseVector< T1, true > &lhs, const DenseVector< T2, false > &rhs)
 SIMD optimized multiplication operator for the scalar product (inner product) of two dense vectors ( $ s=\vec{a}*\vec{b} $). More...
 
template<typename T1 , typename T2 >
const DisableIf_< Or< IsSymmetric< T2 >, IsMatMatMultExpr< T2 > >, TDVecSMatMultExpr< T1, T2 > > operator* (const DenseVector< T1, true > &vec, const SparseMatrix< T2, false > &mat)
 Multiplication operator for the multiplication of a transpose dense vector and a row-major sparse matrix ( $ \vec{y}^T=\vec{x}^T*A $). More...
 
template<typename T1 , typename T2 , bool SO>
const EnableIf_< IsMatMatMultExpr< T2 >, MultExprTrait_< T1, T2 > > operator* (const DenseVector< T1, true > &vec, const SparseMatrix< T2, SO > &mat)
 Multiplication operator for the multiplication of a transpose dense vector and a sparse matrix-matrix multiplication expression ( $ \vec{y}^T=\vec{x}^T*(A*B) $). More...
 
template<typename T1 , typename T2 >
const MultTrait_< ElementType_< T1 >, ElementType_< T2 > > operator* (const DenseVector< T1, true > &lhs, const SparseVector< T2, false > &rhs)
 Multiplication operator for the scalar product (inner product) of a dense and a sparse vector ( $ s=\vec{a}*\vec{b} $). More...
 
template<typename T1 , typename T2 >
const DisableIf_< IsMatMatMultExpr< T2 >, TDVecTDMatMultExpr< T1, T2 > > operator* (const DenseVector< T1, true > &vec, const DenseMatrix< T2, true > &mat)
 Multiplication operator for the multiplication of a transpose dense vector and a column-major dense matrix ( $ \vec{y}^T=\vec{x}^T*A $). More...
 
template<typename T1 , typename T2 >
const DisableIf_< IsMatMatMultExpr< T2 >, TDVecTSMatMultExpr< T1, T2 > > operator* (const DenseVector< T1, true > &vec, const SparseMatrix< T2, true > &mat)
 Multiplication operator for the multiplication of a transpose dense vector and a column-major sparse matrix ( $ \vec{y}^T=\vec{x}^T*A $). More...
 
template<typename T1 , typename T2 >
const TSMatDMatMultExpr< T1, T2 > operator* (const SparseMatrix< T1, true > &lhs, const DenseMatrix< T2, false > &rhs)
 Multiplication operator for the multiplication of a column-major sparse matrix and a row-major dense matrix ( $ A=B*C $). More...
 
template<typename T1 , typename T2 >
const TSMatDMatSubExpr< T1, T2 > operator- (const SparseMatrix< T1, true > &lhs, const DenseMatrix< T2, false > &rhs)
 Subtraction operator for the subtraction of a column-major sparse matrix and a row-major dense matrix ( $ A=B+C $). More...
 
template<typename T1 , typename T2 >
const DisableIf_< Or< IsSymmetric< T1 >, IsMatMatMultExpr< T1 > >, TSMatDVecMultExpr< T1, T2 > > operator* (const SparseMatrix< T1, true > &mat, const DenseVector< T2, false > &vec)
 Multiplication operator for the multiplication of a column-major sparse matrix and a dense vector ( $ \vec{y}=A*\vec{x} $). More...
 
template<typename T1 , typename T2 >
const TSMatSMatMultExpr< T1, T2 > operator* (const SparseMatrix< T1, true > &lhs, const SparseMatrix< T2, false > &rhs)
 Multiplication operator for the multiplication of a column-major sparse matrix and a row-major sparse matrix ( $ A=B*C $). More...
 
template<typename T1 , typename T2 >
const TSMatSMatSubExpr< T1, T2 > operator- (const SparseMatrix< T1, true > &lhs, const SparseMatrix< T2, false > &rhs)
 Subtraction operator for the subtraction of a column-major and a row-major sparse matrix ( $ A=B-C $). More...
 
template<typename T1 , typename T2 >
const DisableIf_< IsMatMatMultExpr< T1 >, TSMatSVecMultExpr< T1, T2 > > operator* (const SparseMatrix< T1, true > &mat, const SparseVector< T2, false > &vec)
 Multiplication operator for the multiplication of a transpose sparse matrix and a sparse vector ( $ \vec{y}=A*\vec{x} $). More...
 
template<typename T1 , typename T2 >
const TSMatTDMatMultExpr< T1, T2 > operator* (const SparseMatrix< T1, true > &lhs, const DenseMatrix< T2, true > &rhs)
 Multiplication operator for the multiplication of a column-major sparse matrix and a column-major dense matrix ( $ A=B*C $). More...
 
template<typename T1 , typename T2 >
const TSMatTSMatAddExpr< T1, T2 > operator+ (const SparseMatrix< T1, true > &lhs, const SparseMatrix< T2, true > &rhs)
 Addition operator for the addition of two column-major sparse matrices ( $ A=B+C $). More...
 
template<typename T1 , typename T2 >
const TSMatTSMatMultExpr< T1, T2 > operator* (const SparseMatrix< T1, true > &lhs, const SparseMatrix< T2, true > &rhs)
 Multiplication operator for the multiplication of two column-major sparse matrices ( $ A=B*C $). More...
 
template<typename T1 , typename T2 >
const TSMatTSMatSubExpr< T1, T2 > operator- (const SparseMatrix< T1, true > &lhs, const SparseMatrix< T2, true > &rhs)
 Subtraction operator for the subtraction of two column-major sparse matrices ( $ A=B-C $). More...
 
template<typename T1 , typename T2 >
const DisableIf_< IsMatMatMultExpr< T2 >, TSVecDMatMultExpr< T1, T2 > > operator* (const SparseVector< T1, true > &vec, const DenseMatrix< T2, false > &mat)
 Multiplication operator for the multiplication of a transpose sparse vector and a row-major dense matrix ( $ \vec{y}^T=\vec{x}^T*A $). More...
 
template<typename T1 , typename T2 , bool SO>
const EnableIf_< IsMatMatMultExpr< T2 >, MultExprTrait_< T1, T2 > > operator* (const SparseVector< T1, true > &vec, const DenseMatrix< T2, SO > &mat)
 Multiplication operator for the multiplication of a transpose sparse vector and a dense matrix-matrix multiplication expression ( $ \vec{y}^T=\vec{x}^T*(A*B) $). More...
 
template<typename T1 , typename T2 >
const MultTrait_< ElementType_< T1 >, ElementType_< T2 > > operator* (const SparseVector< T1, true > &lhs, const DenseVector< T2, false > &rhs)
 Multiplication operator for the scalar product (inner product) of a sparse and a dense vector ( $ s=\vec{a}*\vec{b} $). More...
 
template<typename T1 , typename T2 >
const DisableIf_< IsMatMatMultExpr< T2 >, TSVecSMatMultExpr< T1, T2 > > operator* (const SparseVector< T1, true > &vec, const SparseMatrix< T2, false > &mat)
 Multiplication operator for the multiplication of a transpose sparse vector and a row-major sparse matrix ( $ \vec{y}^T=\vec{x}^T*A $). More...
 
template<typename T1 , typename T2 , bool SO>
const EnableIf_< IsMatMatMultExpr< T2 >, MultExprTrait_< T1, T2 > > operator* (const SparseVector< T1, true > &vec, const SparseMatrix< T2, SO > &mat)
 Multiplication operator for the multiplication of a transpose sparse vector and a sparse matrix-matrix multiplication expression ( $ \vec{y}^T=\vec{x}^T*(A*B) $). More...
 
template<typename T1 , typename T2 >
const MultTrait_< ElementType_< T1 >, ElementType_< T2 > > operator* (const SparseVector< T1, true > &lhs, const SparseVector< T2, false > &rhs)
 Multiplication operator for the scalar product (inner product) of two sparse vectors ( $ s=\vec{a}*\vec{b} $). More...
 
template<typename T1 , typename T2 >
const DisableIf_< Or< IsSymmetric< T2 >, IsMatMatMultExpr< T2 > >, TSVecTDMatMultExpr< T1, T2 > > operator* (const SparseVector< T1, true > &vec, const DenseMatrix< T2, true > &mat)
 Multiplication operator for the multiplication of a transpose sparse vector and a column-major dense matrix ( $ \vec{y}^T=\vec{x}^T*A $). More...
 
template<typename T1 , typename T2 >
const DisableIf_< Or< IsSymmetric< T2 >, IsMatMatMultExpr< T2 > >, TSVecTSMatMultExpr< T1, T2 > > operator* (const SparseVector< T1, true > &vec, const SparseMatrix< T2, true > &mat)
 Multiplication operator for the multiplication of a transpose sparse vector and a column-major sparse matrix ( $ \vec{y}^T=\vec{x}^T*A $). More...
 
template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE constexpr bool lessThan (const T1 &a, const T2 &b) noexcept(IsBuiltin< CommonType_< T1, T2 > >::value)
 Generic less-than comparison. More...
 
template<typename Type >
size_t determineColumns (initializer_list< initializer_list< Type > > list) noexcept
 Determine the maximum number of columns specified by the given initializer list. 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_< MT2 > *tau)
 LAPACK kernel for the multiplication of the double precision Q from a RQ decomposition with another matrix. More...
 
template<typename PT , typename RT >
auto erf (const Proxy< PT, RT > &proxy) -> decltype(erf(std::declval< RepresentedType_< PT > >()))
 Computing the error function of the represented element. More...
 
template<typename PT , typename RT >
auto erfc (const Proxy< PT, RT > &proxy) -> decltype(erfc(std::declval< RepresentedType_< PT > >()))
 Computing the complementary error function of 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 void clear (Type &clearable)
 Clearing the given value/object to the default state. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE constexpr EnableIf_< IsBuiltin< 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< T >::value)
 In-place conjugation of the given value/object. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE void cswap (T &a, T &b) noexcept(IsNumeric< T >::value)
 Swapping two conjugated values/objects. More...
 
template<typename T1 , typename T2 >
bool equal (const T1 &a, const T2 &b)
 Generic equality check. More...
 
template<typename T , typename = EnableIf_< IsBuiltin<T> >>
auto invcbrt (T a) noexcept-> decltype(inv(cbrt(a)))
 Returns the inverse cubic root of the given built-in value. More...
 
BLAZE_ALWAYS_INLINE float inv (float a) noexcept
 Inverting the given single precision value. More...
 
BLAZE_ALWAYS_INLINE double inv (double a) noexcept
 Inverting the given double precision value. More...
 
BLAZE_ALWAYS_INLINE long double inv (long double a) noexcept
 Inverting the given extended precision value. More...
 
BLAZE_ALWAYS_INLINE complex< float > inv (const complex< float > &a) noexcept
 Inverting the given single precision complex number. More...
 
BLAZE_ALWAYS_INLINE complex< double > inv (const complex< double > &a) noexcept
 Inverting the given double precision complex number. More...
 
BLAZE_ALWAYS_INLINE 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_< IsBuiltin<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_< IsBuiltin<T> >>
auto invsqrt (const complex< T > &a) noexcept-> decltype(inv(sqrt(a)))
 Returns the inverse square root of the given complex number. More...
 
template<typename Type >
BLAZE_ALWAYS_INLINE bool isDefault (const Type &v) noexcept(IsBuiltin< Type >::value)
 Returns whether the given value/object is in default state. More...
 
template<typename Type , typename = EnableIf_< IsNumeric<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_< IsNumeric< T >, bool > isnan (T a) noexcept
 Platform independent implementation of the C99 isnan function. More...
 
template<typename Type >
BLAZE_ALWAYS_INLINE EnableIf_< IsNumeric< 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 isReal (const Type &v) noexcept
 Returns whether the given value/object represents a real number. More...
 
template<typename Type >
BLAZE_ALWAYS_INLINE EnableIf_< IsNumeric< 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 void reset (Type &resettable)
 Resetting the given value/object to the default value. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE constexpr EnableIf_< Or< IsBuiltin< T >, IsComplex< T > >, const T & > serial (const T &a) noexcept
 Formal serialization of the evaluation of the given argument. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE constexpr MultExprTrait_< T, T > sq (const T &a) noexcept(noexcept(a *a))
 Squaring the given value/object. More...
 
BLAZE_ALWAYS_INLINE const SIMDuint8 abs (const SIMDint8 &a) noexcept=delete
 Absolute value of a vector of 8-bit signed integral values. More...
 
BLAZE_ALWAYS_INLINE const SIMDuint16 abs (const SIMDint16 &a) noexcept=delete
 Absolute value of a vector of 16-bit signed integral values. More...
 
BLAZE_ALWAYS_INLINE const SIMDuint32 abs (const SIMDint32 &a) noexcept=delete
 Absolute value of a vector of 32-bit signed integral values. More...
 
BLAZE_ALWAYS_INLINE const SIMDuint64 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 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 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 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...
 
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 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 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 $ e^x $ for a vector of single precision floating point values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const SIMDdouble exp (const SIMDf64< T > &a) noexcept=delete
 Computes $ e^x $ for a vector of double precision floating point values. More...
 
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 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_< And< IsIntegral< T >, HasSize< T, 1UL > >, If_< IsSigned< 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_< And< IsIntegral< T >, HasSize< T, 1UL > >, If_< IsSigned< 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_< And< IsIntegral< T >, HasSize< T, 2UL > >, If_< IsSigned< 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_< And< IsIntegral< T >, HasSize< T, 2UL > >, If_< IsSigned< 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_< And< IsIntegral< T >, HasSize< T, 4UL > >, If_< IsSigned< 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_< And< IsIntegral< T >, HasSize< T, 4UL > >, If_< IsSigned< 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_< And< IsIntegral< T >, HasSize< T, 8UL > >, If_< IsSigned< 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_< And< IsIntegral< T >, HasSize< T, 8UL > >, If_< IsSigned< 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_< And< IsIntegral< T >, HasSize< T, 1UL > >, If_< IsSigned< 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_< And< IsIntegral< T >, HasSize< T, 1UL > >, If_< IsSigned< 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_< And< IsIntegral< T >, HasSize< T, 2UL > >, If_< IsSigned< 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_< And< IsIntegral< T >, HasSize< T, 2UL > >, If_< IsSigned< 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_< And< IsIntegral< T >, HasSize< T, 4UL > >, If_< IsSigned< 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_< And< IsIntegral< T >, HasSize< T, 4UL > >, If_< IsSigned< 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_< And< IsIntegral< T >, HasSize< T, 8UL > >, If_< IsSigned< 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_< And< IsIntegral< T >, HasSize< T, 8UL > >, If_< IsSigned< 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 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 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...
 
BLAZE_ALWAYS_INLINE const complex< int8_tsum (const SIMDcint8 &a) noexcept
 Returns the sum of all elements in the 8-bit integral complex SIMD vector. More...
 
BLAZE_ALWAYS_INLINE int16_t sum (const SIMDint16 &a) noexcept
 Returns the sum of all elements in the 16-bit integral SIMD vector. More...
 
BLAZE_ALWAYS_INLINE const complex< int16_tsum (const SIMDcint16 &a) noexcept
 Returns the sum of all elements in the 16-bit integral complex SIMD vector. More...
 
BLAZE_ALWAYS_INLINE int32_t sum (const SIMDint32 &a) noexcept
 Returns the sum of all elements in the 32-bit integral SIMD vector. More...
 
BLAZE_ALWAYS_INLINE const complex< int32_tsum (const SIMDcint32 &a) noexcept
 Returns the sum of all elements in the 32-bit integral complex SIMD vector. More...
 
BLAZE_ALWAYS_INLINE int64_t sum (const SIMDint64 &a) noexcept
 Returns the sum of all elements in the 64-bit integral SIMD vector. More...
 
BLAZE_ALWAYS_INLINE const complex< int64_tsum (const SIMDcint64 &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 EnableIf_< And< IsIntegral< T >, HasSize< T, 1UL > >, If_< IsSigned< 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_< And< IsIntegral< T >, HasSize< T, 1UL > >, If_< IsSigned< 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_< And< IsIntegral< T >, HasSize< T, 2UL > >, If_< IsSigned< 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_< And< IsIntegral< T >, HasSize< T, 2UL > >, If_< IsSigned< 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_< And< IsIntegral< T >, HasSize< T, 4UL > >, If_< IsSigned< 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_< And< IsIntegral< T >, HasSize< T, 4UL > >, If_< IsSigned< 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_< And< IsIntegral< T >, HasSize< T, 8UL > >, If_< IsSigned< 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_< And< IsIntegral< T >, HasSize< T, 8UL > >, If_< IsSigned< 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...
 
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_< And< IsIntegral< T1 >, HasSize< 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_< And< IsIntegral< T1 >, HasSize< 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_< And< IsIntegral< T1 >, HasSize< 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_< And< IsIntegral< T1 >, HasSize< 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_< And< IsIntegral< T1 >, HasSize< 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_< And< IsIntegral< T1 >, HasSize< 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_< And< IsIntegral< T1 >, HasSize< 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_< And< IsIntegral< T1 >, HasSize< 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_< And< IsIntegral< T1 >, HasSize< 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_< And< IsIntegral< T1 >, HasSize< 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_< And< IsIntegral< T1 >, HasSize< 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_< And< IsIntegral< T1 >, HasSize< 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_< And< IsIntegral< T1 >, HasSize< 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_< And< IsIntegral< T1 >, HasSize< 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_< And< IsIntegral< T1 >, HasSize< 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_< And< IsIntegral< T1 >, HasSize< 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_< And< IsIntegral< T1 >, HasSize< 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_< And< IsIntegral< T1 >, HasSize< 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_< And< IsIntegral< T1 >, HasSize< 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_< And< IsIntegral< T1 >, HasSize< 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_< And< IsIntegral< T1 >, HasSize< 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_< And< IsIntegral< T1 >, HasSize< 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_< And< IsIntegral< T1 >, HasSize< 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_< And< IsIntegral< T1 >, HasSize< 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 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 T1 , typename T2 >
bool operator== (const SparseMatrix< T1, false > &lhs, const SparseMatrix< T2, false > &rhs)
 Equality operator for the comparison of two row-major sparse matrices. More...
 
template<typename T1 , typename T2 >
bool operator== (const SparseMatrix< T1, true > &lhs, const SparseMatrix< T2, true > &rhs)
 Equality operator for the comparison of two column-major sparse matrices. More...
 
template<typename MT , bool SO>
DisableIf_< Or< IsComputation< MT >, IsTransExpr< MT > >, ColumnExprTrait_< MT > > column (Matrix< MT, SO > &matrix, size_t index)
 Creating a view on a specific column of the given matrix. More...
 
template<typename MT , bool SO>
const DisableIf_< Or< IsComputation< MT >, IsTransExpr< MT > >, ColumnExprTrait_< const MT > > column (const Matrix< MT, SO > &matrix, size_t index)
 Creating a view on a specific column of the given constant matrix. More...
 
template<typename MT , bool SO>
DisableIf_< Or< IsComputation< MT >, IsTransExpr< MT > >, ColumnExprTrait_< MT > > column (Matrix< MT, SO > &&matrix, size_t index)
 Creating a view on a specific column of the given temporary matrix. More...
 
template<typename MT , bool SO>
DisableIf_< Or< IsComputation< MT >, IsTransExpr< MT > >, RowExprTrait_< MT > > row (Matrix< MT, SO > &matrix, size_t index)
 Creating a view on a specific row of the given matrix. More...
 
template<typename MT , bool SO>
const DisableIf_< Or< IsComputation< MT >, IsTransExpr< MT > >, RowExprTrait_< const MT > > row (const Matrix< MT, SO > &matrix, size_t index)
 Creating a view on a specific row of the given constant matrix. More...
 
template<typename MT , bool SO>
DisableIf_< Or< IsComputation< MT >, IsTransExpr< MT > >, RowExprTrait_< MT > > row (Matrix< MT, SO > &&matrix, size_t index)
 Creating a view on a specific row of the given temporary matrix. More...
 
template<typename MT , bool SO>
SubmatrixExprTrait_< MT, unalignedsubmatrix (Matrix< MT, SO > &matrix, size_t row, size_t column, size_t m, size_t n)
 Creating a view on a specific submatrix of the given matrix. More...
 
template<typename MT , bool SO>
const SubmatrixExprTrait_< const MT, unalignedsubmatrix (const Matrix< MT, SO > &matrix, size_t row, size_t column, size_t m, size_t n)
 Creating a view on a specific submatrix of the given constant matrix. More...
 
template<typename MT , bool SO>
SubmatrixExprTrait_< MT, unalignedsubmatrix (Matrix< MT, SO > &&matrix, size_t row, size_t column, size_t m, size_t n)
 Creating a view on a specific submatrix of the given temporary matrix. More...
 
template<bool AF, typename MT , bool SO>
DisableIf_< Or< IsComputation< MT >, IsTransExpr< MT > >, SubmatrixExprTrait_< MT, AF > > submatrix (Matrix< MT, SO > &matrix, size_t row, size_t column, size_t m, size_t n)
 Creating a view on a specific submatrix of the given matrix. More...
 
template<bool AF, typename MT , bool SO>
const DisableIf_< Or< IsComputation< MT >, IsTransExpr< MT > >, SubmatrixExprTrait_< const MT, AF > > submatrix (const Matrix< MT, SO > &matrix, size_t row, size_t column, size_t m, size_t n)
 Creating a view on a specific submatrix of the given constant matrix. More...
 
template<bool AF, typename MT , bool SO>
DisableIf_< Or< IsComputation< MT >, IsTransExpr< MT > >, SubmatrixExprTrait_< MT, AF > > submatrix (Matrix< MT, SO > &&matrix, size_t row, size_t column, size_t m, size_t n)
 Creating a view on a specific submatrix of the given temporary matrix. More...
 
template<typename VT , bool TF>
SubvectorExprTrait_< VT, unalignedsubvector (Vector< VT, TF > &vector, size_t index, size_t size)
 Creating a view on a specific subvector of the given vector. More...
 
template<typename VT , bool TF>
const SubvectorExprTrait_< const VT, unalignedsubvector (const Vector< VT, TF > &vector, size_t index, size_t size)
 Creating a view on a specific subvector of the given constant vector. More...
 
template<typename VT , bool TF>
SubvectorExprTrait_< VT, unalignedsubvector (Vector< VT, TF > &&vector, size_t index, size_t size)
 Creating a view on a specific subvector of the given temporary vector. More...
 
template<bool AF, typename VT , bool TF>
DisableIf_< Or< IsComputation< VT >, IsTransExpr< VT > >, SubvectorExprTrait_< VT, AF > > subvector (Vector< VT, TF > &vector, size_t index, size_t size)
 Creating a view on a specific subvector of the given vector. More...
 
template<bool AF, typename VT , bool TF>
const DisableIf_< Or< IsComputation< VT >, IsTransExpr< VT > >, SubvectorExprTrait_< const VT, AF > > subvector (const Vector< VT, TF > &vector, size_t index, size_t size)
 Creating a view on a specific subvector of the given constant vector. More...
 
template<bool AF, typename VT , bool TF>
DisableIf_< Or< IsComputation< VT >, IsTransExpr< VT > >, SubvectorExprTrait_< VT, AF > > subvector (Vector< VT, TF > &&vector, size_t index, size_t size)
 Creating a view on a specific subvector of the given temporary vector. 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<typename D , typename S >
size_t polymorphicCount (S *const *first, S *const *last)
 Counts the pointer to objects with dynamic type D. More...
 
template<typename D , typename S >
S *const * polymorphicFind (S *const *first, S *const *last)
 Finds the next pointer to an object with dynamic type D. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE bool checkAlignment (const T *address)
 Checks the alignment of the given address. 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 To , typename From >
To convert (const From &from)
 Conversion from type From to type To. More...
 
template<typename T , unsigned int N>
size_t dimensionof (T(&a)[N])
 Static evaluation of array dimensions. More...
 
template<typename T >
EnableIf_< IsBuiltin< T >, T * > allocate (size_t size)
 Aligned array allocation for built-in data types. More...
 
template<typename T >
DisableIf_< IsBuiltin< T >, T * > allocate (size_t size)
 Aligned array allocation for user-specific class types. More...
 
template<typename T >
EnableIf_< IsBuiltin< T > > deallocate (T *address) noexcept
 Deallocation of memory for built-in data types. More...
 
template<typename T >
DisableIf_< IsBuiltin< 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...
 
template<typename... Args>
void UNUSED_PARAMETER (const Args &...)
 Suppression of unused parameter warnings. More...
 
Accuracy operators
template<typename A , typename T >
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 >
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 >
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 >
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 >
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 >
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 >
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 >
bool operator> (const T &lhs, const NegativeAccuracy< A > & )
 Greater-than comparison between a floating point value and a NegativeAccuracy object. More...
 
template<typename T >
bool operator== (const Accuracy &, const T &rhs)
 Equality comparison between an Accuracy object and a floating point value. More...
 
template<typename T >
bool operator== (const T &lhs, const Accuracy & )
 Equality comparison between a floating point value and an Accuracy object. More...
 
template<typename T >
bool operator!= (const Accuracy &, const T &rhs)
 Inequality comparison between an Accuracy object and a floating point value. More...
 
template<typename T >
bool operator!= (const T &lhs, const Accuracy & )
 Inequality comparison between a floating point value and an Accuracy object. More...
 
template<typename T >
bool operator< (const Accuracy &, const T &rhs)
 Less-than comparison between an Accuracy object and a floating point value. More...
 
template<typename T >
bool operator< (const T &lhs, const Accuracy & )
 Less-than comparison between a floating point value and an Accuracy object. More...
 
template<typename T >
bool operator> (const Accuracy &, const T &rhs)
 Greater-than comparison between an Accuracy object and a floating point value. More...
 
template<typename T >
bool operator> (const T &lhs, const Accuracy & )
 Greater-than comparison between a floating point value and an Accuracy object. More...
 
template<typename T >
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 >
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 >
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 >
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<typename MT >
bool isDefault (const DiagonalProxy< MT > &proxy)
 Returns whether the represented element is in default state. More...
 
template<typename MT >
bool isReal (const DiagonalProxy< MT > &proxy)
 Returns whether the matrix element represents a real number. More...
 
template<typename MT >
bool isZero (const DiagonalProxy< MT > &proxy)
 Returns whether the represented element is 0. More...
 
template<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<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<typename MT >
bool isDefault (const HermitianProxy< MT > &proxy)
 Returns whether the represented element is in default state. More...
 
template<typename MT >
bool isReal (const HermitianProxy< MT > &proxy)
 Returns whether the matrix element represents a real number. More...
 
template<typename MT >
bool isZero (const HermitianProxy< MT > &proxy)
 Returns whether the represented element is 0. More...
 
template<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<typename MT >
bool isDefault (const HermitianValue< MT > &value)
 Returns whether the Hermitian value is in default state. More...
 
template<typename MT >
bool isReal (const HermitianValue< MT > &value)
 Returns whether the Hermitian value represents a real number. More...
 
template<typename MT >
bool isZero (const HermitianValue< MT > &value)
 Returns whether the Hermitian value is 0. More...
 
template<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<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<typename MT >
bool isDefault (const LowerProxy< MT > &proxy)
 Returns whether the represented element is in default state. More...
 
template<typename MT >
bool isReal (const LowerProxy< MT > &proxy)
 Returns whether the matrix element represents a real number. More...
 
template<typename MT >
bool isZero (const LowerProxy< MT > &proxy)
 Returns whether the represented element is 0. More...
 
template<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<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<typename MT >
bool isDefault (const StrictlyLowerProxy< MT > &proxy)
 Returns whether the represented element is in default state. More...
 
template<typename MT >
bool isReal (const StrictlyLowerProxy< MT > &proxy)
 Returns whether the matrix element represents a real number. More...
 
template<typename MT >
bool isZero (const StrictlyLowerProxy< MT > &proxy)
 Returns whether the represented element is 0. More...
 
template<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<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<typename MT >
bool isDefault (const StrictlyUpperProxy< MT > &proxy)
 Returns whether the represented element is in default state. More...
 
template<typename MT >
bool isReal (const StrictlyUpperProxy< MT > &proxy)
 Returns whether the matrix element represents a real number. More...
 
template<typename MT >
bool isZero (const StrictlyUpperProxy< MT > &proxy)
 Returns whether the represented element is 0. More...
 
template<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<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<typename MT >
bool isDefault (const NonNumericProxy< MT > &proxy)
 Returns whether the represented element is in default state. More...
 
template<typename MT >
bool isReal (const NonNumericProxy< MT > &proxy)
 Returns whether the matrix element represents a real number. More...
 
template<typename MT >
bool isZero (const NonNumericProxy< MT > &proxy)
 Returns whether the represented element is 0. More...
 
template<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<typename MT >
bool isDefault (const NumericProxy< MT > &proxy)
 Returns whether the represented element is in default state. More...
 
template<typename MT >
bool isReal (const NumericProxy< MT > &proxy)
 Returns whether the matrix element represents a real number. More...
 
template<typename MT >
bool isZero (const NumericProxy< MT > &proxy)
 Returns whether the represented element is 0. More...
 
template<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<typename Type >
bool isDefault (const SharedValue< Type > &value)
 Returns whether the shared value is in default state. 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<typename MT >
bool isDefault (const SymmetricValue< MT > &value)
 Returns whether the symmetric value is in default state. More...
 
template<typename MT >
bool isReal (const SymmetricValue< MT > &value)
 Returns whether the symmetric value represents a real number. More...
 
template<typename MT >
bool isZero (const SymmetricValue< MT > &value)
 Returns whether the symmetric value is 0. More...
 
template<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<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<typename MT >
bool isDefault (const UniLowerProxy< MT > &proxy)
 Returns whether the represented element is in default state. More...
 
template<typename MT >
bool isReal (const UniLowerProxy< MT > &proxy)
 Returns whether the matrix element represents a real number. More...
 
template<typename MT >
bool isZero (const UniLowerProxy< MT > &proxy)
 Returns whether the represented element is 0. More...
 
template<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<typename MT >
bool isDefault (const UniLowerValue< MT > &value)
 Returns whether the unilower value is in default state. More...
 
template<typename MT >
bool isReal (const UniLowerValue< MT > &value)
 Returns whether the unilower value represents a real number. More...
 
template<typename MT >
bool isZero (const UniLowerValue< MT > &value)
 Returns whether the unilower value is 0. More...
 
template<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<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<typename MT >
bool isDefault (const UniUpperProxy< MT > &proxy)
 Returns whether the represented element is in default state. More...
 
template<typename MT >
bool isReal (const UniUpperProxy< MT > &proxy)
 Returns whether the matrix element represents a real number. More...
 
template<typename MT >
bool isZero (const UniUpperProxy< MT > &proxy)
 Returns whether the represented element is 0. More...
 
template<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<typename MT >
bool isDefault (const UniUpperValue< MT > &value)
 Returns whether the uniupper value is in default state. More...
 
template<typename MT >
bool isReal (const UniUpperValue< MT > &value)
 Returns whether the uniupper value represents a real number. More...
 
template<typename MT >
bool isZero (const UniUpperValue< MT > &value)
 Returns whether the uniupper value is 0. More...
 
template<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<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<typename MT >
bool isDefault (const UpperProxy< MT > &proxy)
 Returns whether the represented element is in default state. More...
 
template<typename MT >
bool isReal (const UpperProxy< MT > &proxy)
 Returns whether the matrix element represents a real number. More...
 
template<typename MT >
bool isZero (const UpperProxy< MT > &proxy)
 Returns whether the represented element is 0. More...
 
template<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<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>
void reset (CustomMatrix< Type, AF, PF, SO > &m)
 Resetting the given custom matrix. More...
 
template<typename Type , bool AF, bool PF, bool SO>
void reset (CustomMatrix< Type, AF, PF, SO > &m, size_t i)
 Reset the specified row/column of the given custom matrix. More...
 
template<typename Type , bool AF, bool PF, bool SO>
void clear (CustomMatrix< Type, AF, PF, SO > &m)
 Clearing the given custom matrix. More...
 
template<typename Type , bool AF, bool PF, bool SO>
bool isDefault (const CustomMatrix< Type, AF, PF, SO > &m)
 Returns whether the given custom matrix is in default state. More...
 
template<typename Type , bool AF, bool PF, bool SO>
bool isIntact (const CustomMatrix< Type, AF, PF, SO > &m)
 Returns whether the invariants of the given custom matrix are intact. More...
 
template<typename Type , bool AF, bool PF, bool SO>
void swap (CustomMatrix< Type, AF, PF, SO > &a, CustomMatrix< Type, AF, PF, SO > &b) noexcept
 Swapping the contents of two custom matrices. More...
 
CustomVector operators
template<typename Type , bool AF, bool PF, bool TF>
void reset (CustomVector< Type, AF, PF, TF > &v)
 Resetting the given custom vector. More...
 
template<typename Type , bool AF, bool PF, bool TF>
void clear (CustomVector< Type, AF, PF, TF > &v)
 Clearing the given custom vector. More...
 
template<typename Type , bool AF, bool PF, bool TF>
bool isDefault (const CustomVector< Type, AF, PF, TF > &v)
 Returns whether the given custom vector is in default state. More...
 
template<typename Type , bool AF, bool PF, bool TF>
bool isIntact (const CustomVector< Type, AF, PF, TF > &v) noexcept
 Returns whether the invariants of the given custom vector are intact. More...
 
template<typename Type , bool AF, bool PF, bool TF>
void swap (CustomVector< Type, AF, PF, TF > &a, CustomVector< Type, AF, PF, TF > &b) noexcept
 Swapping the contents of two vectors. More...
 
DenseIterator operators
template<typename T1 , bool AF1, typename T2 , bool AF2>
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>
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>
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>
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>
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>
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>
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>
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>
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>
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 >
bool operator== (const DenseMatrix< T1, false > &lhs, const DenseMatrix< T2, false > &rhs)
 Equality operator for the comparison of two rwo-major dense matrices. More...
 
template<typename T1 , typename T2 >
bool operator== (const DenseMatrix< T1, true > &lhs, const DenseMatrix< T2, true > &rhs)
 Equality operator for the comparison of two column-major dense matrices. More...
 
template<typename T1 , typename T2 , bool SO>
bool operator== (const DenseMatrix< T1, SO > &lhs, const DenseMatrix< T2,!SO > &rhs)
 Equality operator for the comparison of two dense matrices with different storage order. More...
 
template<typename T1 , typename T2 , bool SO>
bool operator== (const DenseMatrix< T1, SO > &lhs, const SparseMatrix< T2, false > &rhs)
 Equality operator for the comparison of a dense matrix and a row-major sparse matrix. More...
 
template<typename T1 , typename T2 , bool SO>
bool operator== (const DenseMatrix< T1, SO > &lhs, const SparseMatrix< T2, true > &rhs)
 Equality operator for the comparison of a dense matrix and a column-major sparse matrix. More...
 
template<typename T1 , bool SO1, typename T2 , bool SO2>
bool operator== (const SparseMatrix< T1, SO1 > &lhs, const DenseMatrix< T2, SO2 > &rhs)
 Equality operator for the comparison of a sparse matrix and a dense matrix. More...
 
template<typename T1 , typename T2 >
EnableIf_< IsNumeric< T2 >, bool > operator== (const DenseMatrix< T1, false > &mat, T2 scalar)
 Equality operator for the comparison of a row-major dense matrix and a scalar value. More...
 
template<typename T1 , typename T2 >
EnableIf_< IsNumeric< T2 >, bool > operator== (const DenseMatrix< T1, true > &mat, T2 scalar)
 Equality operator for the comparison of a column-major dense matrix and a scalar value. More...
 
template<typename T1 , typename T2 , bool SO>
EnableIf_< IsNumeric< T2 >, bool > operator== (T1 scalar, const DenseMatrix< T2, SO > &mat)
 Equality operator for the comparison of a scalar value and a dense matrix. More...
 
template<typename T1 , bool SO1, typename T2 , bool SO2>
bool operator!= (const DenseMatrix< T1, SO1 > &lhs, const DenseMatrix< T2, SO2 > &rhs)
 Inequality operator for the comparison of two dense matrices. More...
 
template<typename T1 , bool SO1, typename T2 , bool SO2>
bool operator!= (const DenseMatrix< T1, SO1 > &lhs, const SparseMatrix< T2, SO2 > &rhs)
 Inequality operator for the comparison of a dense matrix and a sparse matrix. More...
 
template<typename T1 , bool SO1, typename T2 , bool SO2>
bool operator!= (const SparseMatrix< T1, SO1 > &lhs, const DenseMatrix< T2, SO2 > &rhs)
 Inequality operator for the comparison of a sparse matrix and a dense matrix. More...
 
template<typename T1 , typename T2 , bool SO>
EnableIf_< IsNumeric< T2 >, bool > operator!= (const DenseMatrix< T1, SO > &mat, T2 scalar)
 Inequality operator for the comparison of a dense matrix and a scalar value. More...
 
template<typename T1 , typename T2 , bool SO>
EnableIf_< IsNumeric< T2 >, bool > operator!= (T1 scalar, const DenseMatrix< T2, SO > &mat)
 Inequality operator for the comparison of a scalar value and a 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<typename MT , bool SO>
bool isSymmetric (const DenseMatrix< MT, SO > &dm)
 Checks if the given dense matrix is symmetric. More...
 
template<typename MT , bool SO>
bool isHermitian (const DenseMatrix< MT, SO > &dm)
 Checks if the given dense matrix is Hermitian. More...
 
template<typename MT , bool SO>
bool isUniform (const DenseMatrix< MT, SO > &dm)
 Checks if the given dense matrix is a uniform matrix. More...
 
template<typename MT , bool SO>
bool isLower (const DenseMatrix< MT, SO > &dm)
 Checks if the given dense matrix is a lower triangular matrix. More...
 
template<typename MT , bool SO>
bool isUniLower (const DenseMatrix< MT, SO > &dm)
 Checks if the given dense matrix is a lower unitriangular matrix. More...
 
template<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<typename MT , bool SO>
bool isUpper (const DenseMatrix< MT, SO > &dm)
 Checks if the given dense matrix is an upper triangular matrix. More...
 
template<typename MT , bool SO>
bool isUniUpper (const DenseMatrix< MT, SO > &dm)
 Checks if the given dense matrix is an upper unitriangular matrix. More...
 
template<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<typename MT , bool SO>
bool isDiagonal (const DenseMatrix< MT, SO > &dm)
 Checks if the give dense matrix is diagonal. More...
 
template<typename MT , bool SO>
bool isIdentity (const DenseMatrix< MT, SO > &dm)
 Checks if the give dense matrix is an identity matrix. More...
 
template<typename MT , bool SO>
const ElementType_< MT > min (const DenseMatrix< MT, SO > &dm)
 Returns the smallest element of the dense matrix. More...
 
template<typename MT , bool SO>
const ElementType_< MT > max (const DenseMatrix< MT, SO > &dm)
 Returns the largest element of the dense matrix. More...
 
DenseVector operators
template<typename T1 , bool TF1, typename T2 , bool TF2>
bool operator== (const DenseVector< T1, TF1 > &lhs, const DenseVector< T2, TF2 > &rhs)
 Equality operator for the comparison of two dense vectors. More...
 
template<typename T1 , bool TF1, typename T2 , bool TF2>
bool operator== (const DenseVector< T1, TF1 > &lhs, const SparseVector< T2, TF2 > &rhs)
 Equality operator for the comparison of a dense vector and a sparse vector. More...
 
template<typename T1 , bool TF1, typename T2 , bool TF2>
bool operator== (const SparseVector< T1, TF1 > &lhs, const DenseVector< T2, TF2 > &rhs)
 Equality operator for the comparison of a sparse vector and a dense vector. More...
 
template<typename T1 , typename T2 , bool TF>
EnableIf_< IsNumeric< T2 >, bool > operator== (const DenseVector< T1, TF > &vec, T2 scalar)
 Equality operator for the comparison of a dense vector and a scalar value. More...
 
template<typename T1 , typename T2 , bool TF>
EnableIf_< IsNumeric< T1 >, bool > operator== (T1 scalar, const DenseVector< T2, TF > &vec)
 Equality operator for the comparison of a scalar value and a dense vector. More...
 
template<typename T1 , bool TF1, typename T2 , bool TF2>
bool operator!= (const DenseVector< T1, TF1 > &lhs, const DenseVector< T2, TF2 > &rhs)
 Inequality operator for the comparison of two dense vectors. More...
 
template<typename T1 , bool TF1, typename T2 , bool TF2>
bool operator!= (const DenseVector< T1, TF1 > &lhs, const SparseVector< T2, TF2 > &rhs)
 Inequality operator for the comparison of a dense vector and a sparse vector. More...
 
template<typename T1 , bool TF1, typename T2 , bool TF2>
bool operator!= (const SparseVector< T1, TF1 > &lhs, const DenseVector< T2, TF2 > &rhs)
 Inequality operator for the comparison of a sparse vector and a dense vector. More...
 
template<typename T1 , typename T2 , bool TF>
EnableIf_< IsNumeric< T2 >, bool > operator!= (const DenseVector< T1, TF > &vec, T2 scalar)
 Inequality operator for the comparison of a dense vector and a scalar value. More...
 
template<typename T1 , typename T2 , bool TF>
EnableIf_< IsNumeric< T1 >, bool > operator!= (T1 scalar, const DenseVector< T2, TF > &vec)
 Inequality operator for the comparison of a scalar value and a 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<typename VT , bool TF>
bool isUniform (const DenseVector< VT, TF > &dv)
 Checks if the given dense vector is a uniform vector. More...
 
template<typename VT , bool TF>
const ElementType_< VT > sqrLength (const DenseVector< VT, TF > &dv)
 Calculation of the dense vector square length $|\vec{a}|^2$. More...
 
template<typename VT , bool TF>
auto length (const DenseVector< VT, TF > &dv) -> decltype(sqrt(sqrLength(~dv)))
 Calculation of the dense vector length $|\vec{a}|$. More...
 
template<typename VT , bool TF>
const ElementType_< VT > min (const DenseVector< VT, TF > &dv)
 Returns the smallest element of the dense vector. More...
 
template<typename VT , bool TF>
const ElementType_< VT > max (const DenseVector< VT, TF > &dv)
 Returns the largest element of the dense 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<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<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...
 
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<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<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...
 
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<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>
void reset (StaticVector< Type, N, TF > &v)
 Resetting the given static vector. More...
 
template<typename Type , size_t N, bool TF>
void clear (StaticVector< Type, N, TF > &v)
 Clearing the given static vector. More...
 
template<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>
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 ( $ \vec{a}=\vec{b}^\perp $). More...
 
template<typename Type , bool TF>
const StaticVector< Type, 3UL, TF > perp (const StaticVector< Type, 3UL, TF > &v)
 Creates a perpendicular vector b which satisfies $ \vec{a} \cdot \vec{b} = 0 $. More...
 
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...
 
NegativeEpsilon operators
template<typename E , typename T >
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 >
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 >
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 >
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 >
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 >
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 >
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 >
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 >
bool operator== (const Epsilon &, const T &rhs)
 Equality comparison between an Epsilon object and a floating point value. More...
 
template<typename T >
bool operator== (const T &lhs, const Epsilon & )
 Equality comparison between a floating point value and an Epsilon object. More...
 
template<typename T >
bool operator!= (const Epsilon &, const T &rhs)
 Inequality comparison between an Epsilon object and a floating point value. More...
 
template<typename T >
bool operator!= (const T &lhs, const Epsilon & )
 Inequality comparison between a floating point value and an Epsilon object. More...
 
template<typename T >
bool operator< (const Epsilon &, const T &rhs)
 Less-than comparison between an Epsilon object and a floating point value. More...
 
template<typename T >
bool operator< (const T &lhs, const Epsilon & )
 Less-than comparison between a floating point value and an Epsilon object. More...
 
template<typename T >
bool operator> (const Epsilon &, const T &rhs)
 Greater-than comparison between an Epsilon object and a floating point value. More...
 
template<typename T >
bool operator> (const T &lhs, const Epsilon & )
 Greater-than comparison between a floating point value and an Epsilon object. More...
 
template<typename T >
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 >
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 >
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 >
bool operator>= (const T &lhs, const Epsilon & )
 Less-or-equal-than comparison between a floating point value and an Epsilon object. More...
 
Determinant functions
template<typename MT , bool SO>
ElementType_< 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>
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 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 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 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 transpose (Matrix< MT, SO > &matrix)
 In-place transpose of the given matrix. 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...
 
Vector global functions
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 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 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...
 
Mathematical utility functions
template<typename T >
constexpr int sign (T a) noexcept
 Sign function. More...
 
template<typename T >
size_t digits (T a) noexcept
 Returns the number of valid digits of an integral value. More...
 
template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE constexpr CommonType_< T1, T2 > min (const T1 &a, const T2 &b) noexcept(All< IsNumeric, T1, T2 >::value)
 Minimum function for two data values. More...
 
template<typename T1 , typename T2 , typename... Ts>
BLAZE_ALWAYS_INLINE constexpr CommonType_< T1, T2, Ts... > min (const T1 &a, const T2 &b, const Ts &...args) noexcept(All< IsNumeric, T1, T2, Ts... >::value)
 Minimum function for at least three data values. More...
 
template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE constexpr CommonType_< T1, T2 > max (const T1 &a, const T2 &b) noexcept(All< IsNumeric, T1, T2 >::value)
 Maximum function for two data values. More...
 
template<typename T1 , typename T2 , typename... Ts>
BLAZE_ALWAYS_INLINE constexpr CommonType_< T1, T2, Ts... > max (const T1 &a, const T2 &b, const Ts &...args) noexcept(All< IsNumeric, T1, T2, Ts... >::value)
 Maximum function for at least three data values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE constexpr T nextMultiple (T value, T factor) noexcept
 Rounds up an integral value to the next multiple of a given factor. More...
 
template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE constexpr bool lessThan (T1 a, T2 b) noexcept(IsBuiltin< CommonType_< T1, T2 > >::value)
 
NegativeInfinity operators
template<typename I1 , typename I2 >
bool operator== (const NegativeInfinity< I1 > &lhs, const NegativeInfinity< I2 > &rhs)
 Equality comparison between two NegativeInfinity objects. More...
 
template<typename I , typename T >
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 >
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 >
bool operator!= (const NegativeInfinity< I1 > &lhs, const NegativeInfinity< I2 > &rhs)
 Inequality comparison between two NegativeInfinity objects. More...
 
template<typename I , typename T >
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 >
bool operator!= (const T &lhs, const NegativeInfinity< I > &rhs)
 Inequality comparison between a built-in data type and an NegativeInfinity object. More...
 
Infinity operators
bool operator== (const Infinity &lhs, const Infinity &rhs)
 Equality comparison between two Infinity objects. More...
 
template<typename I >
bool operator== (const Infinity &lhs, const NegativeInfinity< I > &rhs)
 Equality comparison between an Infinity object and a NegativeInfinity object. More...
 
template<typename I >
bool operator== (const NegativeInfinity< I > &lhs, const Infinity &rhs)
 Equality comparison between a NegativeInfinity object and an Infinity object. More...
 
template<typename T >
bool operator== (const Infinity &lhs, const T &rhs)
 Equality comparison between an Infinity object and a built-in data type. More...
 
template<typename T >
bool operator== (const T &lhs, const Infinity &rhs)
 Equality comparison between a built-in data type and an Infinity object. More...
 
bool operator!= (const Infinity &lhs, const Infinity &rhs)
 Inequality comparison between two Infinity objects. More...
 
template<typename I >
bool operator!= (const Infinity &lhs, const NegativeInfinity< I > &rhs)
 Inequality comparison between an Infinity object and a NegativeInfinity object. More...
 
template<typename I >
bool operator!= (const NegativeInfinity< I > &lhs, const Infinity &rhs)
 Inequality comparison between a NegativeInfinity object and an Infinity object. More...
 
template<typename T >
bool operator!= (const Infinity &lhs, const T &rhs)
 Inequality comparison between an Infinity object and a built-in data type. More...
 
template<typename T >
bool operator!= (const T &lhs, const Infinity &rhs)
 Inequality comparison between a built-in data type and an Infinity object. 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_< 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_< 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_< 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_< MT > *tau)
 LAPACK kernel for the RQ decomposition of the given dense 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 ( $ A*X=B $). More...
 
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 ( $ A*X=B $). More...
 
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 ( $ A*X=B $). More...
 
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 ( $ A*X=B $). More...
 
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 ( $ A*x=b $). More...
 
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 ( $ A*X=B $). 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 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 ( $ A*X=B $). More...
 
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 ( $ A*X=B $). More...
 
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 ( $ A*X=B $). More...
 
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 ( $ A*X=B $). More...
 
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 ( $ A*x=b $). More...
 
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 ( $ A*X=B $). 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 ( $ A*X=B $). More...
 
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 ( $ A*X=B $). More...
 
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 ( $ A*x=b $). More...
 
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 ( $ A*X=B $). More...
 
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 ( $ A*X=B $). More...
 
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 ( $ A*X=B $). More...
 
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 ( $ A*x=b $). More...
 
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 ( $ A*X=B $). 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_< 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_< 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_< 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 (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_< 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_< 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_< 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_< 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_< 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 ( $ A*X=B $). More...
 
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 ( $ A*X=B $). More...
 
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 ( $ A*X=B $). More...
 
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 ( $ A*X=B $). More...
 
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 ( $ A*x=b $). More...
 
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 ( $ A*X=B $). More...
 
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 ( $ A*X=B $). More...
 
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 ( $ A*X=B $). More...
 
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 ( $ A*X=B $). More...
 
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 ( $ A*X=B $). More...
 
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 ( $ A*x=b $). More...
 
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 ( $ A*X=B $). 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 ( $ A*X=B $). More...
 
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 ( $ A*X=B $). More...
 
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 ( $ A*X=B $). More...
 
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 ( $ A*X=B $). More...
 
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 ( $ A*x=b $). More...
 
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 ( $ A*X=B $). More...
 
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 ( $ A*X=B $). More...
 
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 ( $ A*X=B $). More...
 
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 ( $ A*X=B $). More...
 
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 ( $ A*X=B $). More...
 
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 ( $ A*x=b $). More...
 
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 ( $ A*X=B $). More...
 
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 ( $ A*X=B $). More...
 
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 ( $ A*x=b $). More...
 
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 ( $ A*x=b $). More...
 
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 ( $ A*x=b $). More...
 
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 ( $ A*x=b $). ( $ A*x=b $). More...
 
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 ( $ A*X=B $). More...
 
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 ( $ A*X=B $). More...
 
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 ( $ A*X=B $). More...
 
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 ( $ A*X=B $). More...
 
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 ( $ A*x=b $). More...
 
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 ( $ A*X=B $). 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_< 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_< 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_< 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 (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_< 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_< 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_< 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_< 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 SO1, typename MT2 , bool SO2>
void unmrq (DenseMatrix< MT1, SO1 > &C, const DenseMatrix< MT2, SO2 > &A, char side, char trans, const ElementType_< MT2 > *tau)
 
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 >
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...
 
DenseVectorProxy global functions
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...
 
Proxy operators
template<typename PT1 , typename RT1 , typename PT2 , typename RT2 >
AddExprTrait_< RT1, RT2 > operator+ (const Proxy< PT1, RT1 > &lhs, const Proxy< PT2, RT2 > &rhs)
 Addition between two Proxy objects. More...
 
template<typename PT , typename RT , typename T >
DisableIf_< IsProxy< T >, AddExprTrait_< RT, T > > operator+ (const Proxy< PT, RT > &lhs, const T &rhs)
 Addition between a Proxy object and an object of different type. More...
 
template<typename T , typename PT , typename RT >
DisableIf_< IsProxy< T >, AddExprTrait_< T, RT > > operator+ (const T &lhs, const Proxy< PT, RT > &rhs)
 Addition between an object of different type and a Proxy object. More...
 
template<typename PT1 , typename RT1 , typename PT2 , typename RT2 >
SubExprTrait_< RT1, RT2 > operator- (const Proxy< PT1, RT1 > &lhs, const Proxy< PT2, RT2 > &rhs)
 Subtraction between two Proxy objects. More...
 
template<typename PT , typename RT , typename T >
DisableIf_< IsProxy< T >, SubExprTrait_< RT, T > > operator- (const Proxy< PT, RT > &lhs, const T &rhs)
 Subtraction between a Proxy object and an object of different type. More...
 
template<typename T , typename PT , typename RT >
DisableIf_< IsProxy< T >, SubExprTrait_< T, RT > > operator- (const T &lhs, const Proxy< PT, RT > &rhs)
 Subtraction between an object of different type and a Proxy object. More...
 
template<typename PT1 , typename RT1 , typename PT2 , typename RT2 >
MultExprTrait_< RT1, RT2 > operator* (const Proxy< PT1, RT1 > &lhs, const Proxy< PT2, RT2 > &rhs)
 Multiplication between two Proxy objects. More...
 
template<typename PT , typename RT , typename T >
DisableIf_< IsProxy< T >, MultExprTrait_< RT, T > > operator* (const Proxy< PT, RT > &lhs, const T &rhs)
 Multiplication between a Proxy object and an object of different type. More...
 
template<typename T , typename PT , typename RT >
DisableIf_< IsProxy< T >, MultExprTrait_< T, RT > > operator* (const T &lhs, const Proxy< PT, RT > &rhs)
 Multiplication between an object of different type and a Proxy object. More...
 
template<typename PT1 , typename RT1 , typename PT2 , typename RT2 >
DivExprTrait_< RT1, RT2 > operator/ (const Proxy< PT1, RT1 > &lhs, const Proxy< PT2, RT2 > &rhs)
 Division between two Proxy objects. More...
 
template<typename PT , typename RT , typename T >
DisableIf_< IsProxy< T >, DivExprTrait_< RT, T > > operator/ (const Proxy< PT, RT > &lhs, const T &rhs)
 Division between a Proxy object and an object of different type. More...
 
template<typename T , typename PT , typename RT >
DisableIf_< IsProxy< T >, DivExprTrait_< T, RT > > 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 >
DisableIf_< IsProxy< 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 >
DisableIf_< IsProxy< 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 >
DisableIf_< IsProxy< 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 >
DisableIf_< IsProxy< 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 >
DisableIf_< IsProxy< 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 >
DisableIf_< IsProxy< 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 >
DisableIf_< IsProxy< 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 >
DisableIf_< IsProxy< 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 >
DisableIf_< IsProxy< 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 >
DisableIf_< IsProxy< 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 >
DisableIf_< IsProxy< 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 >
DisableIf_< IsProxy< 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 >
auto trans (const Proxy< PT, RT > &proxy) -> decltype(trans(std::declval< RepresentedType_< PT > >()))
 Computing the transpose of the represented element. More...
 
template<typename PT , typename RT >
auto ctrans (const Proxy< PT, RT > &proxy) -> decltype(ctrans(std::declval< RepresentedType_< PT > >()))
 Computing the conjugate transpose of the represented element. More...
 
template<typename PT , typename RT >
auto abs (const Proxy< PT, RT > &proxy) -> decltype(abs(std::declval< RepresentedType_< PT > >()))
 Computing the absolute value of the represented element. More...
 
template<typename PT , typename RT >
auto conj (const Proxy< PT, RT > &proxy) -> decltype(conj(std::declval< RepresentedType_< PT > >()))
 Computing the complex conjugate of the represented element. More...
 
template<typename PT , typename RT >
auto real (const Proxy< PT, RT > &proxy) -> decltype(real(std::declval< RepresentedType_< PT > >()))
 Computing the real part of the represented element. More...
 
template<typename PT , typename RT >
auto imag (const Proxy< PT, RT > &proxy) -> decltype(imag(std::declval< RepresentedType_< PT > >()))
 Computing the imaginary part of the represented element. More...
 
template<typename PT , typename RT >
auto sqrt (const Proxy< PT, RT > &proxy) -> decltype(sqrt(std::declval< RepresentedType_< PT > >()))
 Computing the square root of the represented element. More...
 
template<typename PT , typename RT >
auto invsqrt (const Proxy< PT, RT > &proxy) -> decltype(invsqrt(std::declval< RepresentedType_< PT > >()))
 Computing the inverse square root of the represented element. More...
 
template<typename PT , typename RT >
auto cbrt (const Proxy< PT, RT > &proxy) -> decltype(cbrt(std::declval< RepresentedType_< PT > >()))
 Computing the cubic root of the represented element. More...
 
template<typename PT , typename RT >
auto invcbrt (const Proxy< PT, RT > &proxy) -> decltype(invcbrt(std::declval< RepresentedType_< PT > >()))
 Computing the inverse cubic root of the represented element. More...
 
template<typename PT , typename RT >
auto floor (const Proxy< PT, RT > &proxy) -> decltype(floor(std::declval< RepresentedType_< PT > >()))
 Computes the largest integral value that is not greater than the represented element. More...
 
template<typename PT , typename RT >
auto ceil (const Proxy< PT, RT > &proxy) -> decltype(ceil(std::declval< RepresentedType_< PT > >()))
 Computes the smallest integral value that is not less than the represented element. More...
 
template<typename PT , typename RT , typename ET >
auto pow (const Proxy< PT, RT > &proxy, const ET &exp) -> decltype(pow(std::declval< RepresentedType_< PT > >(), exp))
 Computing the exponential value of the represented element. More...
 
template<typename PT , typename RT >
auto exp (const Proxy< PT, RT > &proxy) -> decltype(exp(std::declval< RepresentedType_< PT > >()))
 Computing the base-e exponential of the represented element. More...
 
template<typename PT , typename RT >
auto sin (const Proxy< PT, RT > &proxy) -> decltype(sin(std::declval< RepresentedType_< PT > >()))
 Computing the sine of the represented element. More...
 
template<typename PT , typename RT >
auto asin (const Proxy< PT, RT > &proxy) -> decltype(asin(std::declval< RepresentedType_< PT > >()))
 Computing the inverse sine of the represented element. More...
 
template<typename PT , typename RT >
auto sinh (const Proxy< PT, RT > &proxy) -> decltype(sinh(std::declval< RepresentedType_< PT > >()))
 Computing the hyperbolic sine of the represented element. More...
 
template<typename PT , typename RT >
auto asinh (const Proxy< PT, RT > &proxy) -> decltype(asinh(std::declval< RepresentedType_< PT > >()))
 Computing the inverse hyperbolic sine of the represented element. More...
 
template<typename PT , typename RT >
auto cos (const Proxy< PT, RT > &proxy) -> decltype(cos(std::declval< RepresentedType_< PT > >()))
 Computing the cosine of the represented element. More...
 
template<typename PT , typename RT >
auto acos (const Proxy< PT, RT > &proxy) -> decltype(acos(std::declval< RepresentedType_< PT > >()))
 Computing the inverse cosine of the represented element. More...
 
template<typename PT , typename RT >
auto cosh (const Proxy< PT, RT > &proxy) -> decltype(cosh(std::declval< RepresentedType_< PT > >()))
 Computing the hyperbolic cosine of the represented element. More...
 
template<typename PT , typename RT >
auto acosh (const Proxy< PT, RT > &proxy) -> decltype(acosh(std::declval< RepresentedType_< PT > >()))
 Computing the inverse hyperbolic cosine of the represented element. More...
 
template<typename PT , typename RT >
auto tan (const Proxy< PT, RT > &proxy) -> decltype(tan(std::declval< RepresentedType_< PT > >()))
 Computing the tangent of the represented element. More...
 
template<typename PT , typename RT >
auto atan (const Proxy< PT, RT > &proxy) -> decltype(atan(std::declval< RepresentedType_< PT > >()))
 Computing the inverse tangent of the represented element. More...
 
template<typename PT , typename RT >
auto tanh (const Proxy< PT, RT > &proxy) -> decltype(tanh(std::declval< RepresentedType_< PT > >()))
 Computing the hyperbolic tangent of the represented element. More...
 
template<typename PT , typename RT >
auto atanh (const Proxy< PT, RT > &proxy) -> decltype(atanh(std::declval< RepresentedType_< PT > >()))
 Computing the inverse hyperbolic tangent of the represented element. More...
 
template<typename PT , typename RT >
void 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<typename PT , typename RT >
bool isReal (const Proxy< PT, RT > &proxy)
 Returns whether the element represents a real number. More...
 
template<typename PT , typename RT >
bool isZero (const Proxy< PT, RT > &proxy)
 Returns whether the represented element is 0. More...
 
template<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...
 
SparseMatrixProxy global functions
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...
 
SparseVectorProxy global functions
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...
 
Dense matrix SMP functions
template<typename MT1 , bool SO1, typename MT2 , bool SO2>
EnableIf_< IsDenseMatrix< MT1 > > smpAssign (Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
 Default implementation of the SMP assignment of a matrix to a dense matrix. More...
 
template<typename MT1 , bool SO1, typename MT2 , bool SO2>
EnableIf_< IsDenseMatrix< MT1 > > smpAddAssign (Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
 Default implementation of the SMP addition assignment of a matrix to a dense matrix. More...
 
template<typename MT1 , bool SO1, typename MT2 , bool SO2>
EnableIf_< IsDenseMatrix< MT1 > > smpSubAssign (Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
 Default implementation of the SMP subtraction assignment of a matrix to dense matrix. More...
 
Dense vector SMP functions
template<typename VT1 , bool TF1, typename VT2 , bool TF2>
EnableIf_< IsDenseVector< VT1 > > smpAssign (Vector< VT1, TF1 > &lhs, const Vector< VT2, TF2 > &rhs)
 Default implementation of the SMP assignment of a vector to a dense vector. More...
 
template<typename VT1 , bool TF1, typename VT2 , bool TF2>
EnableIf_< IsDenseVector< VT1 > > smpAddAssign (Vector< VT1, TF1 > &lhs, const Vector< VT2, TF2 > &rhs)
 Default implementation of the SMP addition assignment of a vector to a dense vector. More...
 
template<typename VT1 , bool TF1, typename VT2 , bool TF2>
EnableIf_< IsDenseVector< VT1 > > smpSubAssign (Vector< VT1, TF1 > &lhs, const Vector< VT2, TF2 > &rhs)
 Default implementation of the SMP subtraction assignment of a vector to a dense vector. More...
 
template<typename VT1 , bool TF1, typename VT2 , bool TF2>
EnableIf_< IsDenseVector< VT1 > > smpMultAssign (Vector< VT1, TF1 > &lhs, const Vector< VT2, TF2 > &rhs)
 Default implementation of the SMP multiplication assignment of a vector to a dense vector. More...
 
template<typename VT1 , bool TF1, typename VT2 , bool TF2>
EnableIf_< IsDenseVector< VT1 > > smpDivAssign (Vector< VT1, TF1 > &lhs, const Vector< VT2, TF2 > &rhs)
 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...
 
Sparse matrix SMP functions
template<typename MT1 , bool SO1, typename MT2 , bool SO2>
EnableIf_< IsSparseMatrix< MT1 > > smpAssign (Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
 Default implementation of the SMP assignment of a matrix to a sparse matrix. More...
 
template<typename MT1 , bool SO1, typename MT2 , bool SO2>
EnableIf_< IsSparseMatrix< MT1 > > smpAddAssign (Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
 Default implementation of the SMP addition assignment of a matrix to a sparse matrix. More...
 
template<typename MT1 , bool SO1, typename MT2 , bool SO2>
EnableIf_< IsSparseMatrix< MT1 > > smpSubAssign (Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs)
 Default implementation of the SMP subtraction assignment of a matrix to sparse matrix. More...
 
Sparse vector SMP functions
template<typename VT1 , bool TF1, typename VT2 , bool TF2>
EnableIf_< IsSparseVector< VT1 > > smpAssign (Vector< VT1, TF1 > &lhs, const Vector< VT2, TF2 > &rhs)
 Default implementation of the SMP assignment of a vector to a sparse vector. More...
 
template<typename VT1 , bool TF1, typename VT2 , bool TF2>
EnableIf_< IsSparseVector< VT1 > > smpAddAssign (Vector< VT1, TF1 > &lhs, const Vector< VT2, TF2 > &rhs)
 Default implementation of the SMP addition assignment of a vector to a sparse vector. More...
 
template<typename VT1 , bool TF1, typename VT2 , bool TF2>
EnableIf_< IsSparseVector< VT1 > > smpSubAssign (Vector< VT1, TF1 > &lhs, const Vector< VT2, TF2 > &rhs)
 Default implementation of the SMP subtraction assignment of a vector to a sparse vector. More...
 
template<typename VT1 , bool TF1, typename VT2 , bool TF2>
EnableIf_< IsSparseVector< VT1 > > smpMultAssign (Vector< VT1, TF1 > &lhs, const Vector< VT2, TF2 > &rhs)
 Default implementation of the SMP multiplication assignment of a vector to a sparse vector. 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...
 
Constructors
 CompressedMatrix ()
 
 CompressedMatrix (size_t m, size_t n)
 
 CompressedMatrix (size_t m, size_t n, size_t nonzeros)
 
 CompressedMatrix (size_t m, size_t n, const std::vector< size_t > &nonzeros)
 
 CompressedMatrix (const CompressedMatrix &sm)
 
 CompressedMatrix (CompressedMatrix &&sm) noexcept
 
template<typename MT , bool SO>
 CompressedMatrix (const DenseMatrix< MT, SO > &dm)
 
template<typename MT , bool SO>
 CompressedMatrix (const SparseMatrix< MT, SO > &sm)
 
Destructor
 ~CompressedMatrix ()
 
Data access functions
Reference operator() (size_t i, size_t j) noexcept
 
Reference at (size_t i, size_t j)
 
Iterator begin (size_t i) noexcept
 
ConstIterator cbegin (size_t i) const noexcept
 
Iterator end (size_t i) noexcept
 
ConstIterator cend (size_t i) const noexcept
 
Assignment operators
CompressedMatrixoperator= (const CompressedMatrix &rhs)
 
CompressedMatrixoperator= (CompressedMatrix &&rhs) noexcept
 
template<typename MT , bool SO>
CompressedMatrixoperator= (const DenseMatrix< MT, SO > &rhs)
 
template<typename MT , bool SO>
CompressedMatrixoperator= (const SparseMatrix< MT, SO > &rhs)
 
template<typename MT , bool SO>
CompressedMatrixoperator+= (const Matrix< MT, SO > &rhs)
 
template<typename MT , bool SO>
CompressedMatrixoperator-= (const Matrix< MT, SO > &rhs)
 
template<typename MT , bool SO>
CompressedMatrixoperator*= (const Matrix< MT, SO > &rhs)
 
template<typename Other >
EnableIf_< IsNumeric< Other >, CompressedMatrix > & operator*= (Other rhs)
 
template<typename Other >
EnableIf_< IsNumeric< Other >, CompressedMatrix > & operator/= (Other rhs)
 
Utility functions
size_t rows () const noexcept
 
size_t columns () const noexcept
 
size_t capacity () const noexcept
 
size_t capacity (size_t j) const noexcept
 
size_t nonZeros () const
 
size_t nonZeros (size_t j) const
 
void reset ()
 
void reset (size_t j)
 
void clear ()
 
Iterator set (size_t i, size_t j, const Type &value)
 
Iterator insert (size_t i, size_t j, const Type &value)
 
void erase (size_t i, size_t j)
 
Iterator erase (size_t j, Iterator pos)
 
Iterator erase (size_t j, Iterator first, Iterator last)
 
void resize (size_t m, size_t n, bool preserve=true)
 
void reserve (size_t nonzeros)
 
void reserve (size_t j, size_t nonzeros)
 
void trim ()
 
void trim (size_t j)
 
CompressedMatrixtranspose ()
 
CompressedMatrixctranspose ()
 
template<typename Other >
CompressedMatrixscale (const Other &scalar)
 
template<typename Other >
CompressedMatrixscaleDiagonal (Other scalar)
 
void swap (CompressedMatrix &sm) noexcept
 
Iterator insert (Iterator pos, size_t i, size_t j, const Type &value)
 
size_t extendCapacity () const noexcept
 
void reserveElements (size_t nonzeros)
 
Lookup functions
Iterator find (size_t i, size_t j)
 
Iterator lowerBound (size_t i, size_t j)
 
Iterator upperBound (size_t i, size_t j)
 
Low-level utility functions
void append (size_t i, size_t j, const Type &value, bool check=false)
 
void finalize (size_t j)
 
Expression template evaluation functions
template<typename Other >
bool canAlias (const Other *alias) const noexcept
 
template<typename Other >
bool isAliased (const Other *alias) const noexcept
 
bool canSMPAssign () const noexcept
 
template<typename MT , bool SO>
void assign (const DenseMatrix< MT, SO > &rhs)
 
template<typename MT >
void assign (const SparseMatrix< MT, true > &rhs)
 
template<typename MT >
void assign (const SparseMatrix< MT, false > &rhs)
 
template<typename MT , bool SO>
void addAssign (const DenseMatrix< MT, SO > &rhs)
 
template<typename MT , bool SO>
void addAssign (const SparseMatrix< MT, SO > &rhs)
 
template<typename MT , bool SO>
void subAssign (const DenseMatrix< MT, SO > &rhs)
 
template<typename MT , bool SO>
void subAssign (const SparseMatrix< MT, SO > &rhs)
 
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<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...
 
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<typename MT >
bool isDefault (const MatrixAccessProxy< MT > &proxy)
 Returns whether the represented element is in default state. More...
 
template<typename MT >
bool isReal (const MatrixAccessProxy< MT > &proxy)
 Returns whether the matrix element represents a real number. More...
 
template<typename MT >
bool isZero (const MatrixAccessProxy< MT > &proxy)
 Returns whether the represented element is 0. More...
 
template<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 T1 , typename T2 , bool SO>
bool operator== (const SparseMatrix< T1, false > &lhs, const SparseMatrix< T2, false > &rhs)
 Equality operator for the comparison of two row-major sparse matrices. More...
 
template<typename T1 , typename T2 , bool SO>
bool operator== (const SparseMatrix< T1, true > &lhs, const SparseMatrix< T2, true > &rhs)
 Equality operator for the comparison of two column-major sparse matrices. More...
 
template<typename T1 , typename T2 , bool SO>
bool operator== (const SparseMatrix< T1, SO > &lhs, const SparseMatrix< T2,!SO > &rhs)
 Equality operator for the comparison of two sparse matrices with different storage order. More...
 
template<typename T1 , bool SO1, typename T2 , bool SO2>
bool operator!= (const SparseMatrix< T1, SO1 > &lhs, const SparseMatrix< T2, SO2 > &rhs)
 Inequality operator for the comparison of two sparse matrices. More...
 
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<typename MT , bool SO>
bool isSymmetric (const SparseMatrix< MT, SO > &sm)
 Checks if the given sparse matrix is symmetric. More...
 
template<typename MT , bool SO>
bool isHermitian (const SparseMatrix< MT, SO > &sm)
 Checks if the given sparse matrix is Hermitian. More...
 
template<typename MT , bool SO>
bool isUniform (const SparseMatrix< MT, SO > &sm)
 Checks if the given sparse matrix is a uniform matrix. More...
 
template<typename MT , bool SO>
bool isLower (const SparseMatrix< MT, SO > &sm)
 Checks if the given sparse matrix is a lower triangular matrix. More...
 
template<typename MT , bool SO>
bool isUniLower (const SparseMatrix< MT, SO > &sm)
 Checks if the given sparse matrix is a lower unitriangular matrix. More...
 
template<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<typename MT , bool SO>
bool isUpper (const SparseMatrix< MT, SO > &sm)
 Checks if the given sparse matrix is an upper triangular matrix. More...
 
template<typename MT , bool SO>
bool isUniUpper (const SparseMatrix< MT, SO > &sm)
 Checks if the given sparse matrix is an upper unitriangular matrix. More...
 
template<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<typename MT , bool SO>
bool isDiagonal (const SparseMatrix< MT, SO > &sm)
 Checks if the give sparse matrix is diagonal. More...
 
template<typename MT , bool SO>
bool isIdentity (const SparseMatrix< MT, SO > &sm)
 Checks if the give sparse matrix is an identity matrix. More...
 
template<typename MT , bool SO>
const ElementType_< MT > min (const SparseMatrix< MT, SO > &sm)
 Returns the smallest element of the sparse matrix. More...
 
template<typename MT , bool SO>
const ElementType_< MT > max (const SparseMatrix< MT, SO > &sm)
 Returns the largest element of the sparse matrix. More...
 
SparseVector operators
template<typename T1 , bool TF1, typename T2 , bool TF2>
bool operator== (const SparseVector< T1, TF1 > &lhs, const SparseVector< T2, TF2 > &rhs)
 Equality operator for the comparison of two sparse vectors. More...
 
template<typename T1 , bool TF1, typename T2 , bool TF2>
bool operator!= (const SparseVector< T1, TF1 > &lhs, const SparseVector< T2, TF2 > &rhs)
 Inequality operator for the comparison of two sparse vectors. More...
 
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<typename VT , bool TF>
bool isUniform (const SparseVector< VT, TF > &sv)
 Checks if the given sparse vector is a uniform vector. More...
 
template<typename VT , bool TF>
const ElementType_< VT > sqrLength (const SparseVector< VT, TF > &sv)
 Calculation of the sparse vector square length $|\vec{a}|^2$. More...
 
template<typename VT , bool TF>
auto length (const SparseVector< VT, TF > &sv) -> decltype(sqrt(sqrLength(~sv)))
 Calculation of the sparse vector length $|\vec{a}|$. More...
 
template<typename VT , bool TF>
const ElementType_< VT > min (const SparseVector< VT, TF > &sv)
 Returns the smallest element of the sparse vector. More...
 
template<typename VT , bool TF>
const ElementType_< VT > max (const SparseVector< VT, TF > &sv)
 Returns the largest element of the sparse 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<typename VT >
bool isDefault (const VectorAccessProxy< VT > &proxy)
 Returns whether the represented element is in default state. More...
 
template<typename VT >
bool isReal (const VectorAccessProxy< VT > &proxy)
 Returns whether the vector element represents a real number. More...
 
template<typename VT >
bool isZero (const VectorAccessProxy< VT > &proxy)
 Returns whether the represented element is 0. More...
 
template<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...
 
Vector operators
template<typename T1 , typename T2 >
const MultTrait_< ElementType_< T1 >, ElementType_< T2 > > inner (const Vector< T1, false > &lhs, const Vector< T2, false > &rhs)
 Multiplication operator for the scalar product (dot/inner product) of two vectors ( $ s=(\vec{a},\vec{b}) $). More...
 
template<typename T1 , typename T2 >
const MultTrait_< ElementType_< T1 >, ElementType_< T2 > > inner (const Vector< T1, false > &lhs, const Vector< T2, true > &rhs)
 Multiplication operator for the scalar product (dot/inner product) of two vectors ( $ s=(\vec{a},\vec{b}) $). More...
 
template<typename T1 , typename T2 >
const MultTrait_< ElementType_< T1 >, ElementType_< T2 > > inner (const Vector< T1, true > &lhs, const Vector< T2, false > &rhs)
 Multiplication operator for the scalar product (dot/inner product) of two vectors ( $ s=(\vec{a},\vec{b}) $). More...
 
template<typename T1 , typename T2 >
const MultTrait_< ElementType_< T1 >, ElementType_< T2 > > inner (const Vector< T1, true > &lhs, const Vector< T2, true > &rhs)
 Multiplication operator for the scalar product (dot/inner product) of two vectors ( $ s=(\vec{a},\vec{b}) $). More...
 
template<typename T1 , bool TF1, typename T2 , bool TF2>
const MultTrait_< ElementType_< T1 >, ElementType_< T2 > > dot (const Vector< T1, TF1 > &lhs, const Vector< T2, TF2 > &rhs)
 Multiplication operator for the scalar product (dot/inner product) of two vectors ( $ s=(\vec{a},\vec{b}) $). More...
 
template<typename T1 , bool TF1, typename T2 , bool TF2>
const MultTrait_< ElementType_< T1 >, ElementType_< T2 > > operator, (const Vector< T1, TF1 > &lhs, const Vector< T2, TF2 > &rhs)
 Multiplication operator for the scalar product (dot/inner product) of two vectors ( $ s=(\vec{a},\vec{b}) $). More...
 
template<typename T1 , typename T2 >
const MultTrait_< ElementType_< T1 >, ElementType_< T2 > > outer (const Vector< T1, false > &lhs, const Vector< T2, false > &rhs)
 Multiplication operator for the outer product of two vectors ( $ s=(\vec{a},\vec{b}) $). More...
 
template<typename T1 , typename T2 >
const MultTrait_< ElementType_< T1 >, ElementType_< T2 > > outer (const Vector< T1, false > &lhs, const Vector< T2, true > &rhs)
 Multiplication operator for the outer product of two vectors ( $ s=(\vec{a},\vec{b}) $). More...
 
template<typename T1 , typename T2 >
const MultTrait_< ElementType_< T1 >, ElementType_< T2 > > outer (const Vector< T1, true > &lhs, const Vector< T2, false > &rhs)
 Multiplication operator for the outer product of two vectors ( $ s=(\vec{a},\vec{b}) $). More...
 
template<typename T1 , typename T2 >
const MultTrait_< ElementType_< T1 >, ElementType_< T2 > > outer (const Vector< T1, true > &lhs, const Vector< T2, true > &rhs)
 Multiplication operator for the outer product of two vectors ( $ s=(\vec{a},\vec{b}) $). More...
 
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...
 
Column operators
template<typename MT , bool SO, bool DF, bool SF>
void reset (Column< MT, SO, DF, SF > &column)
 Resetting the given column. More...
 
template<typename MT , bool SO, bool DF, bool SF>
void clear (Column< MT, SO, DF, SF > &column)
 Clearing the given column. More...
 
template<typename MT , bool SO, bool DF, bool SF>
bool isDefault (const Column< MT, SO, DF, SF > &column)
 Returns whether the given column is in default state. More...
 
template<typename MT , bool SO, bool DF, bool SF>
bool isIntact (const Column< MT, SO, DF, SF > &column) noexcept
 Returns whether the invariants of the given column are intact. More...
 
template<typename MT , bool SO, bool DF, bool SF>
bool isSame (const Column< MT, SO, DF, SF > &a, const Column< MT, SO, DF, SF > &b) noexcept
 Returns whether the two given columns represent the same observable state. More...
 
Row operators
template<typename MT , bool SO, bool DF, bool SF>
void reset (Row< MT, SO, DF, SF > &row)
 Resetting the given row. More...
 
template<typename MT , bool SO, bool DF, bool SF>
void clear (Row< MT, SO, DF, SF > &row)
 Clearing the given row. More...
 
template<typename MT , bool SO, bool DF, bool SF>
bool isDefault (const Row< MT, SO, DF, SF > &row)
 Returns whether the given row is in default state. More...
 
template<typename MT , bool SO, bool DF, bool SF>
bool isIntact (const Row< MT, SO, DF, SF > &row) noexcept
 Returns whether the invariants of the given row are intact. More...
 
template<typename MT , bool SO, bool DF, bool SF>
bool isSame (const Row< MT, SO, DF, SF > &a, const Row< MT, SO, DF, SF > &b) noexcept
 Returns whether the two given rows represent the same observable state. More...
 
Submatrix operators
template<typename MT , bool AF, bool SO, bool DF>
void reset (Submatrix< MT, AF, SO, DF > &sm)
 Resetting the given submatrix. More...
 
template<typename MT , bool AF, bool SO, bool DF>
void reset (Submatrix< MT, AF, SO, DF > &sm, size_t i)
 Reset the specified row/column of the given submatrix. More...
 
template<typename MT , bool AF, bool SO, bool DF>
void clear (Submatrix< MT, AF, SO, DF > &sm)
 Clearing the given matrix. More...
 
template<typename MT , bool AF, bool SO, bool DF>
bool isDefault (const Submatrix< MT, AF, SO, DF > &sm)
 Returns whether the given submatrix is in default state. More...
 
template<typename MT , bool AF, bool SO, bool DF>
bool isIntact (const Submatrix< MT, AF, SO, DF > &sm) noexcept
 Returns whether the invariants of the given submatrix are intact. More...
 
template<typename MT , bool AF, bool SO, bool DF>
bool isSymmetric (const Submatrix< MT, AF, SO, DF > &sm)
 Checks if the given submatrix is symmetric. More...
 
template<typename MT , bool AF, bool SO, bool DF>
bool isHermitian (const Submatrix< MT, AF, SO, DF > &sm)
 Checks if the given submatrix is Hermitian. More...
 
template<typename MT , bool AF, bool SO, bool DF>
bool isLower (const Submatrix< MT, AF, SO, DF > &sm)
 Checks if the given submatrix is a lower triangular matrix. More...
 
template<typename MT , bool AF, bool SO, bool DF>
bool isUniLower (const Submatrix< MT, AF, SO, DF > &sm)
 Checks if the given submatrix is a lower unitriangular matrix. More...
 
template<typename MT , bool AF, bool SO, bool DF>
bool isStrictlyLower (const Submatrix< MT, AF, SO, DF > &sm)
 Checks if the given submatrix is a strictly lower triangular matrix. More...
 
template<typename MT , bool AF, bool SO, bool DF>
bool isUpper (const Submatrix< MT, AF, SO, DF > &sm)
 Checks if the given submatrix is an upper triangular matrix. More...
 
template<typename MT , bool AF, bool SO, bool DF>
bool isUniUpper (const Submatrix< MT, AF, SO, DF > &sm)
 Checks if the given submatrix is an upper unitriangular matrix. More...
 
template<typename MT , bool AF, bool SO, bool DF>
bool isStrictlyUpper (const Submatrix< MT, AF, SO, DF > &sm)
 Checks if the given submatrix is a strictly upper triangular matrix. More...
 
template<typename MT , bool AF, bool SO, bool DF>
bool isSame (const Submatrix< MT, AF, SO, DF > &a, const Matrix< MT, SO > &b) noexcept
 Returns whether the given matrix and submatrix represent the same observable state. More...
 
template<typename MT , bool AF, bool SO, bool DF>
bool isSame (const Matrix< MT, SO > &a, const Submatrix< MT, AF, SO, DF > &b) noexcept
 Returns whether the given matrix and submatrix represent the same observable state. More...
 
template<typename MT , bool AF, bool SO, bool DF>
bool isSame (const Submatrix< MT, AF, SO, DF > &a, const Submatrix< MT, AF, SO, DF > &b) noexcept
 Returns whether the two given submatrices represent the same observable state. More...
 
Subvector operators
template<typename VT , bool AF, bool TF, bool DF>
void reset (Subvector< VT, AF, TF, DF > &sv)
 Resetting the given subvector. More...
 
template<typename VT , bool AF, bool TF, bool DF>
void clear (Subvector< VT, AF, TF, DF > &sv)
 Clearing the given subvector. More...
 
template<typename VT , bool AF, bool TF, bool DF>
bool isDefault (const Subvector< VT, AF, TF, DF > &sv)
 Returns whether the given subvector is in default state. More...
 
template<typename VT , bool AF, bool TF, bool DF>
bool isIntact (const Subvector< VT, AF, TF, DF > &sv) noexcept
 Returns whether the invariants of the given subvector vector are intact. More...
 
template<typename VT , bool AF, bool TF, bool DF>
bool isSame (const Subvector< VT, AF, TF, DF > &a, const Vector< VT, TF > &b) noexcept
 Returns whether the given vector and subvector represent the same observable state. More...
 
template<typename VT , bool AF, bool TF, bool DF>
bool isSame (const Vector< VT, TF > &a, const Subvector< VT, AF, TF, DF > &b) noexcept
 Returns whether the given vector and subvector represent the same observable state. More...
 
template<typename VT , bool AF, bool TF, bool DF>
bool isSame (const Subvector< VT, AF, TF, DF > &a, const Subvector< VT, AF, TF, DF > &b) noexcept
 Returns whether the two given subvectors represent the same observable state. 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...
 
InputString operators
bool IsFileName (const InputString &s)
 Tests for a valid file name. More...
 
std::ostream & operator<< (std::ostream &os, const InputString &str)
 Global output operator for the InputString class. More...
 
std::istream & operator>> (std::istream &is, InputString &str)
 Global input operator for the InputString class. 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...
 
PtrIterator operators
template<typename TypeL , typename TypeR >
bool operator== (const PtrIterator< TypeL > &lhs, const PtrIterator< TypeR > &rhs)
 Equality comparison between two PtrIterator objects. More...
 
template<typename TypeL , typename TypeR >
bool operator!= (const PtrIterator< TypeL > &lhs, const PtrIterator< TypeR > &rhs)
 Inequality comparison between two PtrIterator objects. More...
 
template<typename TypeL , typename TypeR >
bool operator< (const PtrIterator< TypeL > &lhs, const PtrIterator< TypeR > &rhs)
 Less-than comparison between two PtrIterator objects. More...
 
template<typename TypeL , typename TypeR >
bool operator> (const PtrIterator< TypeL > &lhs, const PtrIterator< TypeR > &rhs)
 Greater-than comparison between two PtrIterator objects. More...
 
template<typename TypeL , typename TypeR >
bool operator<= (const PtrIterator< TypeL > &lhs, const PtrIterator< TypeR > &rhs)
 Less-or-equal-than comparison between two PtrIterator objects. More...
 
template<typename TypeL , typename TypeR >
bool operator>= (const PtrIterator< TypeL > &lhs, const PtrIterator< TypeR > &rhs)
 Greater-or-equal-than comparison between two PtrIterator objects. More...
 
PtrVector operators
template<typename T , typename D , typename G >
bool operator== (const PtrVector< T, D, G > &lhs, const PtrVector< T, D, G > &rhs)
 Equality comparison between two pointer vectors. More...
 
template<typename T , typename D , typename G >
bool operator!= (const PtrVector< T, D, G > &lhs, const PtrVector< T, D, G > &rhs)
 Inequality comparison between two pointer vectors. More...
 
template<typename T , typename D , typename G >
void swap (PtrVector< T, D, G > &a, PtrVector< T, D, G > &b) noexcept
 Swapping the contents of two pointer vectors. More...
 
Random number functions
template<typename T >
rand ()
 Random number function. More...
 
template<typename T , typename... Args>
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...
 
System clock setup functions
SystemClockID theSystemClock ()
 Returns a handle to the Blaze system clock. 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 size_t cacheSize = 3145728UL
 Cache size of the target architecture.This setting specifies the available cache size in Byte of the used target architecture. Several algorithms use this setting for an optimized evaluation. More...
 
constexpr bool usePadding = true
 Configuration of the padding of dense vectors and matrices.This configuration switch enables/disables the padding of dense vectors and matrices. Padding is used by the Blaze library in order to achieve maximum performance for both dense vector and matrix operations. Due to padding, the proper alignment of data elements can be guaranteed and the need for remainder loops is minimized. In case the switch is set to true, padding is enabled for all native dense vectors and matrices. If the switch is set to false, padding is generally disabled. More...
 
constexpr bool useStreaming = true
 Configuration of the streaming behavior.For large vectors and matrices non-temporal stores can provide a significant performance advantage of about 20%. However, this advantage is only in effect in case the memory bandwidth of the target architecture is maxed out. If the target architecture's memory bandwidth cannot be exhausted the use of non-temporal stores can decrease performance instead of increasing it. More...
 
constexpr bool useOptimizedKernels = true
 Configuration switch for optimized kernels.This configuration switch enables/disables all optimized compute kernels of the Blaze library, including all vectorized and data type depending kernels. In case the switch is set to true the optimized kernels are used whenever possible. In case the switch is set to false all optimized kernels are not used, even if it would be possible. More...
 
constexpr bool defaultStorageOrder = rowMajor
 The default storage order for all matrices of the Blaze library.This value specifies the default storage order for all matrices of the Blaze library. In case no explicit storage order is specified with the according matrix type, this setting is used. More...
 
constexpr size_t DMATDVECMULT_USER_THRESHOLD = 4000000UL
 Row-major dense matrix/dense vector multiplication threshold.This setting 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. More...
 
constexpr size_t TDMATDVECMULT_USER_THRESHOLD = 62500UL
 Column-major dense matrix/dense vector multiplication threshold.This setting 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. More...
 
constexpr size_t TDVECDMATMULT_USER_THRESHOLD = 62500UL
 Dense Vector/row-major dense matrix multiplication threshold.This setting 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. More...
 
constexpr size_t TDVECTDMATMULT_USER_THRESHOLD = 4000000UL
 Dense Vector/column-major dense matrix multiplication threshold.This setting 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. More...
 
constexpr size_t DMATDMATMULT_USER_THRESHOLD = 10000UL
 Row-major dense matrix/row-major dense matrix multiplication threshold.This setting 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 of the target 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 target matrix is smaller, the Blaze kernels are used. More...
 
constexpr size_t DMATTDMATMULT_USER_THRESHOLD = 10000UL
 Row-major dense matrix/column-major dense matrix multiplication threshold.This setting 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 of the target 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 target matrix is smaller, the Blaze kernels are used. More...
 
constexpr size_t TDMATDMATMULT_USER_THRESHOLD = 10000UL
 Column-major dense matrix/row-major dense matrix multiplication threshold.This setting 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 of the target 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 target matrix is smaller, the Blaze kernels are used. More...
 
constexpr size_t TDMATTDMATMULT_USER_THRESHOLD = 10000UL
 Column-major dense matrix/column-major dense matrix multiplication threshold.This setting 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 of the target 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 target matrix is smaller, the Blaze kernels are used. More...
 
constexpr size_t DMATSMATMULT_USER_THRESHOLD = 2500UL
 Row-major dense matrix/row-major sparse matrix multiplication threshold.This setting 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. More...
 
constexpr size_t TDMATSMATMULT_USER_THRESHOLD = 2500UL
 Column-major dense matrix/row-major sparse matrix multiplication threshold.This setting 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. More...
 
constexpr size_t TSMATDMATMULT_USER_THRESHOLD = 10000UL
 Column-major sparse matrix/row-major dense matrix multiplication threshold.This setting 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. More...
 
constexpr size_t TSMATTDMATMULT_USER_THRESHOLD = 22500UL
 Column-major sparse matrix/column-major dense matrix multiplication threshold.This setting 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. More...
 
constexpr size_t SMP_DVECASSIGN_USER_THRESHOLD = 38000UL
 SMP dense vector assignment threshold.This threshold 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. More...
 
constexpr size_t SMP_DVECDVECADD_USER_THRESHOLD = 38000UL
 SMP dense vector/dense vector addition threshold.This threshold 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. More...
 
constexpr size_t SMP_DVECDVECSUB_USER_THRESHOLD = 38000UL
 SMP dense vector/dense vector subtraction threshold.This threshold 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. More...
 
constexpr size_t SMP_DVECDVECMULT_USER_THRESHOLD = 38000UL
 SMP dense vector/dense vector multiplication threshold.This threshold 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. More...
 
constexpr size_t SMP_DVECDVECDIV_USER_THRESHOLD = 38000UL
 SMP dense vector/dense vector division threshold.This threshold 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. More...
 
constexpr size_t SMP_DVECSCALARMULT_USER_THRESHOLD = 51000UL
 SMP dense vector/scalar multiplication/division threshold.This threshold 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. More...
 
constexpr size_t SMP_DMATDVECMULT_USER_THRESHOLD = 330UL
 SMP row-major dense matrix/dense vector multiplication threshold.This threshold 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. More...
 
constexpr size_t SMP_TDMATDVECMULT_USER_THRESHOLD = 360UL
 SMP column-major dense matrix/dense vector multiplication threshold.This threshold 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. More...
 
constexpr size_t SMP_TDVECDMATMULT_USER_THRESHOLD = 370UL
 SMP dense vector/row-major dense matrix multiplication threshold.This threshold 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. More...
 
constexpr size_t SMP_TDVECTDMATMULT_USER_THRESHOLD = 340UL
 SMP dense vector/column-major dense matrix multiplication threshold.This threshold 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. More...
 
constexpr size_t SMP_DMATSVECMULT_USER_THRESHOLD = 480UL
 SMP row-major dense matrix/sparse vector multiplication threshold.This threshold 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. More...
 
constexpr size_t SMP_TDMATSVECMULT_USER_THRESHOLD = 910UL
 SMP column-major dense matrix/sparse vector multiplication threshold.This threshold 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. More...
 
constexpr size_t SMP_TSVECDMATMULT_USER_THRESHOLD = 910UL
 SMP sparse vector/row-major dense matrix multiplication threshold.This threshold 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. More...
 
constexpr size_t SMP_TSVECTDMATMULT_USER_THRESHOLD = 480UL
 SMP sparse vector/column-major dense matrix multiplication threshold.This threshold 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. More...
 
constexpr size_t SMP_SMATDVECMULT_USER_THRESHOLD = 600UL
 SMP row-major sparse matrix/dense vector multiplication threshold.This threshold 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. More...
 
constexpr size_t SMP_TSMATDVECMULT_USER_THRESHOLD = 1250UL
 SMP column-major sparse matrix/dense vector multiplication threshold.This threshold 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. More...
 
constexpr size_t SMP_TDVECSMATMULT_USER_THRESHOLD = 1190UL
 SMP dense vector/row-major sparse matrix multiplication threshold.This threshold 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. More...
 
constexpr size_t SMP_TDVECTSMATMULT_USER_THRESHOLD = 530UL
 SMP dense vector/column-major sparse matrix multiplication threshold.This threshold 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. More...
 
constexpr size_t SMP_SMATSVECMULT_USER_THRESHOLD = 260UL
 SMP row-major sparse matrix/sparse vector multiplication threshold.This threshold 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. More...
 
constexpr size_t SMP_TSMATSVECMULT_USER_THRESHOLD = 2160UL
 SMP column-major sparse matrix/sparse vector multiplication threshold.This threshold 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. More...
 
constexpr size_t SMP_TSVECSMATMULT_USER_THRESHOLD = 2160UL
 SMP sparse vector/row-major sparse matrix multiplication threshold.This threshold 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. More...
 
constexpr size_t SMP_TSVECTSMATMULT_USER_THRESHOLD = 260UL
 SMP sparse vector/column-major sparse matrix multiplication threshold.This threshold 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. More...
 
constexpr size_t SMP_DMATASSIGN_USER_THRESHOLD = 48400UL
 SMP dense matrix assignment threshold.This threshold 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. More...
 
constexpr size_t SMP_DMATDMATADD_USER_THRESHOLD = 36100UL
 SMP row-major dense matrix/row-major dense matrix addition threshold.This threshold 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. More...
 
constexpr size_t SMP_DMATTDMATADD_USER_THRESHOLD = 30625UL
 SMP row-major dense matrix/column-major dense matrix addition threshold.This threshold 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. More...
 
constexpr size_t SMP_DMATDMATSUB_USER_THRESHOLD = 36100UL
 SMP row-major dense matrix/row-major dense matrix subtraction threshold.This threshold 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. More...
 
constexpr size_t SMP_DMATTDMATSUB_USER_THRESHOLD = 30625UL
 SMP row-major dense matrix/column-major dense matrix subtraction threshold.This threshold 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. More...
 
constexpr size_t SMP_DMATSCALARMULT_USER_THRESHOLD = 48400UL
 SMP dense matrix/scalar multiplication/division threshold.This threshold 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. More...
 
constexpr size_t SMP_DMATDMATMULT_USER_THRESHOLD = 3025UL
 SMP row-major dense matrix/row-major dense matrix multiplication threshold.This threshold 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. More...
 
constexpr size_t SMP_DMATTDMATMULT_USER_THRESHOLD = 3025UL
 SMP row-major dense matrix/column-major dense matrix multiplication threshold.This threshold 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. More...
 
constexpr size_t SMP_TDMATDMATMULT_USER_THRESHOLD = 3025UL
 SMP column-major dense matrix/row-major dense matrix multiplication threshold.This threshold 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. More...
 
constexpr size_t SMP_TDMATTDMATMULT_USER_THRESHOLD = 3025UL
 SMP column-major dense matrix/column-major dense matrix multiplication threshold.This threshold 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. More...
 
constexpr size_t SMP_DMATSMATMULT_USER_THRESHOLD = 4096UL
 SMP row-major dense matrix/row-major sparse matrix multiplication threshold.This threshold 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. More...
 
constexpr size_t SMP_DMATTSMATMULT_USER_THRESHOLD = 4624UL
 SMP row-major dense matrix/column-major sparse matrix multiplication threshold.This threshold 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. More...
 
constexpr size_t SMP_TDMATSMATMULT_USER_THRESHOLD = 8100UL
 SMP column-major dense matrix/row-major sparse matrix multiplication threshold.This threshold 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. More...
 
constexpr size_t SMP_TDMATTSMATMULT_USER_THRESHOLD = 8100UL
 SMP column-major dense matrix/column-major sparse matrix multiplication threshold.This threshold 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. More...
 
constexpr size_t SMP_SMATDMATMULT_USER_THRESHOLD = 7744UL
 SMP row-major sparse matrix/row-major dense matrix multiplication threshold.This threshold 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. More...
 
constexpr size_t SMP_SMATTDMATMULT_USER_THRESHOLD = 5184UL
 SMP row-major sparse matrix/column-major dense matrix multiplication threshold.This threshold 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. More...
 
constexpr size_t SMP_TSMATDMATMULT_USER_THRESHOLD = 4356UL
 SMP column-major sparse matrix/row-major dense matrix multiplication threshold.This threshold 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. More...
 
constexpr size_t SMP_TSMATTDMATMULT_USER_THRESHOLD = 4356UL
 SMP column-major sparse matrix/column-major dense matrix multiplication threshold.This threshold 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. More...
 
constexpr size_t SMP_SMATSMATMULT_USER_THRESHOLD = 22500UL
 SMP row-major sparse matrix/row-major sparse matrix multiplication threshold.This threshold 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. More...
 
constexpr size_t SMP_SMATTSMATMULT_USER_THRESHOLD = 19600UL
 SMP row-major sparse matrix/column-major sparse matrix multiplication threshold.This threshold 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. More...
 
constexpr size_t SMP_TSMATSMATMULT_USER_THRESHOLD = 19600UL
 SMP column-major sparse matrix/row-major sparse matrix multiplication threshold.This threshold 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. More...
 
constexpr size_t SMP_TSMATTSMATMULT_USER_THRESHOLD = 22500UL
 SMP column-major sparse matrix/column-major sparse matrix multiplication threshold.This threshold 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. More...
 
constexpr size_t SMP_DVECTDVECMULT_USER_THRESHOLD = 84100UL
 SMP dense vector/dense vector outer product threshold.This threshold 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. More...
 
constexpr bool defaultTransposeFlag = columnVector
 The default transpose flag for all vectors of the Blaze library.This value specifies the default transpose flag for all vector of the Blaze library. In case no explicit transpose flag is specified with the according vector type, this setting is used. More...
 
const 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.
 
const bool unaligned = false
 Alignment flag for unaligned vectors and matrices.Via this flag it is possible to specify subvectors, submatrices, custom vectors and matrices as unaligned. The following example demonstrates the setup of an unaligned subvector: More...
 
const bool aligned = true
 Alignment flag for aligned vectors and matrices.Via this flag it is possible to specify subvectors, submatrices, custom vectors and matrices as aligned. The following example demonstrates the setup of an aligned subvector: More...
 
const real_t M_E = 2.7182818284590452353602874713526625
 Definition of the mathematical constant $ e $.
 
const real_t M_LOG2E = 1.4426950408889634073599246810018921
 Definition of the mathematical constant $ \log_2 e $.
 
const real_t M_LOG10E = 0.4342944819032518276511289189166051
 Definition of the mathematical constant $ \log_{10} e $.
 
const real_t M_LN2 = 0.6931471805599453094172321214581766
 Definition of the mathematical constant $ \ln 2 $.
 
const real_t M_LN10 = 2.3025850929940456840179914546843642
 Definition of the mathematical constant $ \ln 10 $.
 
const real_t M_PI = 3.1415926535897932384626433832795029
 Definition of the mathematical constant $ \pi $.
 
const real_t M_SQRT2 = 1.4142135623730950488016887242096981
 Definition of the mathematical constant $ \sqrt{2} $.
 
const real_t M_SQRT3 = 1.7320508075688772935274463415058724
 Definition of the mathematical constant $ \sqrt{3} $.
 
const 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.
 
const 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.
 
const 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 row vector of size 7: More...
 
const 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 row vector of size 7: More...
 
const bool rowMajor = false
 Storage order flag for row-major matrices. More...
 
const bool columnMajor = true
 Storage order flag for column-major matrices. More...
 
const bool columnVector = false
 Transpose flag for column vectors. More...
 
const bool rowVector = true
 Transpose flag for row vectors. 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_USER_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_USER_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_USER_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_USER_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_USER_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_USER_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_USER_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_USER_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_USER_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_USER_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_USER_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_USER_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_USER_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_DVECDVECADD_DEBUG_THRESHOLD = 32UL
 SMP dense vector/dense vector addition threshold.This debug value is used instead of the blaze::SMP_DVECDVECADD_USER_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_USER_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_USER_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_USER_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_DVECSCALARMULT_DEBUG_THRESHOLD = 32UL
 SMP dense vector/scalar multiplication/division threshold.This debug value is used instead of the blaze::SMP_DVECSCALARMULT_USER_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_DMATDVECMULT_DEBUG_THRESHOLD = 16UL
 SMP row-major dense matrix/dense vector multiplication threshold.This debug value is used instead of the blaze::SMP_DMATDVECMULT_USER_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_USER_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_USER_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_USER_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_USER_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_USER_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_USER_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_USER_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_USER_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_USER_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_USER_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_USER_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_USER_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_USER_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_USER_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_USER_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_USER_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_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_USER_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_USER_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_USER_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_USER_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_DMATSCALARMULT_DEBUG_THRESHOLD = 256UL
 SMP dense matrix/scalar multiplication/division threshold.This debug value is used instead of the blaze::SMP_DMATSCALARMULT_USER_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_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_USER_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_USER_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_USER_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_USER_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_USER_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_USER_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_USER_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_USER_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_USER_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_USER_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_USER_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_USER_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_USER_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_USER_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_USER_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_USER_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_DVECTDVECMULT_DEBUG_THRESHOLD = 256UL
 SMP dense vector/dense vector outer product threshold.This debug value is used instead of the blaze::SMP_DVECTDVECMULT_USER_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.
 
Member variables
size_t m_
 The current number of rows of the sparse matrix.
 
size_t n_
 The current number of columns of the sparse matrix.
 
size_t capacity_
 The current capacity of the pointer array.
 
Iteratorbegin_
 Pointers to the first non-zero element of each column.
 
Iteratorend_
 Pointers one past the last non-zero element of each column.
 
static const Type zero_
 Neutral element for accesses to zero elements.
 

Detailed Description

Namespace of the Blaze C++ math library.

Typedef Documentation

template<typename T >
using blaze::BaseType_ = typedef typename T::BaseType

Alias declaration for nested BaseType type definitions.The BaseType_ 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 Type1 = typename T::BaseType;
using Type2 = BaseType_<T>;
template<typename T >
using blaze::CompositeType_ = typedef typename T::CompositeType

Alias declaration for nested CompositeType type definitions.The CompositeType_ 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 Type1 = typename T::CompositeType;
using Type2 = CompositeType_<T>;
template<typename T >
using blaze::ConstIterator_ = typedef typename T::ConstIterator

Alias declaration for nested ConstIterator type definitions.The ConstIterator_ 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 Type1 = typename T::ConstIterator;
using Type2 = ConstIterator_<T>;
template<typename T >
using blaze::ConstPointer_ = typedef typename T::ConstPointer

Alias declaration for nested ConstPointer type definitions.The ConstPointer_ 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 Type1 = typename T::ConstPointer;
using Type2 = ConstPointer_<T>;
template<typename T >
using blaze::ConstReference_ = typedef typename T::ConstReference

Alias declaration for nested ConstReference type definitions.The ConstReference_ 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 Type1 = typename T::ConstReference;
using Type2 = ConstReference_<T>;
template<typename T >
using blaze::ElementType_ = typedef typename T::ElementType

Alias declaration for nested ElementType type definitions.The ElementType_ 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 Type1 = typename T::ElementType;
using Type2 = ElementType_<T>;
template<typename T >
using blaze::Iterator_ = typedef typename T::Iterator

Alias declaration for nested Iterator type definitions.The Iterator_ 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 Type1 = typename T::Iterator;
using Type2 = Iterator_<T>;
template<typename T >
using blaze::LeftOperand_ = typedef typename T::LeftOperand

Alias declaration for nested LeftOperand type definitions.The LeftOperand_ 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 Type1 = typename T::LeftOperand;
using Type2 = LeftOperand_<T>;
template<typename T >
using blaze::Operand_ = typedef typename T::Operand

Alias declaration for nested Operand type definitions.The Operand_ 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 Type1 = typename T::Operand;
using Type2 = Operand_<T>;
template<typename T >
using blaze::OppositeType_ = typedef typename T::OppositeType

Alias declaration for nested OppositeType type definitions.The OppositeType_ 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 Type1 = typename T::OppositeType;
using Type2 = OppositeType_<T>;
template<typename T >
using blaze::Pointer_ = typedef typename T::Pointer

Alias declaration for nested Pointer type definitions.The Pointer_ 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 Type1 = typename T::Pointer;
using Type2 = Pointer_<T>;
template<typename T >
using blaze::Reference_ = typedef typename T::Reference

Alias declaration for nested Reference type definitions.The Reference_ 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 Type1 = typename T::Reference;
using Type2 = Reference_<T>;
template<typename T >
using blaze::RepresentedType_ = typedef typename T::RepresentedType

Alias declaration for nested RepresentedType type definitions.The RepresentedType_ 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 Type1 = typename T::RepresentedType;
using Type2 = RepresentedType_<T>;
template<typename T >
using blaze::ResultType_ = typedef typename T::ResultType

Alias declaration for nested ResultType type definitions.The ResultType_ 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 Type1 = typename T::ResultType;
using Type2 = ResultType_<T>;
template<typename T >
using blaze::ReturnType_ = typedef typename T::ReturnType

Alias declaration for nested ReturnType type definitions.The ReturnType_ 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 Type1 = typename T::ReturnType;
using Type2 = ReturnType_<T>;
template<typename T >
using blaze::RightOperand_ = typedef typename T::RightOperand

Alias declaration for nested RightOperand type definitions.The RightOperand_ 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 Type1 = typename T::RightOperand;
using Type2 = RightOperand_<T>;
template<typename T >
using blaze::SIMDType_ = typedef typename T::SIMDType

Alias declaration for nested SIMDType type definitions.The SIMDType_ 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 Type1 = typename T::SIMDType;
using Type2 = SIMDType_<T>;
template<typename T >
using blaze::TransposeType_ = typedef typename T::TransposeType

Alias declaration for nested TransposeType type definitions.The TransposeType_ 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 Type1 = typename T::TransposeType;
using Type2 = TransposeType_<T>;
template<typename T >
using blaze::ValueType_ = typedef typename T::ValueType

Alias declaration for nested ValueType type definitions.The ValueType_ 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 Type1 = typename T::ValueType;
using Type2 = ValueType_<T>;

Enumeration Type Documentation

anonymous enum : bool

Compilation flag for SMP assignments.

The smpAssignable compilation flag indicates whether the matrix can be used in SMP (shared memory parallel) assignments (both on the left-hand and right-hand side of the assignment).

Function Documentation

template<typename T >
DisableIf_< IsBuiltin<T>, T* > blaze::allocate ( size_t  size)

Aligned array allocation for user-specific class types.

Parameters
sizeThe number of elements of the given type to allocate.
Returns
Pointer to the first element of the aligned array.
Exceptions
std::bad_allocAllocation 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.

template<typename To , typename From >
To blaze::convert ( const From &  from)
inline

Conversion from type From to type To.

Parameters
fromThe data value to be converted.
Returns
The converted data value.

The convert function transforms the data value from of type From to the data type To. The syntax for this operation is similar to the C++ cast operators. For example, in order to convert a built-in integer value integer to a std::string, use

convert<std::string>( integer )

The convert function supports any possible type conversion in the most efficient way.

template<typename T >
DisableIf_< IsBuiltin<T> > blaze::deallocate ( T *  address)

Deallocation of memory for user-specific class types.

Parameters
addressThe address of the first element of the array to be deallocated.
Returns
void

This function deallocates the given memory that was previously allocated via the allocate() function.

template<typename Archive , typename VT , bool TF>
void blaze::deserialize ( Archive archive,
Vector< VT, TF > &  vec 
)

Deserializes a vector from the given archive.

Parameters
archiveThe archive to be read from.
vecThe vector to be deserialized.
Returns
void
Exceptions
std::runtime_errorVector 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.

template<typename Archive , typename MT , bool SO>
void blaze::deserialize ( Archive archive,
Matrix< MT, SO > &  mat 
)

Deserializes a matrix from the given archive.

Parameters
archiveThe archive to be read from.
matThe matrix to be deserialized.
Returns
void
Exceptions
std::runtime_errorMatrix 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.

template<typename T >
BLAZE_ALWAYS_INLINE const EnableIf_< And< IsIntegral<T>, HasSize<T,2UL> > , If_< IsSigned<T>, SIMDint16, SIMDuint16 > > blaze::loada ( const T *  address)
noexcept

Loads a vector of 2-byte integral values.

Parameters
addressThe first integral value to be loaded.
Returns
The loaded vector of integral values.

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

template<typename T >
BLAZE_ALWAYS_INLINE const EnableIf_< And< IsIntegral<T>, HasSize<T,2UL> > , If_< IsSigned<T>, SIMDcint16, SIMDcuint16 > > blaze::loada ( const complex< T > *  address)
noexcept

Loads a vector of 2-byte integral complex values.

Parameters
addressThe first integral complex value to be loaded.
Returns
The loaded vector of integral complex values.

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

template<typename T >
BLAZE_ALWAYS_INLINE const EnableIf_< And< IsIntegral<T>, HasSize<T,4UL> > , If_< IsSigned<T>, SIMDint32, SIMDuint32 > > blaze::loada ( const T *  address)
noexcept

Loads a vector of 4-byte integral values.

Parameters
addressThe first integral value to be loaded.
Returns
The loaded vector of integral values.

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

template<typename T >
BLAZE_ALWAYS_INLINE const EnableIf_< And< IsIntegral<T>, HasSize<T,4UL> > , If_< IsSigned<T>, SIMDcint32, SIMDcuint32 > > blaze::loada ( const complex< T > *  address)
noexcept

Loads a vector of 4-byte integral complex values.

Parameters
addressThe first integral complex value to be loaded.
Returns
The loaded vector of integral complex values.

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

template<typename T >
BLAZE_ALWAYS_INLINE const EnableIf_< And< IsIntegral<T>, HasSize<T,8UL> > , If_< IsSigned<T>, SIMDint64, SIMDuint64 > > blaze::loada ( const T *  address)
noexcept

Loads a vector of 8-byte integral values.

Parameters
addressThe first integral value to be loaded.
Returns
The loaded vector of integral values.

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

template<typename T >
BLAZE_ALWAYS_INLINE const EnableIf_< And< IsIntegral<T>, HasSize<T,8UL> > , If_< IsSigned<T>, SIMDcint64, SIMDcuint64 > > blaze::loada ( const complex< T > *  address)
noexcept

Loads a vector of 8-byte integral complex values.

Parameters
addressThe first integral complex value to be loaded.
Returns
The loaded vector of integral complex values.

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

template<typename T >
BLAZE_ALWAYS_INLINE const EnableIf_< And< IsIntegral<T>, HasSize<T,2UL> > , If_< IsSigned<T>, SIMDint16, SIMDuint16 > > blaze::loadu ( const T *  address)
noexcept

Loads a vector of 2-byte integral values.

Parameters
addressThe first integral value to be loaded.
Returns
The loaded vector of integral values.

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.

template<typename T >
BLAZE_ALWAYS_INLINE const EnableIf_< And< IsIntegral<T>, HasSize<T,2UL> > , If_< IsSigned<T>, SIMDcint16, SIMDcuint16 > > blaze::loadu ( const complex< T > *  address)
noexcept

Loads a vector of 2-byte integral complex values.

Parameters
addressThe first integral complex value to be loaded.
Returns
The loaded vector of integral complex values.

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.

template<typename T >
BLAZE_ALWAYS_INLINE const EnableIf_< And< IsIntegral<T>, HasSize<T,4UL> > , If_< IsSigned<T>, SIMDint32, SIMDuint32 > > blaze::loadu ( const T *  address)
noexcept

Loads a vector of 4-byte integral values.

Parameters
addressThe first integral value to be loaded.
Returns
The loaded vector of integral values.

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.

template<typename T >
BLAZE_ALWAYS_INLINE const EnableIf_< And< IsIntegral<T>, HasSize<T,4UL> > , If_< IsSigned<T>, SIMDcint32, SIMDcuint32 > > blaze::loadu ( const complex< T > *  address)
noexcept

Loads a vector of 4-byte integral complex values.

Parameters
addressThe first integral complex value to be loaded.
Returns
The loaded vector of integral complex values.

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.

template<typename T >
BLAZE_ALWAYS_INLINE const EnableIf_< And< IsIntegral<T>, HasSize<T,8UL> > , If_< IsSigned<T>, SIMDint64, SIMDuint64 > > blaze::loadu ( const T *  address)
noexcept

Loads a vector of 8-byte integral values.

Parameters
addressThe first integral value to be loaded.
Returns
The loaded vector of integral values.

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.

template<typename T >
BLAZE_ALWAYS_INLINE const EnableIf_< And< IsIntegral<T>, HasSize<T,8UL> > , If_< IsSigned<T>, SIMDcint64, SIMDcuint64 > > blaze::loadu ( const complex< T > *  address)
noexcept

Loads a vector of 8-byte integral complex values.

Parameters
addressThe first integral complex value to be loaded.
Returns
The loaded vector of integral complex values.

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.

template<typename VT , bool TF>
const SVecScalarMultExpr<VT,ElementType_<VT>,TF> blaze::normalize ( const SparseVector< VT, TF > &  vec)
inline

Normalization of the sparse vector ( $|\vec{a}|=1$).

Parameters
vecThe given sparse vector.
Returns
The normalized result vector.

This function represents the normalization of a sparse vector:

// ... Resizing and initialization
a = normalize( a );

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.

template<typename VT , bool TF>
const DVecScalarMultExpr<VT,ElementType_<VT>,TF> blaze::normalize ( const DenseVector< VT, TF > &  vec)
inline

Normalization of the dense vector ( $|\vec{a}|=1$).

Parameters
vecThe given dense vector.
Returns
The normalized result vector.

This function represents the normalization of a dense vector:

// ... Resizing and initialization
a = normalize( a );

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.

template<typename T1 , typename T2 >
bool blaze::operator!= ( const UnsignedValue< T1 > &  lhs,
const UnsignedValue< T2 > &  rhs 
)
inline

Inequality comparison between two UnsignedValue objects.

Parameters
lhsThe left-hand side UnsignedValue wrapper.
rhsThe right-hand side UnsignedValue wrapper.
Returns
true if the two values are not equal, true if they are equal.
template<typename T1 , typename T2 >
bool blaze::operator!= ( const AlignedAllocator< T1 > &  lhs,
const AlignedAllocator< T2 > &  rhs 
)
inlinenoexcept

Inequality comparison between two AlignedAllocator objects.

Parameters
lhsThe left-hand side aligned allocator.
rhsThe right-hand side aligned allocator.
Returns
false.
template<typename TypeL , typename TypeR >
bool blaze::operator!= ( const PtrIterator< TypeL > &  lhs,
const PtrIterator< TypeR > &  rhs 
)
inline

Inequality comparison between two PtrIterator objects.

Parameters
lhsThe left-hand side pointer iterator.
rhsThe right-hand side pointer iterator.
Returns
true if the iterators don't point to the same element, false if they do.
template<typename T1 , bool AF1, typename T2 , bool AF2>
bool blaze::operator!= ( const DenseIterator< T1, AF1 > &  lhs,
const DenseIterator< T2, AF2 > &  rhs 
)
inlinenoexcept

Inequality comparison between two DenseIterator objects.

Parameters
lhsThe left-hand side iterator.
rhsThe right-hand side iterator.
Returns
true if the iterators don't refer to the same element, false if they do.
template<typename T , typename D , typename G >
bool blaze::operator!= ( const PtrVector< T, D, G > &  lhs,
const PtrVector< T, D, G > &  rhs 
)
inline

Inequality comparison between two pointer vectors.

Parameters
lhsThe left hand side pointer vector.
rhsThe right hand side pointer vector.
Returns
true if the two pointer vectors are inequal, false if they are not.
template<typename T1 , typename T2 >
EnableIf_< TDVecDVecMultExprHelper<T1,T2> , const MultTrait_< ElementType_<T1>, ElementType_<T2> > > blaze::operator* ( const DenseVector< T1, true > &  lhs,
const DenseVector< T2, false > &  rhs 
)
inline

SIMD optimized multiplication operator for the scalar product (inner product) of two dense vectors ( $ s=\vec{a}*\vec{b} $).

Parameters
lhsThe left-hand side dense vector for the inner product.
rhsThe right-hand side dense vector for the inner product.
Returns
The scalar product.
Exceptions
std::invalid_argumentVector sizes do not match.

This operator represents the scalar product (inner product) of two dense vectors:

blaze::double res;
// ... Resizing and initialization
res = trans(a) * b;

The operator returns a scalar value of the higher-order element type of the two involved vector element types T1::ElementType and T2::ElementType. Both vector types T1 and T2 as well as the two element types T1::ElementType and T2::ElementType have to be supported by the MultTrait class template.
In case the current sizes of the two given vectors don't match, a std::invalid_argument is thrown.

template<typename Type , bool AF>
const DenseIterator< Type, AF > blaze::operator+ ( const DenseIterator< Type, AF > &  it,
ptrdiff_t  inc 
)
inlinenoexcept

Addition between a DenseIterator and an integral value.

Parameters
itThe iterator to be incremented.
incThe number of elements the iterator is incremented.
Returns
The incremented iterator.
template<typename Type , bool AF>
const DenseIterator< Type, AF > blaze::operator+ ( ptrdiff_t  inc,
const DenseIterator< Type, AF > &  it 
)
inlinenoexcept

Addition between an integral value and a DenseIterator.

Parameters
incThe number of elements the iterator is incremented.
itThe iterator to be incremented.
Returns
The incremented iterator.
template<typename Type , bool AF>
const DenseIterator< Type, AF > blaze::operator- ( const DenseIterator< Type, AF > &  it,
ptrdiff_t  dec 
)
inlinenoexcept

Subtraction between a DenseIterator and an integral value.

Parameters
itThe iterator to be decremented.
decThe number of elements the iterator is decremented.
Returns
The decremented iterator.
template<typename Type , bool AF>
ptrdiff_t blaze::operator- ( const DenseIterator< Type, AF > &  lhs,
const DenseIterator< Type, AF > &  rhs 
)
inlinenoexcept

Calculating the number of elements between two DenseIterator objects.

Parameters
lhsThe left-hand side iterator.
rhsThe right-hand side iterator.
Returns
The number of elements between the two iterators.
template<typename T1 , typename T2 >
bool blaze::operator< ( const UnsignedValue< T1 > &  lhs,
const UnsignedValue< T2 > &  rhs 
)
inline

Less-than comparison between two UnsignedValue objects.

Parameters
lhsThe left-hand side UnsignedValue wrapper.
rhsThe right-hand side UnsignedValue wrapper.
Returns
true if the left value is less than the right value, false if not.
template<typename TypeL , typename TypeR >
bool blaze::operator< ( const PtrIterator< TypeL > &  lhs,
const PtrIterator< TypeR > &  rhs 
)
inline

Less-than comparison between two PtrIterator objects.

Parameters
lhsThe left-hand side pointer iterator.
rhsThe right-hand side pointer iterator.
Returns
true if the left-hand side iterator points to a lower element, false if not.
template<typename T1 , bool AF1, typename T2 , bool AF2>
bool blaze::operator< ( const DenseIterator< T1, AF1 > &  lhs,
const DenseIterator< T2, AF2 > &  rhs 
)
inlinenoexcept

Less-than comparison between two DenseIterator objects.

Parameters
lhsThe left-hand side iterator.
rhsThe right-hand side iterator.
Returns
true if the left-hand side iterator is smaller, false if not.
template<typename T >
std::ostream & blaze::operator<< ( std::ostream &  os,
const UnsignedValue< T > &  uv 
)
inline

Global output operator for the UnsignedValue wrapper.

Parameters
osReference to the output stream.
uvReference to a UnsignedValue object.
Returns
The output stream.
template<typename T1 , typename T2 >
bool blaze::operator<= ( const UnsignedValue< T1 > &  lhs,
const UnsignedValue< T2 > &  rhs 
)
inline

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

Parameters
lhsThe left-hand side UnsignedValue wrapper.
rhsThe right-hand side UnsignedValue wrapper.
Returns
true if the left value is less or equal than the right value, false if not.
template<typename A , typename T >
bool blaze::operator<= ( const NegativeAccuracy< A > &  ,
const T &  rhs 
)
inline

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

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

This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.

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

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

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

This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.

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

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

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

This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.

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

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

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

This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.

template<typename TypeL , typename TypeR >
bool blaze::operator<= ( const PtrIterator< TypeL > &  lhs,
const PtrIterator< TypeR > &  rhs 
)
inline

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

Parameters
lhsThe left-hand side pointer iterator.
rhsThe right-hand side pointer iterator.
Returns
true if the left-hand side iterator points to a lower or the same element, false if not.
template<typename T1 , bool AF1, typename T2 , bool AF2>
bool blaze::operator<= ( const DenseIterator< T1, AF1 > &  lhs,
const DenseIterator< T2, AF2 > &  rhs 
)
inlinenoexcept

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

Parameters
lhsThe left-hand side iterator.
rhsThe right-hand side iterator.
Returns
true if the left-hand side iterator is less or equal, false if not.
template<typename T1 , typename T2 >
bool blaze::operator== ( const UnsignedValue< T1 > &  lhs,
const UnsignedValue< T2 > &  rhs 
)
inline

Equality comparison between two UnsignedValue objects.

Parameters
lhsThe left-hand side UnsignedValue wrapper.
rhsThe right-hand side UnsignedValue wrapper.
Returns
true if the two values are equal, false if not.
template<typename T1 , typename T2 >
bool blaze::operator== ( const AlignedAllocator< T1 > &  lhs,
const AlignedAllocator< T2 > &  rhs 
)
inlinenoexcept

Equality comparison between two AlignedAllocator objects.

Parameters
lhsThe left-hand side aligned allocator.
rhsThe right-hand side aligned allocator.
Returns
true.
template<typename TypeL , typename TypeR >
bool blaze::operator== ( const PtrIterator< TypeL > &  lhs,
const PtrIterator< TypeR > &  rhs 
)
inline

Equality comparison between two PtrIterator objects.

Parameters
lhsThe left-hand side pointer iterator.
rhsThe right-hand side pointer iterator.
Returns
true if the iterators point to the same element, false if not.
template<typename T1 , bool AF1, typename T2 , bool AF2>
bool blaze::operator== ( const DenseIterator< T1, AF1 > &  lhs,
const DenseIterator< T2, AF2 > &  rhs 
)
inlinenoexcept

Equality comparison between two DenseIterator objects.

Parameters
lhsThe left-hand side iterator.
rhsThe right-hand side iterator.
Returns
true if the iterators refer to the same element, false if not.
template<typename T , typename D , typename G >
bool blaze::operator== ( const PtrVector< T, D, G > &  lhs,
const PtrVector< T, D, G > &  rhs 
)
inline

Equality comparison between two pointer vectors.

Parameters
lhsThe left hand side pointer vector.
rhsThe right hand side pointer vector.
Returns
true if the two pointer vectors are equal, false if they are not.
template<typename T1 , typename T2 >
bool blaze::operator> ( const UnsignedValue< T1 > &  lhs,
const UnsignedValue< T2 > &  rhs 
)
inline

Greater-than comparison between two UnsignedValue objects.

Parameters
lhsThe left-hand side UnsignedValue wrapper.
rhsThe right-hand side UnsignedValue wrapper.
Returns
true if the left value if greater than the right value, false if not.
template<typename TypeL , typename TypeR >
bool blaze::operator> ( const PtrIterator< TypeL > &  lhs,
const PtrIterator< TypeR > &  rhs 
)
inline

Greater-than comparison between two PtrIterator objects.

Parameters
lhsThe left-hand side pointer iterator.
rhsThe right-hand side pointer iterator.
Returns
true if the left-hand side iterator points to a higher element, false if not.
template<typename T1 , bool AF1, typename T2 , bool AF2>
bool blaze::operator> ( const DenseIterator< T1, AF1 > &  lhs,
const DenseIterator< T2, AF2 > &  rhs 
)
inlinenoexcept

Greater-than comparison between two DenseIterator objects.

Parameters
lhsThe left-hand side iterator.
rhsThe right-hand side iterator.
Returns
true if the left-hand side iterator is greater, false if not.
template<typename T1 , typename T2 >
bool blaze::operator>= ( const UnsignedValue< T1 > &  lhs,
const UnsignedValue< T2 > &  rhs 
)
inline

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

Parameters
lhsThe left-hand side UnsignedValue wrapper.
rhsThe right-hand side UnsignedValue wrapper.
Returns
true if the left value is greater or equal than the right value, false if not.
template<typename A , typename T >
bool blaze::operator>= ( const NegativeAccuracy< A > &  ,
const T &  rhs 
)
inline

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

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

This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.

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

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

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

This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.

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

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

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

This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.

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

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

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

This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.

template<typename TypeL , typename TypeR >
bool blaze::operator>= ( const PtrIterator< TypeL > &  lhs,
const PtrIterator< TypeR > &  rhs 
)
inline

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

Parameters
lhsThe left-hand side pointer iterator.
rhsThe right-hand side pointer iterator.
Returns
true if the left-hand side iterator points to a higher or the same element, false if not.
template<typename T1 , bool AF1, typename T2 , bool AF2>
bool blaze::operator>= ( const DenseIterator< T1, AF1 > &  lhs,
const DenseIterator< T2, AF2 > &  rhs 
)
inlinenoexcept

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

Parameters
lhsThe left-hand side iterator.
rhsThe right-hand side iterator.
Returns
true if the left-hand side iterator is greater or equal, false if not.
template<typename T >
std::istream & blaze::operator>> ( std::istream &  is,
UnsignedValue< T > &  uv 
)

Global input operator for the UnsignedValue wrapper.

Parameters
isReference to the input stream.
uvReference to a UnsignedValue object.
Returns
The input stream.

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.

template<typename D , typename S >
size_t blaze::polymorphicCount ( S *const *  first,
S *const *  last 
)
inline

Counts the pointer to objects with dynamic type D.

Parameters
firstIterator to the first pointer of the pointer range.
lastIterator to the pointer one past the last pointer of the pointer range.
Returns
The number of objects with dynamic type D.

This function traverses the range $ [first,last) $ of pointers to objects with static type S and counts all polymorphic pointers to objects of dynamic type D. Note that in case D is not a type derived from S, a compile time error is created!

template<typename D , typename S >
S* const* blaze::polymorphicFind ( S *const *  first,
S *const *  last 
)
inline

Finds the next pointer to an object with dynamic type D.

Parameters
firstIterator to the first pointer of the pointer range.
lastIterator to the pointer one past the last pointer of the pointer range.
Returns
The next pointer to an object with dynamic type D.

This function traverses the range $ [first,last) $ of pointers to objects with static type S until it finds the next polymorphic pointer to an object of dynamic type D. Note that in case D is not a type derived from S, a compile time error is created!

template<typename Archive , typename VT , bool TF>
void blaze::serialize ( Archive archive,
const Vector< VT, TF > &  vec 
)

Serializes the given vector and writes it to the archive.

Parameters
archiveThe archive to be written.
vecThe vector to be serialized.
Returns
void
Exceptions
std::runtime_errorError during serialization.

The serialize() function converts the given vector into a portable, binary representation. The following example demonstrates the (de-)serialization process of vectors:

// Serialization of both vectors
{
// ... Resizing and initialization
// Creating an archive that writes into a the file "vectors.blaze"
blaze::Archive<std::ofstream> archive( "vectors.blaze" );
// Serialization of both vectors into the same archive. Note that d lies before s!
archive << d << s;
}
// Reconstitution of both vectors
{
// ... Resizing and initialization
// Creating an archive that reads from the file "vectors.blaze"
blaze::Archive<std::ofstream> archive( "vectors.blaze" );
// Reconstituting the former d vector into d1. Note that it is possible to reconstitute
// the vector into a differrent kind of vector (StaticVector -> DynamicVector), but that
// the type of elements has to be the same.
archive >> d1;
// Reconstituting the former s vector into d2. Note that is is even possible to reconstitute
// a sparse vector as a dense vector (also the reverse is possible) and that a column vector
// can be reconstituted as row vector (and vice versa). Note however that also in this case
// the type of elements is the same!
archive >> d2
}

As the example demonstrates, the vector serialization offers an enormous flexibility. However, several actions result in errors:

  • vectors cannot be reconstituted as matrices (and vice versa)
  • the element type of the serialized and reconstituted vector must match, which means that on the source and destination platform the general type (signed/unsigned integral or floating point) and the size of the type must be exactly the same
  • when reconstituting a StaticVector, its size must match the size of the serialized vector

In case an error is encountered during (de-)serialization, a std::runtime_exception is thrown.

template<typename Archive , typename MT , bool SO>
void blaze::serialize ( Archive archive,
const Matrix< MT, SO > &  mat 
)

Serializes the given matrix and writes it to the archive.

Parameters
archiveThe archive to be written.
matThe matrix to be serialized.
Returns
void
Exceptions
std::runtime_errorMatrix 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:

// Serialization of both matrices
{
// ... Resizing and initialization
// Creating an archive that writes into a the file "matrices.blaze"
blaze::Archive<std::ofstream> archive( "matrices.blaze" );
// Serialization of both matrices into the same archive. Note that D lies before S!
archive << D << S;
}
// Reconstitution of both matrices
{
// ... Resizing and initialization
// Creating an archive that reads from the file "matrices.blaze"
blaze::Archive<std::ofstream> archive( "matrices.blaze" );
// Reconstituting the former D matrix into D1. Note that it is possible to reconstitute
// the matrix into a differrent kind of matrix (StaticMatrix -> DynamicMatrix), but that
// the type of elements has to be the same.
archive >> D1;
// Reconstituting the former S matrix into D2. Note that is is even possible to reconstitute
// a sparse matrix as a dense matrix (also the reverse is possible) and that a column-major
// matrix can be reconstituted as row-major matrix (and vice versa). Note however that also
// in this case the type of elements is the same!
archive >> D2
}

As the example demonstrates, the matrix serialization offers an enormous flexibility. However, several actions result in errors:

  • matrices cannot be reconstituted as vectors (and vice versa)
  • the element type of the serialized and reconstituted matrix must match, which means that on the source and destination platform the general type (signed/unsigned integral or floating point) and the size of the type must be exactly the same
  • when reconstituting a StaticMatrix, the number of rows and columns must match those of the serialized matrix

In case an error is encountered during (de-)serialization, a std::runtime_exception is thrown.

template<typename T >
BLAZE_ALWAYS_INLINE const EnableIf_< And< IsIntegral<T>, HasSize<T,2UL> > , If_< IsSigned<T>, SIMDint16, SIMDuint16 > > blaze::set ( value)
noexcept

Sets all values in the vector to the given 2-byte integral value.

Parameters
valueThe given 2-byte integral value.
Returns
The set vector of 2-byte integral values.
template<typename T >
BLAZE_ALWAYS_INLINE const EnableIf_< And< IsIntegral<T>, HasSize<T,2UL> > , If_< IsSigned<T>, SIMDcint16, SIMDcuint16 > > blaze::set ( complex< T >  value)
noexcept

Sets all values in the vector to the given 2-byte integral complex value.

Parameters
valueThe given 2-byte integral complex value.
Returns
The set vector of 2-byte integral complex values.
template<typename T >
BLAZE_ALWAYS_INLINE const EnableIf_< And< IsIntegral<T>, HasSize<T,4UL> > , If_< IsSigned<T>, SIMDint32, SIMDuint32 > > blaze::set ( value)
noexcept

Sets all values in the vector to the given 4-byte integral value.

Parameters
valueThe given 4-byte integral value.
Returns
The set vector of 4-byte integral values.
template<typename T >
BLAZE_ALWAYS_INLINE const EnableIf_< And< IsIntegral<T>, HasSize<T,4UL> > , If_< IsSigned<T>, SIMDcint32, SIMDcuint32 > > blaze::set ( complex< T >  value)
noexcept

Sets all values in the vector to the given 4-byte integral complex value.

Parameters
valueThe given 4-byte integral complex value.
Returns
The set vector of 4-byte integral complex values.
template<typename T >
BLAZE_ALWAYS_INLINE const EnableIf_< And< IsIntegral<T>, HasSize<T,8UL> > , If_< IsSigned<T>, SIMDint64, SIMDuint64 > > blaze::set ( value)
noexcept

Sets all values in the vector to the given 8-byte integral value.

Parameters
valueThe given 8-byte integral value.
Returns
The set vector of 8-byte integral values.
template<typename T >
BLAZE_ALWAYS_INLINE const EnableIf_< And< IsIntegral<T>, HasSize<T,8UL> > , If_< IsSigned<T>, SIMDcint64, SIMDcuint64 > > blaze::set ( complex< T >  value)
noexcept

Sets all values in the vector to the given 8-byte integral complex value.

Parameters
valueThe given 8-byte integral complex value.
Returns
The set vector of 8-byte integral complex values.
template<typename MT1 , bool SO1, typename MT2 , bool SO2>
EnableIf_< IsSparseMatrix< MT1 > > blaze::smpAddAssign ( Matrix< MT1, SO1 > &  lhs,
const Matrix< MT2, SO2 > &  rhs 
)
inline

Default implementation of the SMP addition assignment of a matrix to a sparse matrix.

Parameters
lhsThe target left-hand side sparse matrix.
rhsThe right-hand side matrix to be added.
Returns
void

This function implements the default SMP addition assignment of a matrix to a sparse matrix.
This function must NOT be called explicitly! It is used internally for the performance optimized evaluation of expression templates. Calling this function explicitly might result in erroneous results and/or in compilation errors. Instead of using this function use the assignment operator.

template<typename VT1 , bool TF1, typename VT2 , bool TF2>
EnableIf_< IsSparseVector< VT1 > > blaze::smpAddAssign ( Vector< VT1, TF1 > &  lhs,
const Vector< VT2, TF2 > &  rhs 
)
inline

Default implementation of the SMP addition assignment of a vector to a sparse vector.

Parameters
lhsThe target left-hand side sparse vector.
rhsThe right-hand side vector to be added.
Returns
void

This function implements the default SMP addition assignment of a vector to a sparse vector.
This function must NOT be called explicitly! It is used internally for the performance optimized evaluation of expression templates. Calling this function explicitly might result in erroneous results and/or in compilation errors. Instead of using this function use the assignment operator.

template<typename VT1 , bool TF1, typename VT2 , bool TF2>
EnableIf_< IsSparseVector< VT1 > > blaze::smpAssign ( Vector< VT1, TF1 > &  lhs,
const Vector< VT2, TF2 > &  rhs 
)
inline

Default implementation of the SMP assignment of a vector to a sparse vector.

Parameters
lhsThe target left-hand side sparse vector.
rhsThe right-hand side vector to be assigned.
Returns
void

This function implements the default SMP assignment of a vector to a sparse vector.
This function must NOT be called explicitly! It is used internally for the performance optimized evaluation of expression templates. Calling this function explicitly might result in erroneous results and/or in compilation errors. Instead of using this function use the assignment operator.

template<typename MT1 , bool SO1, typename MT2 , bool SO2>
EnableIf_< IsSparseMatrix< MT1 > > blaze::smpAssign ( Matrix< MT1, SO1 > &  lhs,
const Matrix< MT2, SO2 > &  rhs 
)
inline

Default implementation of the SMP assignment of a matrix to a sparse matrix.

Parameters
lhsThe target left-hand side sparse matrix.
rhsThe right-hand side matrix to be assigned.
Returns
void

This function implements the default SMP assignment of a matrix to a sparse matrix.
This function must NOT be called explicitly! It is used internally for the performance optimized evaluation of expression templates. Calling this function explicitly might result in erroneous results and/or in compilation errors. Instead of using this function use the assignment operator.

template<typename VT1 , bool TF1, typename VT2 , bool TF2>
EnableIf_< IsSparseVector< VT1 > > blaze::smpMultAssign ( Vector< VT1, TF1 > &  lhs,
const Vector< VT2, TF2 > &  rhs 
)
inline

Default implementation of the SMP multiplication assignment of a vector to a sparse vector.

Parameters
lhsThe target left-hand side sparse vector.
rhsThe right-hand side vector to be multiplied.
Returns
void

This function implements the default SMP multiplication assignment of a vector to a sparse vector.
This function must NOT be called explicitly! It is used internally for the performance optimized evaluation of expression templates. Calling this function explicitly might result in erroneous results and/or in compilation errors. Instead of using this function use the assignment operator.

template<typename MT1 , bool SO1, typename MT2 , bool SO2>
EnableIf_< IsSparseMatrix< MT1 > > blaze::smpSubAssign ( Matrix< MT1, SO1 > &  lhs,
const Matrix< MT2, SO2 > &  rhs 
)
inline

Default implementation of the SMP subtraction assignment of a matrix to sparse matrix.

Parameters
lhsThe target left-hand side sparse matrix.
rhsThe right-hand side matrix to be subtracted.
Returns
void

This function implements the default SMP subtraction assignment of a matrix to a sparse matrix.
This function must NOT be called explicitly! It is used internally for the performance optimized evaluation of expression templates. Calling this function explicitly might result in erroneous results and/or in compilation errors. Instead of using this function use the assignment operator.

template<typename VT1 , bool TF1, typename VT2 , bool TF2>
EnableIf_< IsSparseVector< VT1 > > blaze::smpSubAssign ( Vector< VT1, TF1 > &  lhs,
const Vector< VT2, TF2 > &  rhs 
)
inline

Default implementation of the SMP subtraction assignment of a vector to a sparse vector.

Parameters
lhsThe target left-hand side sparse vector.
rhsThe right-hand side vector to be subtracted.
Returns
void

This function implements the default SMP subtraction assignment of a vector to a sparse vector.
This function must NOT be called explicitly! It is used internally for the performance optimized evaluation of expression templates. Calling this function explicitly might result in erroneous results and/or in compilation errors. Instead of using this function use the assignment operator.

template<typename T , typename D , typename G >
void blaze::swap ( PtrVector< T, D, G > &  a,
PtrVector< T, D, G > &  b 
)
inlinenoexcept

Swapping the contents of two pointer vectors.

Parameters
aThe first pointer vector to be swapped.
bThe second pointer vector to be swapped.
Returns
void
Exceptions
no-throwguarantee.
template<typename InputIterator , typename OutputIterator >
OutputIterator blaze::transfer ( InputIterator  first,
InputIterator  last,
OutputIterator  dest 
)

Transfers the elements from the given source range to the destination range.

Parameters
firstIterator to the first element of the source range.
lastIterator to the element one past the last element of the source range.
destIterator to the first element of the destination range.
Returns
Output iterator to the element one past the last copied element.

This function transfers the elements in the range $ [first,last) $ to the specified destination range. In case the elements provide a no-throw move assignment, the transfer operation is handled via move. Else the elements are copied.

Variable Documentation

const 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

\[\left(\begin{array}{*{3}{c}} 1 & 2 & 3 \\ 4 & 5 & 6 \\ \end{array}\right)\]


in case of column-major order the elements are stored in the order

\[\left(\begin{array}{*{6}{c}} 1 & 4 & 2 & 5 & 3 & 6. \\ \end{array}\right)\]

The following example demonstrates the setup of this $ 2 \times 3 $ matrix:

blaze::StaticMatrix<int,2UL,3UL,columnMajor> A( { { 1, 2, 3 }, { 4, 5, 6 } } );
const 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:

const 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

\[\left(\begin{array}{*{3}{c}} 1 & 2 & 3 \\ 4 & 5 & 6 \\ \end{array}\right)\]


in case of row-major order the elements are stored in the order

\[\left(\begin{array}{*{6}{c}} 1 & 2 & 3 & 4 & 5 & 6. \\ \end{array}\right)\]

The following example demonstrates the setup of this $ 2 \times 3 $ matrix:

blaze::StaticMatrix<int,2UL,3UL,rowMajor> A( { { 1, 2, 3 }, { 4, 5, 6 } } );
const 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: