![]() |
Namespace of the Blaze C++ math library. More...
Namespaces | |
logging | |
Namespace for the logging module. | |
solvers | |
Namespace for the solvers module. | |
threadpool | |
Namespace for the threadpool module. | |
timing | |
Namespace for the time measurement module. | |
Classes | |
struct | AbsExpr |
Base class for all absolute value expression templates.The AbsExpr class serves as a tag for all expression templates that implement an absolute value operation. All classes, that represent an absolute value 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 absolute value expression template. Only in case a class is derived from the AbsExpr base class, the IsAbsExpr type trait recognizes the class as valid absolute value expression template. More... | |
struct | AbsExprTrait |
Evaluation of the return type of an absolute value expression.Via this type trait it is possible to evaluate the return type of an absolute value 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 absolute value operation exists for the type, the resulting data type Type is set to INVALID_TYPE. 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 | 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::RemoveReference<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... | |
class | AlignedStorage |
POD data type with a fixed alignment.The AlignedStorage class template represents a POD data type with a fixed alignment. Via this class it is possible to enforce a specific, type-based alignment for static data types. The required alignment is evaluated based on the given data type T. In case T is a built-in, vectorizable data type, AlignedStorage enforces an alignment of 16 or 32 bytes, depending on the active SSE/AVX level. In all other cases, no specific alignment is enforced. 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 | And |
Compile time logical and evaluation.The And class template performs at compile time a logical and ('&&') evaluation of the up to six given compile time conditions: 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 | 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 | BaseElementType |
Evaluation of the base element type of a given data type.Via this type trait it is possible to evaluate the base (fundamental) element type at the heart of a given data type. Examples: 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 | BoxLCP |
A box linear complementarity problem (BLCP) data structure.The BoxLCP class represent a box linear complementarity problem (BLCP) of the form ![]() | |
class | CG |
A conjugate gradient solver.TODO: description TODO: Problem formulation: ![]() | |
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 | CMathTrait |
Base template for the CMathTrait class.The CMathTrait template evaluates the return type of the mathematical functions defined in the C++ header <cmath> depending on the type of the template argument. In case of an integral data type or double precision argument, the return value of the functions is double, whereas the return type is float for single precision arguments and long double for long double precision arguments. More... | |
struct | Column |
Base class for all columns.The Column class serves as a tag for all columns (i.e. dense and sparse columns). All classes that represent a column 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 column. Only in case a class is derived from the Column base class, the IsColumn type trait recognizes the class as valid column. 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... | |
class | complex |
Complex data type of the Blaze library. More... | |
class | ComplexProxy |
Proxy backend for complex types.The ComplexProxy class serves as a backend for the Proxy class. It is used in case the data type represented by the proxy is a complex number and augments the Proxy interface by the complete interface required of complex numbers. More... | |
class | CompressedMatrix |
Efficient implementation of a ![]() ![]() | |
class | CompressedVector |
Efficient implementation of an arbitrary sized sparse vector.The CompressedVector class is the representation of an arbitrarily sized sparse vector, which stores only non-zero elements of arbitrary type. The type of the elements and the transpose flag of the vector can be specified via the two template parameters: More... | |
struct | Computation |
Base class for all compute expression templates.The Computation class serves as a tag for all computational expression templates. All classes, that represent a mathematical computation (addition, subtraction, multiplication, division, absolute value calculation, ...) and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as computational expression template. Only in case a class is derived from the Computation base class, the IsComputation type trait recognizes the class as valid computational expression template. More... | |
struct | 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... | |
struct | ContactLCP |
A data structure for linear complementarity problems (LCPs) for contact mechanics.TODO. 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... | |
class | CPG |
Implementation of the conjugate projected gradient algorithm.TODO: description of the CPG solver TODO: capabilities of the CPG solver (which LCP problems, etc) TODO: known issues of the CPG solver. 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 | 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 | 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 | DenseColumn |
Reference to a specific column of a dense matrix.The DenseColumn template represents a reference to a specific column of a dense matrix primitive. The type of the dense matrix is specified via the first template parameter: 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... | |
class | DenseRow |
Reference to a specific row of a dense matrix.The DenseRow template represents a reference to a specific row of a dense matrix primitive. The type of the dense matrix is specified via the first template parameter: More... | |
class | DenseSubmatrix |
View on a specific submatrix of a dense matrix.The DenseSubmatrix template represents a view on a specific submatrix of a dense matrix primitive. The type of the dense matrix is specified via the first template parameter: More... | |
class | DenseSubvector |
View on a specific subvector of a dense vector.The DenseSubvector template represents a view on a specific subvector of a dense vector primitive. The type of the dense vector is specified via the first template parameter: 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 | 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... | |
class | DMatAbsExpr |
Expression object for the dense matrix abs() function.The DMatAbsExpr class represents the compile time expression for the calculation of the absolute value of each element of a dense matrix via the abs() function. More... | |
struct | DMatAbsExprTrait |
Evaluation of the expression type of a dense matrix absolute value operation.Via this type trait it is possible to evaluate the resulting expression type of a dense matrix absolute value operation. Given the row-major dense matrix type MT, the nested type Type corresponds to the resulting expression type. In case either 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 either 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 either 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 either 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... | |
class | DVecAbsExpr |
Expression object for the dense vector abs() function.The DVecAbsExpr class represents the compile time expression for the calculation of the absolute value of each element of a dense vector via the abs() function. More... | |
struct | DVecAbsExprTrait |
Evaluation of the expression type of a dense vector absolute value operation.Via this type trait it is possible to evaluate the resulting expression type of a dense vector absolute value operation. Given the non-transpose dense vector type VT, the nested type Type corresponds to the resulting expression type. In case either 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 | 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 either 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 either 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 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 | 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 either 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 ![]() ![]() | |
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... | |
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 | 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 enumeration 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... | |
class | GaussianElimination |
Implementation of the Gaussian elimination direct linear system solver.TODO: description TODO: Problem formulation: ![]() | |
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 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 | 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 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 | 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 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 | 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 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 | HasCyclicDependency |
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 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... | |
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 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... | |
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... | |
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 | 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 | 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... | |
class | IntrinsicTrait |
Intrinsic characteristics of data types.The IntrinsicTrait class template provides the intrinsic characteristics of a specific data type: More... | |
struct | IsAbsExpr |
Compile time check whether the given type is an absolute value expression template.This type trait class tests whether or not the given type Type is an absolute value expression template. In order to qualify as a valid absolute value expression template, the given type has to derive (publicly or privately) from the AbsExpr base class. In case the given type is a valid absolute value expression template, 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 | 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 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 | 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 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 | 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 enumeration is set to 1, the nested type definition Type is set to TrueType, and the class derives from TrueType. Otherwise value is set to 0, Type is FalseType and the class derives from FalseType. More... | |
class | IsBaseOf |
Compile time analysis of an inheritance relationship.This type trait tests for an inheritance relationship between the two types Base and Derived. If Derived is a type derived from Base or the same type as Base the value member 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 | 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 currently only supports float, double, complex<float> and complex<double> values. If the type is BLAS compatible, 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 | 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 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 | 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 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 | 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 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 | 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 enumeration is set to 1, the nested type definition Type is set to TrueType, and the class derives from TrueType. Otherwise value is set to 0, 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 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 | 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 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 | 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 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 | 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 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 | 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 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 | 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 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 | 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 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 | 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 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 | 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 enumeration is set to 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise yes is set to 0, 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 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 | 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 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 | 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 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 | 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 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 | 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 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 | 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 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 | 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 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 | IsFalse |
Compile time check whether a compile time constant expression evaluates to false.This value trait tests whether the given compile time constant C evaluates to false. In case the value is false, 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 | 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 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 | 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 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 | 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 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 | 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 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 | 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 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 | 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 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 | 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). In case the type is a lower triangular matrix type, 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 | IsMatAbsExpr |
Compile time check whether the given type is a matrix absolute value expression template.This type trait class tests whether or not the given type Type is a matrix absolute value expression template. In order to qualify as a valid matrix absolute value expression template, the given type has to derive (publicly or privately) from the MatAbsExpr base class. In case the given type is a valid matrix absolute value expression template, 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 | 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 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 | 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 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 | 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 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 | 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 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 | 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 enumeration is set to 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise yes is set to 0, 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 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 | 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 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 | 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 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 | 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 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 | 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 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 | 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 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 | 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 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 | 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 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 | 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 | 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 enumeration is set o 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 | 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 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 | IsPowerOf |
Compile time check for a power relationship of integral values to a given base.This value trait tests whether the given integral value N is a power of the base B according to the equation ![]() ![]() | |
struct | 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 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 | 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 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. 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 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 | 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 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 | 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 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 | 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 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 | 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 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 | 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 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 | IsSigned |
Compile time check for signed data types.This type trait tests whether or not the given template parameter is a signed integral data type. In case the type is a signed (possibly cv-qualified) data type, 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 | 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 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 | 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 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 | 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 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 | 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 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 | 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 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 | 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 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 | 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 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 | 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 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 | 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 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 | 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 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 | 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 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 | 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 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 | IsTrue |
Compile time check whether a compile time constant expression evaluates to true.This value trait tests whether the given compile time constant C evaluates to true. In case the value is true, 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 | 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 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 | 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 enumeration is set o 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 | 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 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 | 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). In case the type is an upper triangular matrix type, 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 | IsVecAbsExpr |
Compile time check whether the given type is a vector absolute value expression template.This type trait class tests whether or not the given type Type is a vector absolute value expression template. In order to qualify as a valid vector absolute value expression template, the given type has to derive (publicly or privately) from the VecAbsExpr base class. In case the given type is a valid vector absolute value expression template, 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 | 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 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 | 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 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 | 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 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 | 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 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 | 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 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 | 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, only signed/unsigned short, signed/unsigned int, signed/unsigned long, float, double, complex<float>, and complex<double> are considered to be vectorizable types. In case the type is vectorizable, 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 | 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 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 | 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 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 | 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 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 | 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 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 | 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 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 | 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 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 | 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 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 | 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 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 | LCP |
A linear complementarity problem (LCP) data structure.The LCP class represent a linear complementarity problem of the form ![]() | |
class | Lemke |
The Lemke pivoting algorithm for solving LCPs.TODO. 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 | 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... | |
struct | LSE |
A linear system of equations (LSE) data structure.The LSE class represent a linear system of equations of the form ![]() | |
struct | MakeSigned |
Compile time type conversion into a signed integral type.This type trait provides the feature to convert the given integral or enumeration 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 enumeration 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 | MatAbsExpr |
Base class for all matrix absolute value expression templates.The MatAbsExpr class serves as a tag for all expression templates that implement a matrix absolute value operation. All classes, that represent a matrix absolute value 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 absolute value expression template. Only in case a class is derived from the MatAbsExpr base class, the IsMatAbsExpr type trait recognizes the class as valid matrix absolute value expression template. 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 | MathTrait |
Base template for the MathTrait class. 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, ![]() 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 | MixedLCP |
A mixed linear complementarity problem (MLCP) data structure.The LCP class represent a mixed linear complementarity problem of the form. More... | |
struct | ModifiedBoxLCP |
A modified box linear complementarity problem (MBLCP) data structure.The ModifiedBoxLCP class represent a modified box linear complementarity problem (MBLCP) of the form. 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 | 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 declared private and left undefined in order to prohibit copy operations of the derived classes. . More... | |
class | NonCreatable |
Base class for non-creatable (static) classes.The NonCreatable class is intended to work as a base class for non-creatable classes, i.e. classes that cannot be instantiated and exclusively offer static functions/data. Both the standard as well as the copy constructor and the copy assignment operator are declared private and left undefinded in order to prohibit the instantiation of objects of derived classes. . More... | |
class | NonNumericProxy |
Access proxy for symmetric, square matrices with non-numeric element types.The NonNumericProxy provides controlled access to the elements of a non-const symmetric matrix with non-numeric element type (e.g. vectors or matrices). It guarantees that a modification of element ![]() ![]() ![]() | |
struct | 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 | Null |
Safe C++ NULL pointer implementation.This implementation offers a remedy for the use of the NULL pointer in C++. For this, the NULL macro is replaced by an instance of the Null class, which can only be assigned and compared with pointers and pointers-to-member. Therefore the use of NULL regains the type safety it lost in C++ due to the strict C++ type system. The NULL pointer is used exactly as before: 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... | |
struct | NumericElementType |
Evaluation of the numeric element type of a given data type.Via this type trait it is possible to evaluate the numeric (fundamental or complex) element type at the heart of a given data type. Examples: More... | |
class | NumericProxy |
Access proxy for symmetric, square matrices with numeric element types.The NumericProxy provides controlled access to the elements of a non-const symmetric matrix with numeric element type (e.g. integral values, floating point values, and complex values). It guarantees that a modification of element ![]() ![]() ![]() | |
struct | 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 the up to six given 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... | |
class | PGS |
A projected Gauss-Seidel Solver for (box) LCPs.TODO: description of the PGS solver TODO: capabilities of the PGS solver (which LCP problems, etc) TODO: known issues of the PGS solver. 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 | Quaternion |
Efficient implementation of a quaternion.Quaternions are a superior way to deal with rotations and orientations. This quaternion consists of 4 statically allocated elements, where the first element represents the real part and the three other elements represent the three imaginary parts. The naming convention of the elements is as following: More... | |
class | Rand |
Default implementation of the Rand class for integral data types.This default implementation of the Rand class creates random, integral numbers in the range ![]() | |
class | Random |
Random number generator.The Random class encapsulates the initialization of the given random number generator with a pseudo-random seed obtained by the std::time() function. Currently, the mersenne-twister mt19937 as provided by the boost library is used per default. For more information see the class description of the boost 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 enumeration is set to the number of dimensions of T. Otherwise value is set to 0. 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 RemoveCV type trait removes any pointer modifiers from the given type T. More... | |
struct | RemoveReference |
Removal of reference modifiers.The RemoveCV 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 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... | |
class | RotationMatrix |
Efficient, generic implementation of a 3x3 rotation matrix.The RotationMatrix class is the representation of a 3x3 rotation matrix with a total of 9 statically allocated elements of arbitrary type. The naming convention of the elements is as following: More... | |
struct | Row |
Base class for all rows.The Row class serves as a tag for all rows (i.e. dense and sparse rows). All classes that represent a row 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 row. Only in case a class is derived from the Row base class, the IsRow type trait recognizes the class as valid row. 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 | SelectType |
Compile time type selection.The SelectType class template selects one of the two given types T1 and T2 depending on the Select template argument. In case the Select compile time constant expression evaluates to true, the member type definition Type is set to T1. In case Select evaluates to false, Type is set to T2. 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 | 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 | 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 | SizeTrait |
Base template for the SizeTrait class.The SizeTrait class template evaluates the larger of the two given data types by use of the sizeof operator. SizeTrait defines the data types Large for the larger of the two given data types and Small for the smaller data type. In case both data types have the same size, the first given data type T1 is chosen as the large and T2 as the small data type. More... | |
class | SMatAbsExpr |
Expression object for the sparse matrix abs() function.The SMatAbsExpr class represents the compile time expression for the calculation of the absolute value of each element of a sparse matrix via the abs() function. More... | |
struct | SMatAbsExprTrait |
Evaluation of the expression type of a sparse matrix absolute value operation.Via this type trait it is possible to evaluate the resulting expression type of a sparse matrix absolute value operation. Given the row-major sparse matrix type MT, the nested type Type corresponds to the resulting expression type. In case either 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 either 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 either 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 either 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... | |
class | Solver |
Base class for all solver classes.TODO: description of the Solver class TODO: description of its functionality. More... | |
class | SparseColumn |
Reference to a specific column of a sparse matrix.The SparseColumn template represents a reference to a specific column of a sparse matrix primitive. The type of the sparse matrix is specified via the first template parameter: 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... | |
class | SparseRow |
Reference to a specific row of a sparse matrix.The SparseRow template represents a reference to a specific row of a sparse matrix primitive. The type of the sparse matrix is specified via the first template parameter: More... | |
class | SparseSubmatrix |
View on a specific submatrix of a sparse matrix.The SparseSubmatrix template represents a view on a specific submatrix of a sparse matrix primitive. The type of the sparse matrix is specified via the first template parameter: More... | |
class | SparseSubvector |
View on a specific subvector of a sparse vector.The SparseSubvector template represents a view on a specific subvector of a sparse vector primitive. The type of the sparse vector is specified via the first template parameter: 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... | |
class | sse_cdouble_t |
Intrinsic type for 64-bit double precision complex values. More... | |
class | sse_cfloat_t |
Intrinsic type for 32-bit single precision complex values. More... | |
class | sse_double_t |
Intrinsic type for 64-bit double precision floating point data values. More... | |
class | sse_float_t |
Intrinsic type for 32-bit single precision floating point data values. More... | |
class | sse_int16_t |
Intrinsic type for 16-bit integral data values. More... | |
class | sse_int32_t |
Intrinsic type for 32-bit integral data values. More... | |
class | sse_int64_t |
Intrinsic type for 64-bit integral data values. More... | |
class | sse_int8_t |
Intrinsic type for 8-bit integral data values. 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 | 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... | |
struct | Submatrix |
Base class for all submatrices.The Submatrix class serves as a tag for all submatrices (i.e. dense and sparse submatrices). All classes that represent a submatrix 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 submatrix. Only in case a class is derived from the Submatrix base class, the IsSubmatrix type trait recognizes the class as valid submatrix. 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... | |
struct | Subvector |
Base class for all subvectors.The Subvector class serves as a tag for all subvectors (i.e. dense and sparse subvectors). All classes that represent a subvector 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 subvector. Only in case a class is derived from the Subvector base class, the IsSubvector type trait recognizes the class as valid subvector. 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... | |
class | SVecAbsExpr |
Expression object for the sparse vector abs() function.The SVecAbsExpr class represents the compile time expression for the calculation of the absolute value of each element of a sparse vector via the abs() function. More... | |
struct | SVecAbsExprTrait |
Evaluation of the expression type of a sparse vector absolute value operation.Via this type trait it is possible to evaluate the resulting expression type of a sparse vector absolute value operation. Given the non-transpose sparse vector type VT, the nested type Type corresponds to the resulting expression type. In case either 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 | 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 either 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 either 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 either 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 | SymmetricMatrix |
Matrix adapter for symmetric ![]() | |
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 | TDMatAbsExprTrait |
Evaluation of the expression type of a dense matrix absolute value operation.Via this type trait it is possible to evaluate the resulting expression type of a dense matrix absolute value operation. Given the column-major dense matrix type MT, the nested type Type corresponds to the resulting expression type. In case either 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 either 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 either 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 either 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 | TDVecAbsExprTrait |
Evaluation of the expression type of a dense vector absolute value operation.Via this type trait it is possible to evaluate the resulting expression type of a dense vector absolute value operation. Given the transpose dense vector type VT, the nested type Type corresponds to the resulting expression type. In case either 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 either 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 either 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 | 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 either 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 | 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 | 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 | TSMatAbsExprTrait |
Evaluation of the expression type of a sparse matrix absolute value operation.Via this type trait it is possible to evaluate the resulting expression type of a sparse matrix absolute value operation. Given the column-major sparse matrix type MT, the nested type Type corresponds to the resulting expression type. In case either 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 either 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 either 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 either 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 | TSVecAbsExprTrait |
Evaluation of the expression type of a sparse vector absolute value operation.Via this type trait it is possible to evaluate the resulting expression type of a sparse vector absolute value operation. Given the transpose sparse vector type VT, the nested type Type corresponds to the resulting expression type. In case either 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 either 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 either 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 | 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 either 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 | 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... | |
class | UniqueArray |
Scope-limited management of dynamically allocated arrays.The UniqueArray class implements a scope-restricted, lightweight smart pointer that manages a dynamically allocated array. In contrast to other smart pointer implementations, UniqueArray is non-copyable and therefore restricted to manage arrays within a single scope, but does so so with a minimum of runtime overhead. The following example demonstrates the application of UniqueArray: More... | |
class | UniquePtr |
Scope-limited management of dynamically allocated resourses.The UniquePtr class implements a scope-restricted, lightweight smart pointer that manages a dynamically allocated resource. In contrast to other smart pointer implementations, UniquePtr is non-copyable and therefore restricted to manage resources within a single scope, but does so with a minimum of runtime overhead. The following example demonstrates the application of UniquePtr: 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 | 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 | VecAbsExpr |
Base class for all vector absolute value expression templates.The VecAbsExpr class serves as a tag for all expression templates that implement a vector absolute value operation. All classes, that represent a vector absolute value 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 absolute value expression template. Only in case a class is derived from the VecAbsExpr base class, the IsVecAbsExpr type trait recognizes the class as valid vector absolute value expression template. 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 | 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 | 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... | |
Typedefs | |
typedef double | real |
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 boost::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 boost::mt19937 mersenne-twister pseudo random number generator. For more information see the class description of the boost library: More... | |
typedef CompressedMatrix < float, false > | CMatMxNf |
MxN single precision matrix. | |
typedef CompressedMatrix < double, false > | CMatMxNd |
MxN double precision matrix. | |
typedef CompressedMatrix< real, false > | CMatMxN |
MxN matrix with system-specific precision. | |
typedef CompressedVector < float, false > | CVecNf |
Compressed single precision vector. | |
typedef CompressedVector < double, false > | CVecNd |
Compressed double precision vector. | |
typedef CompressedVector< real, false > | CVecN |
Compressed vector with system-specific precision. | |
typedef DynamicMatrix< float, false > | MatMxNf |
MxN single precision matrix. | |
typedef DynamicMatrix< double, false > | MatMxNd |
MxN double precision matrix. | |
typedef DynamicMatrix< real, false > | MatMxN |
MxN matrix with system-specific precision. | |
typedef DynamicVector< float, false > | VecNf |
N-dimensional single precision vector. | |
typedef DynamicVector< double, false > | VecNd |
N-dimensional double precision vector. | |
typedef DynamicVector< real, false > | VecN |
N-dimensional vector with system-specific precision. | |
typedef IntrinsicTrait< short > ::Type | sse_short_t |
The intrinsic data type for 'short'. | |
typedef IntrinsicTrait < unsigned short >::Type | sse_ushort_t |
The intrinsic data type for 'unsigned short'. | |
typedef IntrinsicTrait< int >::Type | sse_int_t |
The intrinsic data type for 'int'. | |
typedef IntrinsicTrait < unsigned int >::Type | sse_uint_t |
The intrinsic data type for 'unsigned int'. | |
typedef IntrinsicTrait< long > ::Type | sse_long_t |
The intrinsic data type for 'long int'. | |
typedef IntrinsicTrait < unsigned long >::Type | sse_ulong_t |
The intrinsic data type for 'unsigned long int'. | |
typedef Quaternion< real > | Quat |
Quaternion of real type. | |
typedef RotationMatrix< real > | Rot3 |
Rotation matrix of real type. | |
typedef CompressedMatrix< Type, true > | This |
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 This & | CompositeType |
Data type for composite expression templates. | |
typedef MatrixAccessProxy< This > | Reference |
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. | |
typedef StaticMatrix< float, 2UL, 2UL, false > | Mat2x2f |
2x2 single precision matrix. | |
typedef StaticMatrix< double, 2UL, 2UL, false > | Mat2x2d |
2x2 double precision matrix. | |
typedef StaticMatrix< real, 2UL, 2UL, false > | Mat2x2 |
2x2 matrix with system-specific precision. | |
typedef StaticMatrix< float, 3UL, 3UL, false > | Mat3x3f |
3x3 single precision matrix. | |
typedef StaticMatrix< double, 3UL, 3UL, false > | Mat3x3d |
3x3 double precision matrix. | |
typedef StaticMatrix< real, 3UL, 3UL, false > | Mat3x3 |
3x3 matrix with system-specific precision. | |
typedef StaticMatrix< float, 4UL, 4UL, false > | Mat4x4f |
4x4 single precision matrix. | |
typedef StaticMatrix< double, 4UL, 4UL, false > | Mat4x4d |
4x4 double precision matrix. | |
typedef StaticMatrix< real, 4UL, 4UL, false > | Mat4x4 |
4x4 matrix with system-specific precision. | |
typedef StaticMatrix< float, 5UL, 5UL, false > | Mat5x5f |
5x5 single precision matrix. | |
typedef StaticMatrix< double, 5UL, 5UL, false > | Mat5x5d |
5x5 double precision matrix. | |
typedef StaticMatrix< real, 5UL, 5UL, false > | Mat5x5 |
5x5 matrix with system-specific precision. | |
typedef StaticMatrix< float, 6UL, 6UL, false > | Mat6x6f |
6x6 single precision matrix. | |
typedef StaticMatrix< double, 6UL, 6UL, false > | Mat6x6d |
6x6 double precision matrix. | |
typedef StaticMatrix< real, 6UL, 6UL, false > | Mat6x6 |
6x6 matrix with system-specific precision. | |
typedef StaticVector< float, 2UL, false > | Vec2f |
2-dimensional single precision vector. | |
typedef StaticVector< double, 2UL, false > | Vec2d |
2-dimensional double precision vector. | |
typedef StaticVector< real, 2UL, false > | Vec2 |
2-dimensional vector with system-specific precision. | |
typedef StaticVector< float, 3UL, false > | Vec3f |
3-dimensional single precision vector. | |
typedef StaticVector< double, 3UL, false > | Vec3d |
3-dimensional double precision vector. | |
typedef StaticVector< real, 3UL, false > | Vec3 |
3-dimensional vector with system-specific precision. | |
typedef StaticVector< float, 6UL, false > | Vec6f |
6-dimensional single precision vector. | |
typedef StaticVector< double, 6UL, false > | Vec6d |
6-dimensional double precision vector. | |
typedef StaticVector< real, 6UL, false > | Vec6 |
6-dimensional vector with system-specific precision. | |
typedef unsigned char | byte |
Byte data type of the Blaze library.The byte data type is guaranteed to be an integral data type of size 1. | |
typedef boost::false_type | FalseType |
Type/value traits base class.The FalseType class is used as base class for type traits and value traits that evaluate to false. | |
typedef boost::shared_ptr < SystemClock > | SystemClockID |
Handle for the system clock of the Blaze library. | |
typedef boost::shared_ptr < const SystemClock > | ConstSystemClockID |
Handle for the system clock of the Blaze library. | |
typedef boost::true_type | TrueType |
Type traits base class.The TrueType class is used as base class for type traits and value traits that evaluate to true. | |
typedef int64_t | large_t |
The largest available signed integer data type. | |
typedef uint64_t | ularge_t |
The largest available unsigned integer data type. | |
typedef ularge_t | id_t |
Unsigned integer data type for integral IDs. | |
Enumerations | |
enum | EulerRotation { XYZs = 0, ZYXr = 1, XYXs = 2, XYXr = 3, XZYs = 4, YZXr = 5, XZXs = 6, XZXr = 7, YZXs = 8, XZYr = 9, YZYs = 10, YZYr = 11, YXZs = 12, ZXYr = 13, YXYs = 14, YXYr = 15, ZXYs = 16, YXZr = 17, ZXZs = 18, ZXZr = 19, ZYXs = 20, XYZr = 21, ZYZs = 22, ZYZr = 23 } |
Order of the Euler rotationThis codes are needed for the EulerAngles function in order to calculate the Euler angles for a specific combination of rotations. More... | |
enum | { 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 >::Type | 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 >::Type | 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 MT , bool SO> | |
const DMatAbsExpr< MT, SO > | abs (const DenseMatrix< MT, SO > &dm) |
Returns a matrix containing the absolute values of each single element of dm. 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 ( ![]() | |
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 ( ![]() | |
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 ( ![]() | |
template<typename T1 , typename T2 > | |
const DisableIf < IsMatMatMultExpr< T1 > , DMatDVecMultExpr< T1, T2 > >::Type | 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 ( ![]() | |
template<typename T1 , bool SO, typename T2 > | |
const EnableIf < IsMatMatMultExpr< T1 > , typename MultExprTrait< T1, T2 >::Type >::Type | 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 ( ![]() | |
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 T1 , bool SO, typename T2 > | |
const EnableIf< IsNumeric< T2 > , typename DivExprTrait< T1, T2 >::Type >::Type | operator/ (const DenseMatrix< T1, SO > &mat, T2 scalar) |
Division operator for the division of a dense matrix by a scalar value ( ![]() | |
template<typename MT , bool SO> | |
const DMatScalarMultExpr< MT, typename BaseElementType< MT > ::Type, SO > | operator- (const DenseMatrix< MT, SO > &dm) |
Unary minus operator for the negation of a dense matrix ( ![]() | |
template<typename T1 , bool SO, typename T2 > | |
const EnableIf< IsNumeric< T2 > , typename MultExprTrait< T1, T2 >::Type >::Type | operator* (const DenseMatrix< T1, SO > &mat, T2 scalar) |
Multiplication operator for the multiplication of a dense matrix and a scalar value ( ![]() | |
template<typename T1 , typename T2 , bool SO> | |
const EnableIf< IsNumeric< T1 > , typename MultExprTrait< T1, T2 >::Type >::Type | operator* (T1 scalar, const DenseMatrix< T2, SO > &mat) |
Multiplication operator for the multiplication of a scalar value and a dense matrix ( ![]() | |
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 ( ![]() | |
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 ( ![]() | |
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 ( ![]() | |
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 ( ![]() | |
template<typename T1 , typename T2 > | |
const DisableIf< Or < IsSymmetric< T1 > , IsMatMatMultExpr< T1 > >, DMatSVecMultExpr< T1, T2 > >::Type | 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 ( ![]() | |
template<typename T1 , typename T2 > | |
EnableIf< And< Not < IsSymmetric< T1 > >, Not < IsSymmetric< T2 > > >, const DMatTDMatAddExpr< T1, T2 > >::Type | 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 ( ![]() | |
template<typename T1 , typename T2 > | |
EnableIf< And< Not < IsSymmetric< T1 > >, Not < IsSymmetric< T2 > > >, const DMatTDMatAddExpr< T2, T1 > >::Type | 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 ( ![]() | |
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 ( ![]() | |
template<typename T1 , typename T2 > | |
EnableIf< And< Not < IsSymmetric< T1 > >, Not < IsSymmetric< T2 > > >, const DMatTDMatSubExpr< T1, T2 > >::Type | 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 ( ![]() | |
template<typename T1 , typename T2 > | |
EnableIf< And< Not < IsSymmetric< T1 > >, Not < IsSymmetric< T2 > > >, const DMatTDMatSubExpr< T1, T2 > >::Type | 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 ( ![]() | |
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 ( ![]() | |
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 ( ![]() | |
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 ( ![]() | |
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 ( ![]() | |
template<typename VT , bool TF> | |
const DVecAbsExpr< VT, TF > | abs (const DenseVector< VT, TF > &dv) |
Returns a vector containing the absolute values of each single element of dv. 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 ( ![]() | |
template<typename T1 , typename T2 > | |
const DVecDVecCrossExpr< T1, T2 > | operator% (const DenseVector< T1, false > &lhs, const DenseVector< T2, false > &rhs) |
Operator for the cross product of two dense vectors ( ![]() | |
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 ( ![]() | |
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 ( ![]() | |
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 T1 , typename T2 , bool TF> | |
const EnableIf< IsNumeric< T2 > , typename DivExprTrait< T1, T2 >::Type >::Type | operator/ (const DenseVector< T1, TF > &vec, T2 scalar) |
Division operator for the divison of a dense vector by a scalar value ( ![]() | |
template<typename VT , bool TF> | |
const DVecScalarMultExpr< VT, typename BaseElementType< VT > ::Type, TF > | operator- (const DenseVector< VT, TF > &dv) |
Unary minus operator for the negation of a dense vector ( ![]() | |
template<typename T1 , typename T2 , bool TF> | |
const EnableIf< IsNumeric< T2 > , typename MultExprTrait< T1, T2 >::Type >::Type | operator* (const DenseVector< T1, TF > &vec, T2 scalar) |
Multiplication operator for the multiplication of a dense vector and a scalar value ( ![]() | |
template<typename T1 , typename T2 , bool TF> | |
const EnableIf< IsNumeric< T1 > , typename MultExprTrait< T1, T2 >::Type >::Type | operator* (T1 scalar, const DenseVector< T2, TF > &vec) |
Multiplication operator for the multiplication of a scalar value and a dense vector ( ![]() | |
template<typename VT , bool TF> | |
const DVecScalarMultExpr< VT, typename VT::ElementType, TF > | normalize (const DenseVector< VT, TF > &vec) |
Normalization of the dense vector ( ![]() | |
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 ( ![]() | |
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 ( ![]() | |
template<typename T1 , typename T2 > | |
const DVecSVecCrossExpr< T1, T2 > | operator% (const DenseVector< T1, false > &lhs, const SparseVector< T2, false > &rhs) |
Operator for the cross product of a dense vector and a sparse vector ( ![]() | |
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 ( ![]() | |
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 ( ![]() | |
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 ( ![]() | |
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 ( ![]() | |
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 MT , bool SO> | |
const SMatAbsExpr< MT, SO > | abs (const SparseMatrix< MT, SO > &sm) |
Returns a matrix containing the absolute values of each single element of sm. 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 ( ![]() | |
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 ( ![]() | |
template<typename T1 , typename T2 > | |
const DisableIf < IsMatMatMultExpr< T1 > , SMatDVecMultExpr< T1, T2 > >::Type | 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 ( ![]() | |
template<typename T1 , bool SO, typename T2 > | |
const EnableIf < IsMatMatMultExpr< T1 > , typename MultExprTrait< T1, T2 >::Type >::Type | 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 ( ![]() | |
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 T1 , bool SO, typename T2 > | |
const EnableIf< IsNumeric< T2 > , typename DivExprTrait< T1, T2 >::Type >::Type | operator/ (const SparseMatrix< T1, SO > &mat, T2 scalar) |
Division operator for the division of a sparse matrix by a scalar value ( ![]() | |
template<typename MT , bool SO> | |
const SMatScalarMultExpr< MT, typename BaseElementType< MT > ::Type, SO > | operator- (const SparseMatrix< MT, SO > &sm) |
Unary minus operator for the negation of a sparse matrix ( ![]() | |
template<typename T1 , bool SO, typename T2 > | |
const EnableIf< IsNumeric< T2 > , typename MultExprTrait< T1, T2 >::Type >::Type | operator* (const SparseMatrix< T1, SO > &mat, T2 scalar) |
Multiplication operator for the multiplication of a sparse matrix and a scalar value ( ![]() | |
template<typename T1 , typename T2 , bool SO> | |
const EnableIf< IsNumeric< T1 > , typename MultExprTrait< T1, T2 >::Type >::Type | operator* (T1 scalar, const SparseMatrix< T2, SO > &mat) |
Multiplication operator for the multiplication of a scalar value and a sparse matrix ( ![]() | |
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 ( ![]() | |
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 ( ![]() | |
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 ( ![]() | |
template<typename T1 , typename T2 > | |
const DisableIf< Or < IsSymmetric< T1 > , IsMatMatMultExpr< T1 > >, SMatSVecMultExpr< T1, T2 > >::Type | 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 ( ![]() | |
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 ( ![]() | |
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 ( ![]() | |
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 ( ![]() | |
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 ( ![]() | |
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 ( ![]() | |
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 ( ![]() | |
template<typename VT , bool TF> | |
const SVecAbsExpr< VT, TF > | abs (const SparseVector< VT, TF > &sv) |
Returns a vector containing the absolute values of each single element of sv. More... | |
template<typename T1 , typename T2 > | |
const SVecDVecCrossExpr< T1, T2 > | operator% (const SparseVector< T1, false > &lhs, const DenseVector< T2, false > &rhs) |
Operator for the cross product of a sparse vector and a dense vector ( ![]() | |
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 ( ![]() | |
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 ( ![]() | |
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 T1 , typename T2 , bool TF> | |
const EnableIf< IsNumeric< T2 > , typename DivExprTrait< T1, T2 >::Type >::Type | operator/ (const SparseVector< T1, TF > &vec, T2 scalar) |
Division operator for the divison of a sparse vector by a scalar value ( ![]() | |
template<typename VT , bool TF> | |
const SVecScalarMultExpr< VT, typename BaseElementType< VT > ::Type, TF > | operator- (const SparseVector< VT, TF > &sv) |
Unary minus operator for the negation of a sparse vector ( ![]() | |
template<typename T1 , typename T2 , bool TF> | |
const EnableIf< IsNumeric< T2 > , typename MultExprTrait< T1, T2 >::Type >::Type | operator* (const SparseVector< T1, TF > &vec, T2 scalar) |
Multiplication operator for the multiplication of a sparse vector and a scalar value ( ![]() | |
template<typename T1 , typename T2 , bool TF> | |
const EnableIf< IsNumeric< T1 > , typename MultExprTrait< T1, T2 >::Type >::Type | operator* (T1 scalar, const SparseVector< T2, TF > &vec) |
Multiplication operator for the multiplication of a scalar value and a sparse vector ( ![]() | |
template<typename VT , bool TF> | |
const SVecScalarMultExpr< VT, typename VT::ElementType, TF > | normalize (const SparseVector< VT, TF > &vec) |
Normalization of the sparse vector ( ![]() | |
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 ( ![]() | |
template<typename T1 , typename T2 > | |
const SVecSVecCrossExpr< T1, T2 > | operator% (const SparseVector< T1, false > &lhs, const SparseVector< T2, false > &rhs) |
Operator for the cross product of two sparse vectors ( ![]() | |
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 ( ![]() | |
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 ( ![]() | |
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 ( ![]() | |
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 ( ![]() | |
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 ( ![]() | |
template<typename T1 , typename T2 > | |
const DisableIf < IsMatMatMultExpr< T1 > , TDMatDVecMultExpr< T1, T2 > >::Type | 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 ( ![]() | |
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 ( ![]() | |
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 ( ![]() | |
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 ( ![]() | |
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 ( ![]() | |
template<typename T1 , typename T2 > | |
const DisableIf < IsMatMatMultExpr< T1 > , TDMatSVecMultExpr< T1, T2 > >::Type | 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 ( ![]() | |
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 ( ![]() | |
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 ( ![]() | |
template<typename T1 , typename T2 > | |
const DisableIf < IsMatMatMultExpr< T2 > , TDVecDMatMultExpr< T1, T2 > >::Type | 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 ( ![]() | |
template<typename T1 , typename T2 , bool SO> | |
const EnableIf < IsMatMatMultExpr< T2 > , typename MultExprTrait< T1, T2 >::Type >::Type | 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 ( ![]() | |
template<typename T1 , typename T2 > | |
DisableIf < TDVecDVecMultExprHelper< T1, T2 >, const typename MultTrait < typename T1::ElementType, typename T2::ElementType > ::Type >::Type | operator* (const DenseVector< T1, true > &lhs, const DenseVector< T2, false > &rhs) |
Default multiplication operator for the scalar product (inner product) of two dense vectors ( ![]() | |
template<typename T1 , typename T2 > | |
EnableIf < TDVecDVecMultExprHelper< T1, T2 >, const typename MultTrait < typename T1::ElementType, typename T2::ElementType > ::Type >::Type | operator* (const DenseVector< T1, true > &lhs, const DenseVector< T2, false > &rhs) |
Intrinsic optimized multiplication operator for the scalar product (inner product) of two dense vectors ( ![]() | |
template<typename T1 , typename T2 > | |
const DisableIf< Or < IsSymmetric< T2 > , IsMatMatMultExpr< T2 > >, TDVecSMatMultExpr< T1, T2 > >::Type | 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 ( ![]() | |
template<typename T1 , typename T2 , bool SO> | |
const EnableIf < IsMatMatMultExpr< T2 > , typename MultExprTrait< T1, T2 >::Type >::Type | 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 ( ![]() | |
template<typename T1 , typename T2 > | |
const MultTrait< typename T1::ElementType, typename T2::ElementType >::Type | 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 ( ![]() | |
template<typename T1 , typename T2 > | |
const DisableIf < IsMatMatMultExpr< T2 > , TDVecTDMatMultExpr< T1, T2 > >::Type | 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 ( ![]() | |
template<typename T1 , typename T2 > | |
const DisableIf < IsMatMatMultExpr< T2 > , TDVecTSMatMultExpr< T1, T2 > >::Type | 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 ( ![]() | |
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 ( ![]() | |
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 ( ![]() | |
template<typename T1 , typename T2 > | |
const DisableIf< Or < IsSymmetric< T1 > , IsMatMatMultExpr< T1 > >, TSMatDVecMultExpr< T1, T2 > >::Type | 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 ( ![]() | |
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 ( ![]() | |
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 ( ![]() | |
template<typename T1 , typename T2 > | |
const DisableIf < IsMatMatMultExpr< T1 > , TSMatSVecMultExpr< T1, T2 > >::Type | 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 ( ![]() | |
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 ( ![]() | |
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 ( ![]() | |
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 ( ![]() | |
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 ( ![]() | |
template<typename T1 , typename T2 > | |
const DisableIf < IsMatMatMultExpr< T2 > , TSVecDMatMultExpr< T1, T2 > >::Type | 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 ( ![]() | |
template<typename T1 , typename T2 , bool SO> | |
const EnableIf < IsMatMatMultExpr< T2 > , typename MultExprTrait< T1, T2 >::Type >::Type | 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 ( ![]() | |
template<typename T1 , typename T2 > | |
const MultTrait< typename T1::ElementType, typename T2::ElementType >::Type | 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 ( ![]() | |
template<typename T1 , typename T2 > | |
const DisableIf < IsMatMatMultExpr< T2 > , TSVecSMatMultExpr< T1, T2 > >::Type | 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 ( ![]() | |
template<typename T1 , typename T2 , bool SO> | |
const EnableIf < IsMatMatMultExpr< T2 > , typename MultExprTrait< T1, T2 >::Type >::Type | 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 ( ![]() | |
template<typename T1 , typename T2 > | |
const MultTrait< typename T1::ElementType, typename T2::ElementType >::Type | operator* (const SparseVector< T1, true > &lhs, const SparseVector< T2, false > &rhs) |
Multiplication operator for the scalar product (inner product) of two sparse vectors ( ![]() | |
template<typename T1 , typename T2 > | |
const DisableIf< Or < IsSymmetric< T2 > , IsMatMatMultExpr< T2 > >, TSVecTDMatMultExpr< T1, T2 > >::Type | 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 ( ![]() | |
template<typename T1 , typename T2 > | |
const DisableIf< Or < IsSymmetric< T2 > , IsMatMatMultExpr< T2 > >, TSVecTSMatMultExpr< T1, T2 > >::Type | 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 ( ![]() | |
template<typename T > | |
BLAZE_ALWAYS_INLINE EnableIf < IsIntegral< T >, Load< T, sizeof(T)> >::Type::Type | load (const T *address) |
Loads a vector of integral values. More... | |
BLAZE_ALWAYS_INLINE sse_float_t | load (const float *address) |
Loads a vector of 'float' values. More... | |
BLAZE_ALWAYS_INLINE sse_double_t | load (const double *address) |
Loads a vector of 'double' values. More... | |
BLAZE_ALWAYS_INLINE sse_cfloat_t | load (const complex< float > *address) |
Loads a vector of 'complex<float>' values. More... | |
BLAZE_ALWAYS_INLINE sse_cdouble_t | load (const complex< double > *address) |
Loads a vector of 'complex<double>' values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE EnableIf < IsIntegral< T >, Loadu< T, sizeof(T)> >::Type::Type | loadu (const T *address) |
Loads a vector of integral values. More... | |
BLAZE_ALWAYS_INLINE sse_float_t | loadu (const float *address) |
Loads a vector of 'float' values. More... | |
BLAZE_ALWAYS_INLINE sse_double_t | loadu (const double *address) |
Loads a vector of 'double' values. More... | |
BLAZE_ALWAYS_INLINE sse_cfloat_t | loadu (const complex< float > *address) |
Loads a vector of 'complex<float>' values. More... | |
BLAZE_ALWAYS_INLINE sse_cdouble_t | loadu (const complex< double > *address) |
Loads a vector of 'complex<double>' values. More... | |
BLAZE_ALWAYS_INLINE int16_t | sum (const sse_int16_t &a) |
Returns the sum of all elements in the 16-bit integral intrinsic vector. More... | |
BLAZE_ALWAYS_INLINE int32_t | sum (const sse_int32_t &a) |
Returns the sum of all elements in the 32-bit integral intrinsic vector. More... | |
BLAZE_ALWAYS_INLINE int64_t | sum (const sse_int64_t &a) |
Returns the sum of all elements in the 64-bit integral intrinsic vector. More... | |
BLAZE_ALWAYS_INLINE float | sum (const sse_float_t &a) |
Returns the sum of all elements in the single precision floating point intrinsic vector. More... | |
BLAZE_ALWAYS_INLINE double | sum (const sse_double_t &a) |
Returns the sum of all elements in the double precision floating point intrinsic vector. More... | |
BLAZE_ALWAYS_INLINE complex < float > | sum (const sse_cfloat_t &a) |
Returns the sum of all elements in the single precision complex intrinsic vector. More... | |
BLAZE_ALWAYS_INLINE complex < double > | sum (const sse_cdouble_t &a) |
Returns the sum of all elements in the double precision complex intrinsic vector. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE EnableIf < IsIntegral< T >, Set< T, sizeof(T)> >::Type::Type | set (T value) |
Sets all values in the vector to the given integral value. More... | |
BLAZE_ALWAYS_INLINE sse_float_t | set (float value) |
Sets all values in the vector to the given 'float' value. More... | |
BLAZE_ALWAYS_INLINE sse_double_t | set (double value) |
Sets all values in the vector to the given 'double' value. More... | |
BLAZE_ALWAYS_INLINE sse_cfloat_t | set (const complex< float > &value) |
Sets all values in the vector to the given 'complex<float>' value. More... | |
BLAZE_ALWAYS_INLINE sse_cdouble_t | set (const complex< double > &value) |
Sets all values in the vector to the given 'complex<double>' value. More... | |
BLAZE_ALWAYS_INLINE void | setzero (sse_int8_t &value) |
Setting an integral intrinsic type with 16 8-bit data values to zero. More... | |
BLAZE_ALWAYS_INLINE void | setzero (sse_int16_t &value) |
Setting an integral intrinsic type with 8 16-bit data values to zero. More... | |
BLAZE_ALWAYS_INLINE void | setzero (sse_int32_t &value) |
Setting an integral intrinsic type with 4 32-bit data values to zero. More... | |
BLAZE_ALWAYS_INLINE void | setzero (sse_int64_t &value) |
Setting an integral intrinsic type with 2 64-bit data values to zero. More... | |
BLAZE_ALWAYS_INLINE void | setzero (sse_float_t &value) |
Setting a floating point intrinsic type with 4 32-bit single precision data values to zero. More... | |
BLAZE_ALWAYS_INLINE void | setzero (sse_double_t &value) |
Setting a floating point intrinsic type with 4 32-bit double precision data values to zero. More... | |
BLAZE_ALWAYS_INLINE void | setzero (sse_cfloat_t &value) |
Setting a floating point intrinsic type with 4 32-bit single precision complex values to zero. More... | |
BLAZE_ALWAYS_INLINE void | setzero (sse_cdouble_t &value) |
Setting a floating point intrinsic type with 4 32-bit double precision complex values to zero. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE EnableIf < IsIntegral< T > >::Type | store (T *address, const typename Store< T, sizeof(T)>::Type &value) |
Aligned store of a vector of integral values. More... | |
BLAZE_ALWAYS_INLINE void | store (float *address, const sse_float_t &value) |
Aligned store of a vector of 'float' values. More... | |
BLAZE_ALWAYS_INLINE void | store (double *address, const sse_double_t &value) |
Aligned store of a vector of 'double' values. More... | |
BLAZE_ALWAYS_INLINE void | store (complex< float > *address, const sse_cfloat_t &value) |
Aligned store of a vector of 'complex<float>' values. More... | |
BLAZE_ALWAYS_INLINE void | store (complex< double > *address, const sse_cdouble_t &value) |
Aligned store of a vector of 'complex<double>' values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE EnableIf < IsIntegral< T > >::Type | storeu (T *address, const typename Storeu< T, sizeof(T)>::Type &value) |
Unaligned store of a vector of integral values. More... | |
BLAZE_ALWAYS_INLINE void | storeu (float *address, const sse_float_t &value) |
Unaligned store of a vector of 'float' values. More... | |
BLAZE_ALWAYS_INLINE void | storeu (double *address, const sse_double_t &value) |
Unaligned store of a vector of 'double' values. More... | |
BLAZE_ALWAYS_INLINE void | storeu (complex< float > *address, const sse_cfloat_t &value) |
Unaligned store of a vector of 'complex<float>' values. More... | |
BLAZE_ALWAYS_INLINE void | storeu (complex< double > *address, const sse_cdouble_t &value) |
Unaligned store of a vector of 'complex<double>' values. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE EnableIf < IsIntegral< T > >::Type | stream (T *address, const typename Stream< T, sizeof(T)>::Type &value) |
Aligned, non-temporal store of a vector of integral values. More... | |
BLAZE_ALWAYS_INLINE void | stream (float *address, const sse_float_t &value) |
Aligned, non-temporal store of a vector of 'float' values. More... | |
BLAZE_ALWAYS_INLINE void | stream (double *address, const sse_double_t &value) |
Aligned, non-temporal store of a vector of 'double' values. More... | |
BLAZE_ALWAYS_INLINE void | stream (complex< float > *address, const sse_cfloat_t &value) |
Aligned, non-temporal store of a vector of 'complex<float>' values. More... | |
BLAZE_ALWAYS_INLINE void | stream (complex< double > *address, const sse_cdouble_t &value) |
Aligned, non-temporal store of a vector of 'complex<double>' values. 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 > | |
void | clear (Type &clearable) |
Clearing the given value/object to the default state. More... | |
template<typename T1 , typename T2 > | |
bool | equal (const T1 &a, const T2 &b) |
Generic equality check. More... | |
float | inv (float a) |
Inverting the given single precision value. More... | |
double | inv (double a) |
Inverting the given double precision value. More... | |
long double | inv (long double a) |
Inverting the given long double value. More... | |
template<typename Type > | |
bool | isDefault (const Type &v) |
Returns whether the given value/object is in default state. More... | |
template<typename T > | |
EnableIf< IsFloatingPoint< T > , bool >::Type | isnan (T a) |
Platform independent implementation of the C99 isnan function. More... | |
template<typename Type > | |
void | move (Type &dst, Type &src) |
Moving the contents of one value to another. More... | |
template<typename Type > | |
void | reset (Type &resettable) |
Resetting the given value/object to the default value. More... | |
template<typename T > | |
EnableIf< Or< IsBuiltin< T > , IsComplex< T > >, const T & > ::Type | serial (const T &a) |
Formal serialization of the evaluation of the given argument. More... | |
template<typename T > | |
const MultExprTrait< T, T >::Type | sq (const T &a) |
Squaring the given value/object. 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 > >, typename ColumnExprTrait < MT >::Type >::Type | 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> | |
DisableIf< Or< IsComputation < MT >, IsTransExpr< MT > >, typename ColumnExprTrait < const MT >::Type >::Type | 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 > >, typename RowExprTrait< MT > ::Type >::Type | 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> | |
DisableIf< Or< IsComputation < MT >, IsTransExpr< MT > >, typename RowExprTrait < const MT >::Type >::Type | 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> | |
SubmatrixExprTrait< MT, unaligned >::Type | 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<typename MT , bool SO> | |
SubmatrixExprTrait< const MT, unaligned >::Type | 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 matrix. More... | |
template<bool AF, typename MT , bool SO> | |
DisableIf< Or< IsComputation < MT >, IsTransExpr< MT > >, typename SubmatrixExprTrait< MT, AF > ::Type >::Type | 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> | |
DisableIf< Or< IsComputation < MT >, IsTransExpr< MT > >, typename SubmatrixExprTrait< const MT, AF >::Type >::Type | 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 matrix. More... | |
template<typename VT , bool TF> | |
SubvectorExprTrait< VT, unaligned >::Type | subvector (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> | |
SubvectorExprTrait< const VT, unaligned >::Type | subvector (const 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> | |
DisableIf< Or< IsComputation < VT >, IsTransExpr< VT > >, typename SubvectorExprTrait< VT, AF > ::Type >::Type | 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> | |
DisableIf< Or< IsComputation < VT >, IsTransExpr< VT > >, typename SubvectorExprTrait< const VT, AF >::Type >::Type | subvector (const Vector< VT, TF > &vector, size_t index, size_t size) |
Creating a view on a specific subvector of the given vector. 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 > | |
bool | checkAlignment (const T *address) |
Checks the alignment of the given. 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 * > ::Type | allocate (size_t size) |
Aligned array allocation for built-in data types. More... | |
template<typename T > | |
DisableIf< IsBuiltin< T >, T * > ::Type | allocate (size_t size) |
Aligned array allocation for user-specific class types. More... | |
template<typename T > | |
EnableIf< IsBuiltin< T > >::Type | deallocate (T *address) |
Deallocation of memory for built-in data types. More... | |
template<typename T > | |
DisableIf< IsBuiltin< T > >::Type | deallocate (T *address) |
Deallocation of memory for user-specific class types. More... | |
template<typename T1 > | |
void | UNUSED_PARAMETER (const T1 &) |
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... | |
NonNumericProxy operators | |
template<typename MT1 , typename MT2 > | |
bool | operator== (const NonNumericProxy< MT1 > &lhs, const NonNumericProxy< MT2 > &rhs) |
Equality comparison between two NonNumericProxy objects. More... | |
template<typename MT , typename T > | |
bool | operator== (const NonNumericProxy< MT > &lhs, const T &rhs) |
Equality comparison between a NonNumericProxy object and an object of different type. More... | |
template<typename T , typename MT > | |
bool | operator== (const T &lhs, const NonNumericProxy< MT > &rhs) |
Equality comparison between an object of different type and a NonNumericProxy object. More... | |
template<typename MT1 , typename MT2 > | |
bool | operator!= (const NonNumericProxy< MT1 > &lhs, const NonNumericProxy< MT2 > &rhs) |
Inequality comparison between two NonNumericProxy objects. More... | |
template<typename MT , typename T > | |
bool | operator!= (const NonNumericProxy< MT > &lhs, const T &rhs) |
Inequality comparison between a NonNumericProxy object and an object of different type. More... | |
template<typename T , typename MT > | |
bool | operator!= (const T &lhs, const NonNumericProxy< MT > &rhs) |
Inquality comparison between an object of different type and a NonNumericProxy object. More... | |
template<typename MT1 , typename MT2 > | |
bool | operator< (const NonNumericProxy< MT1 > &lhs, const NonNumericProxy< MT2 > &rhs) |
Less-than comparison between two NonNumericProxy objects. More... | |
template<typename MT , typename T > | |
bool | operator< (const NonNumericProxy< MT > &lhs, const T &rhs) |
Less-than comparison between a NonNumericProxy object and an object of different type. More... | |
template<typename T , typename MT > | |
bool | operator< (const T &lhs, const NonNumericProxy< MT > &rhs) |
Less-than comparison between an object of different type and a NonNumericProxy object. More... | |
template<typename MT1 , typename MT2 > | |
bool | operator> (const NonNumericProxy< MT1 > &lhs, const NonNumericProxy< MT2 > &rhs) |
Greater-than comparison between two NonNumericProxy objects. More... | |
template<typename MT , typename T > | |
bool | operator> (const NonNumericProxy< MT > &lhs, const T &rhs) |
Greater-than comparison between a NonNumericProxy object and an object of different type. More... | |
template<typename T , typename MT > | |
bool | operator> (const T &lhs, const NonNumericProxy< MT > &rhs) |
Greater-than comparison between an object of different type and a NonNumericProxy object. More... | |
template<typename MT1 , typename MT2 > | |
bool | operator<= (const NonNumericProxy< MT1 > &lhs, const NonNumericProxy< MT2 > &rhs) |
Less-or-equal-than comparison between two NonNumericProxy objects. More... | |
template<typename MT , typename T > | |
bool | operator<= (const NonNumericProxy< MT > &lhs, const T &rhs) |
Less-or-equal-than comparison between a NonNumericProxy object and an object of different type. More... | |
template<typename T , typename MT > | |
bool | operator<= (const T &lhs, const NonNumericProxy< MT > &rhs) |
Less-or-equal-than comparison between an object of different type and a NonNumericProxy object. More... | |
template<typename MT1 , typename MT2 > | |
bool | operator>= (const NonNumericProxy< MT1 > &lhs, const NonNumericProxy< MT2 > &rhs) |
Greater-or-equal-than comparison between two NonNumericProxy objects. More... | |
template<typename MT , typename T > | |
bool | operator>= (const NonNumericProxy< MT > &lhs, const T &rhs) |
Greater-or-equal-than comparison between a NonNumericProxy object and an object of different type. More... | |
template<typename T , typename MT > | |
bool | operator>= (const T &lhs, const NonNumericProxy< MT > &rhs) |
Greater-or-equal-than comparison between an object of different type and a NonNumericProxy object. More... | |
template<typename MT > | |
std::ostream & | operator<< (std::ostream &os, const NonNumericProxy< MT > &proxy) |
Global output operator for the NonNumericProxy class template. More... | |
NonNumericProxy global functions | |
template<typename MT > | |
BLAZE_ALWAYS_INLINE void | reset (const NonNumericProxy< MT > &proxy) |
Resetting the represented element to the default initial values. More... | |
template<typename MT > | |
BLAZE_ALWAYS_INLINE void | clear (const NonNumericProxy< MT > &proxy) |
Clearing the represented element. More... | |
template<typename MT > | |
BLAZE_ALWAYS_INLINE bool | isDefault (const NonNumericProxy< MT > &proxy) |
Returns whether the represented element is in default state. More... | |
NumericProxy operators | |
template<typename MT1 , typename MT2 > | |
bool | operator== (const NumericProxy< MT1 > &lhs, const NumericProxy< MT2 > &rhs) |
Equality comparison between two NumericProxy objects. More... | |
template<typename MT , typename T > | |
bool | operator== (const NumericProxy< MT > &lhs, const T &rhs) |
Equality comparison between a NumericProxy object and an object of different type. More... | |
template<typename T , typename MT > | |
bool | operator== (const T &lhs, const NumericProxy< MT > &rhs) |
Equality comparison between an object of different type and a NumericProxy object. More... | |
template<typename MT1 , typename MT2 > | |
bool | operator!= (const NumericProxy< MT1 > &lhs, const NumericProxy< MT2 > &rhs) |
Inequality comparison between two NumericProxy objects. More... | |
template<typename MT , typename T > | |
bool | operator!= (const NumericProxy< MT > &lhs, const T &rhs) |
Inequality comparison between a NumericProxy object and an object of different type. More... | |
template<typename T , typename MT > | |
bool | operator!= (const T &lhs, const NumericProxy< MT > &rhs) |
Inquality comparison between an object of different type and a NumericProxy object. More... | |
template<typename MT1 , typename MT2 > | |
bool | operator< (const NumericProxy< MT1 > &lhs, const NumericProxy< MT2 > &rhs) |
Less-than comparison between two NumericProxy objects. More... | |
template<typename MT , typename T > | |
bool | operator< (const NumericProxy< MT > &lhs, const T &rhs) |
Less-than comparison between a NumericProxy object and an object of different type. More... | |
template<typename T , typename MT > | |
bool | operator< (const T &lhs, const NumericProxy< MT > &rhs) |
Less-than comparison between an object of different type and a NumericProxy object. More... | |
template<typename MT1 , typename MT2 > | |
bool | operator> (const NumericProxy< MT1 > &lhs, const NumericProxy< MT2 > &rhs) |
Greater-than comparison between two NumericProxy objects. More... | |
template<typename MT , typename T > | |
bool | operator> (const NumericProxy< MT > &lhs, const T &rhs) |
Greater-than comparison between a NumericProxy object and an object of different type. More... | |
template<typename T , typename MT > | |
bool | operator> (const T &lhs, const NumericProxy< MT > &rhs) |
Greater-than comparison between an object of different type and a NumericProxy object. More... | |
template<typename MT1 , typename MT2 > | |
bool | operator<= (const NumericProxy< MT1 > &lhs, const NumericProxy< MT2 > &rhs) |
Less-or-equal-than comparison between two NumericProxy objects. More... | |
template<typename MT , typename T > | |
bool | operator<= (const NumericProxy< MT > &lhs, const T &rhs) |
Less-or-equal-than comparison between a NumericProxy object and an object of different type. More... | |
template<typename T , typename MT > | |
bool | operator<= (const T &lhs, const NumericProxy< MT > &rhs) |
Less-or-equal-than comparison between an object of different type and a NumericProxy object. More... | |
template<typename MT1 , typename MT2 > | |
bool | operator>= (const NumericProxy< MT1 > &lhs, const NumericProxy< MT2 > &rhs) |
Greater-or-equal-than comparison between two NumericProxy objects. More... | |
template<typename MT , typename T > | |
bool | operator>= (const NumericProxy< MT > &lhs, const T &rhs) |
Greater-or-equal-than comparison between a NumericProxy object and an object of different type. More... | |
template<typename T , typename MT > | |
bool | operator>= (const T &lhs, const NumericProxy< MT > &rhs) |
Greater-or-equal-than comparison between an object of different type and a NumericProxy object. More... | |
template<typename MT > | |
std::ostream & | operator<< (std::ostream &os, const NumericProxy< MT > &proxy) |
Global output operator for numeric proxies. 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 > | |
bool | isDefault (const NumericProxy< MT > &proxy) |
Returns whether the represented element is in default state. 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... | |
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> | |
void | swap (SymmetricMatrix< MT, SO, DF, NF > &a, SymmetricMatrix< MT, SO, DF, NF > &b) |
Swapping the contents of two matrices. More... | |
DenseIterator operators | |
template<typename T1 , typename T2 > | |
bool | operator== (const DenseIterator< T1 > &lhs, const DenseIterator< T2 > &rhs) |
Equality comparison between two DenseIterator objects. More... | |
template<typename T1 , typename T2 > | |
bool | operator!= (const DenseIterator< T1 > &lhs, const DenseIterator< T2 > &rhs) |
Inequality comparison between two DenseIterator objects. More... | |
template<typename T1 , typename T2 > | |
bool | operator< (const DenseIterator< T1 > &lhs, const DenseIterator< T2 > &rhs) |
Less-than comparison between two DenseIterator objects. More... | |
template<typename T1 , typename T2 > | |
bool | operator> (const DenseIterator< T1 > &lhs, const DenseIterator< T2 > &rhs) |
Greater-than comparison between two DenseIterator objects. More... | |
template<typename T1 , typename T2 > | |
bool | operator<= (const DenseIterator< T1 > &lhs, const DenseIterator< T2 > &rhs) |
Less-or-equal-than comparison between two DenseIterator objects. More... | |
template<typename T1 , typename T2 > | |
bool | operator>= (const DenseIterator< T1 > &lhs, const DenseIterator< T2 > &rhs) |
Greater-or-equal-than comparison between two DenseIterator objects. More... | |
template<typename Type > | |
const DenseIterator< Type > | operator+ (const DenseIterator< Type > &it, ptrdiff_t inc) |
Addition between a DenseIterator and an integral value. More... | |
template<typename Type > | |
const DenseIterator< Type > | operator+ (ptrdiff_t inc, const DenseIterator< Type > &it) |
Addition between an integral value and a DenseIterator. More... | |
template<typename Type > | |
const DenseIterator< Type > | operator- (const DenseIterator< Type > &it, ptrdiff_t dec) |
Subtraction between a DenseIterator and an integral value. More... | |
template<typename Type > | |
ptrdiff_t | operator- (const DenseIterator< Type > &lhs, const DenseIterator< Type > &rhs) |
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 >::Type | 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 >::Type | 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 >::Type | 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 >::Type | 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 >::Type | 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 | isDiagonal (const DenseMatrix< MT, SO > &dm) |
Checks if the give dense matrix is diagonal. 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 | isLower (const DenseMatrix< MT, SO > &dm) |
Checks if the given dense matrix is a 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> | |
const MT::ElementType | min (const DenseMatrix< MT, SO > &dm) |
Returns the smallest element of the dense matrix. More... | |
template<typename MT , bool SO> | |
const MT::ElementType | 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 >::Type | 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 >::Type | 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 >::Type | 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 >::Type | 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> | |
CMathTrait< typename VT::ElementType >::Type | length (const DenseVector< VT, TF > &dv) |
Calculation of the dense vector length ![]() | |
template<typename VT , bool TF> | |
const VT::ElementType | sqrLength (const DenseVector< VT, TF > &dv) |
Calculation of the dense vector square length ![]() | |
template<typename VT , bool TF> | |
const VT::ElementType | min (const DenseVector< VT, TF > &dv) |
Returns the smallest element of the dense vector. More... | |
template<typename VT , bool TF> | |
const VT::ElementType | 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> | |
void | swap (DynamicMatrix< Type, SO > &a, DynamicMatrix< Type, SO > &b) |
Swapping the contents of two dynamic matrices. More... | |
template<typename Type , bool SO> | |
void | move (DynamicMatrix< Type, SO > &dst, DynamicMatrix< Type, SO > &src) |
Moving the contents of one dynamic matrix to another. 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> | |
void | swap (DynamicVector< Type, TF > &a, DynamicVector< Type, TF > &b) |
Swapping the contents of two vectors. More... | |
template<typename Type , bool TF> | |
void | move (DynamicVector< Type, TF > &dst, DynamicVector< Type, TF > &src) |
Moving the contents of one dynamic vector to another. 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> | |
void | swap (HybridMatrix< Type, M, N, SO > &a, HybridMatrix< Type, M, N, SO > &b) |
Swapping the contents of two hybrid matrices. More... | |
template<typename Type , size_t M, size_t N, bool SO> | |
void | move (HybridMatrix< Type, M, N, SO > &dst, HybridMatrix< Type, M, N, SO > &src) |
Moving the contents of one hybrid matrix to another. 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> | |
void | swap (HybridVector< Type, N, TF > &a, HybridVector< Type, N, TF > &b) |
Swapping the contents of two hybrid vectors. More... | |
template<typename Type , size_t N, bool TF> | |
void | move (HybridVector< Type, N, TF > &dst, HybridVector< Type, N, TF > &src) |
Moving the contents of one hybrid vector to another. 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 static matrix is in default state. 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) |
Swapping the contents of two static matrices. More... | |
template<typename Type , size_t M, size_t N, bool SO> | |
void | move (StaticMatrix< Type, M, N, SO > &dst, StaticMatrix< Type, M, N, SO > &src) |
Moving the contents of one static matrix to another. 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 , bool TF> | |
const StaticVector< Type, 2UL, TF > | perp (const StaticVector< Type, 2UL, TF > &v) |
Unary perp dot product operator for the calculation of a perpendicular vector ( ![]() | |
template<typename Type , bool TF> | |
const StaticVector< Type, 3UL, TF > | perp (const StaticVector< Type, 3UL, TF > &v) |
Creates a perpendicular vector b which satisfies ![]() | |
template<typename Type , size_t N, bool TF> | |
void | swap (StaticVector< Type, N, TF > &a, StaticVector< Type, N, TF > &b) |
Swapping the contents of two static vectors. More... | |
template<typename Type , size_t N, bool TF> | |
void | move (StaticVector< Type, N, TF > &dst, StaticVector< Type, N, TF > &src) |
Moving the contents of one static vector to another. 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... | |
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) |
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) |
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) |
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) |
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 MT1 , bool SO1, typename MT2 , bool SO2> | |
BLAZE_ALWAYS_INLINE void | assign (Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs) |
Default implementation of the assignment of a matrix to a matrix. More... | |
template<typename MT1 , bool SO1, typename MT2 , bool SO2> | |
BLAZE_ALWAYS_INLINE void | addAssign (Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs) |
Default implementation of the addition assignment of a matrix to a matrix. More... | |
template<typename MT1 , bool SO1, typename MT2 , bool SO2> | |
BLAZE_ALWAYS_INLINE void | subAssign (Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs) |
Default implementation of the subtraction assignment of a matrix to matrix. More... | |
template<typename MT1 , bool SO1, typename MT2 , bool SO2> | |
BLAZE_ALWAYS_INLINE void | multAssign (Matrix< MT1, SO1 > &lhs, const Matrix< MT2, SO2 > &rhs) |
Default implementation of the multiplication assignment of a matrix to a matrix. More... | |
template<typename MT , bool SO> | |
BLAZE_ALWAYS_INLINE bool | isSquare (const Matrix< MT, SO > &matrix) |
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) |
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) |
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) |
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 void | assign (Vector< VT1, TF1 > &lhs, const Vector< VT2, TF2 > &rhs) |
Default implementation of the assignment of a vector to a vector. More... | |
template<typename VT1 , bool TF1, typename VT2 , bool TF2> | |
BLAZE_ALWAYS_INLINE void | addAssign (Vector< VT1, TF1 > &lhs, const Vector< VT2, TF2 > &rhs) |
Default implementation of the addition assignment of a vector to a vector. More... | |
template<typename VT1 , bool TF1, typename VT2 , bool TF2> | |
BLAZE_ALWAYS_INLINE void | subAssign (Vector< VT1, TF1 > &lhs, const Vector< VT2, TF2 > &rhs) |
Default implementation of the subtraction assignment of a vector to a vector. More... | |
template<typename VT1 , bool TF1, typename VT2 , bool TF2> | |
BLAZE_ALWAYS_INLINE void | multAssign (Vector< VT1, TF1 > &lhs, const Vector< VT2, TF2 > &rhs) |
Default implementation of the multiplication assignment of a vector to a 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) |
Returns whether the two given vectors represent the same observable state. More... | |
Mathematical utility functions | |
template<typename T > | |
int | sign (T a) |
Sign function. More... | |
template<typename T > | |
size_t | digits (T a) |
Returns the number of valid digits of an integral value. More... | |
template<typename T1 , typename T2 > | |
BLAZE_ALWAYS_INLINE const MathTrait< T1, T2 >::HighType | min (const T1 &a, const T2 &b) |
Minimum function for two arguments. More... | |
template<typename T1 , typename T2 , typename T3 > | |
BLAZE_ALWAYS_INLINE const MathTrait< typename MathTrait < T1, T2 >::HighType, T3 > ::HighType | min (const T1 &a, const T2 &b, const T3 &c) |
Minimum function for three arguments. More... | |
template<typename T1 , typename T2 > | |
BLAZE_ALWAYS_INLINE const MathTrait< T1, T2 >::HighType | max (const T1 &a, const T2 &b) |
Maximum function for two arguments. More... | |
template<typename T1 , typename T2 , typename T3 > | |
BLAZE_ALWAYS_INLINE const MathTrait< typename MathTrait < T1, T2 >::HighType, T3 > ::HighType | max (const T1 &a, const T2 &b, const T3 &c) |
Maximum function for three arguments. More... | |
template<typename T > | |
BLAZE_ALWAYS_INLINE T | round (T a) |
Rounds the given input value. More... | |
template<typename T1 , typename T2 > | |
BLAZE_ALWAYS_INLINE bool | lessThan (T1 a, T2 b) |
Generic less-than comparison. More... | |
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... | |
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 | 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 | 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... | |
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 | 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 | 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... | |
Quaternion operators | |
template<typename T1 , typename T2 > | |
bool | operator== (const Quaternion< T1 > &lhs, const Quaternion< T2 > &rhs) |
Equality operator for the comparison of two quaternions. More... | |
template<typename T1 , typename T2 > | |
bool | operator!= (const Quaternion< T1 > &lhs, const Quaternion< T2 > &rhs) |
Inequality operator for the comparison of two quaternions. More... | |
template<typename Type > | |
std::ostream & | operator<< (std::ostream &os, const Quaternion< Type > &q) |
Global output operator for quaternions. More... | |
template<typename Type > | |
std::istream & | operator>> (std::istream &is, Quaternion< Type > &q) |
Global input operator for quaternions. More... | |
template<typename Type > | |
bool | isnan (const Quaternion< Type > &q) |
Checks the given quaternion for not-a-number elements. More... | |
template<typename Type > | |
void | reset (Quaternion< Type > &q) |
Resetting the given quaternion. More... | |
template<typename Type > | |
void | clear (Quaternion< Type > &q) |
Clearing the given quaternion. More... | |
template<typename Type > | |
bool | isDefault (const Quaternion< Type > &q) |
Returns whether the given quaternion is in default state. More... | |
template<typename Type > | |
const Quaternion< Type > | inv (const Quaternion< Type > &q) |
Inverting the given quaternion ( ![]() | |
template<typename Type > | |
const Quaternion< Type > | sq (const Quaternion< Type > &q) |
Squaring the given quaternion. More... | |
template<typename Type > | |
void | swap (Quaternion< Type > &a, Quaternion< Type > &b) |
Swapping the contents of two quaternions. More... | |
Quaternion arithmetic operators | |
template<typename T1 , typename T2 > | |
const Quaternion< typename MultTrait< T1, T2 >::Type > | operator* (const Quaternion< T1 > &lhs, const Quaternion< T2 > &rhs) |
Multiplication operator for the multiplication of two quaternions ( ![]() | |
RotationMatrix operators | |
template<typename T1 , typename T2 > | |
bool | operator== (const RotationMatrix< T1 > &lhs, const RotationMatrix< T2 > &rhs) |
Equality operator for the comparison of two rotation matrices. More... | |
template<typename T1 , typename T2 > | |
bool | operator!= (const RotationMatrix< T1 > &lhs, const RotationMatrix< T2 > &rhs) |
Inequality operator for the comparison of two rotation matrices. More... | |
template<typename Type > | |
std::ostream & | operator<< (std::ostream &os, const RotationMatrix< Type > &m) |
Global output operator for 3x3 rotation matrices. More... | |
template<typename Type > | |
bool | isnan (const RotationMatrix< Type > &m) |
Checks the given rotation matrix for not-a-number elements. More... | |
template<typename Type > | |
const StaticMatrix< Type, 3UL, 3UL, false > | abs (const RotationMatrix< Type > &m) |
Returns a matrix containing the absolute values of each single element of m. More... | |
template<typename Type > | |
const StaticMatrix< Type, 3UL, 3UL, false > | fabs (const RotationMatrix< Type > &m) |
Returns a matrix containing the absolute values of each single element of m. More... | |
template<typename Type > | |
void | reset (RotationMatrix< Type > &m) |
Resetting the given rotation matrix. More... | |
template<typename Type > | |
void | clear (RotationMatrix< Type > &m) |
Clearing the given rotation matrix. More... | |
template<typename Type > | |
bool | isDefault (const RotationMatrix< Type > &m) |
Returns whether the given rotation matrix is in default state. More... | |
template<typename Type > | |
const RotationMatrix< Type > | trans (const RotationMatrix< Type > &m) |
Calculation of the transpose of the rotation matrix. More... | |
template<typename Type > | |
const RotationMatrix< Type > | inv (const RotationMatrix< Type > &m) |
Inverting the given rotation matrix. More... | |
template<typename Type > | |
const RotationMatrix< Type > | sq (const RotationMatrix< Type > &m) |
Squaring the given rotation matrix. More... | |
template<typename Type > | |
void | swap (RotationMatrix< Type > &a, RotationMatrix< Type > &b) |
Swapping the contents of two rotation matrices. More... | |
RotationMatrix arithmetic operators | |
template<typename T1 , typename T2 > | |
const StaticVector< typename MultTrait< T1, T2 >::Type, 3UL, false > | operator* (const RotationMatrix< T1 > &lhs, const StaticVector< T2, 3UL, false > &rhs) |
Multiplication operator for the multiplication of a rotation matrix and a vector ( ![]() | |
template<typename T1 , typename T2 > | |
const StaticVector< typename MultTrait< T1, T2 >::Type, 3UL, true > | operator* (const StaticVector< T1, 3UL, true > &lhs, const RotationMatrix< T2 > &rhs) |
Multiplication operator for the multiplication of a vector and a rotation matrix ( ![]() | |
template<typename T1 , typename T2 > | |
const StaticMatrix< typename MultTrait< T1, T2 >::Type, 3UL, 3UL, false > | operator* (const RotationMatrix< T1 > &lhs, const StaticMatrix< T2, 3UL, 3UL, false > &rhs) |
Multiplication operator for the multiplication of a rotation matrix and a standard matrix ( ![]() | |
template<typename T1 , typename T2 > | |
const StaticMatrix< typename MultTrait< T1, T2 >::Type, 3UL, 3UL, false > | operator* (const StaticMatrix< T1, 3UL, 3UL, false > &lhs, const RotationMatrix< T2 > &rhs) |
Multiplication operator for the multiplication of a standard matrix and a rotation matrix ( ![]() | |
template<typename T1 , typename T2 > | |
const RotationMatrix< typename MultTrait< T1, T2 >::Type > | operator* (const RotationMatrix< T1 > &lhs, const RotationMatrix< T2 > &rhs) |
Multiplication operator for the multiplication of two rotation matrices ( ![]() | |
Dense matrix SMP functions | |
template<typename MT1 , bool SO1, typename MT2 , bool SO2> | |
EnableIf< IsDenseMatrix< MT1 > >::Type | 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 > >::Type | 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 > >::Type | 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 > >::Type | 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 > >::Type | 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 > >::Type | 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 > >::Type | 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... | |
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 > >::Type | 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 > >::Type | 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 > >::Type | 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 > >::Type | 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 > >::Type | 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 > >::Type | 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 > >::Type | 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) | |
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) |
Iterator | begin (size_t i) |
ConstIterator | cbegin (size_t i) const |
Iterator | end (size_t i) |
ConstIterator | cend (size_t i) const |
Assignment operators | |
CompressedMatrix & | operator= (const CompressedMatrix &rhs) |
template<typename MT , bool SO> | |
CompressedMatrix & | operator= (const DenseMatrix< MT, SO > &rhs) |
template<typename MT , bool SO> | |
CompressedMatrix & | operator= (const SparseMatrix< MT, SO > &rhs) |
template<typename MT , bool SO> | |
CompressedMatrix & | operator+= (const Matrix< MT, SO > &rhs) |
template<typename MT , bool SO> | |
CompressedMatrix & | operator-= (const Matrix< MT, SO > &rhs) |
template<typename MT , bool SO> | |
CompressedMatrix & | operator*= (const Matrix< MT, SO > &rhs) |
template<typename Other > | |
EnableIf< IsNumeric< Other > , CompressedMatrix >::Type & | operator*= (Other rhs) |
template<typename Other > | |
EnableIf< IsNumeric< Other > , CompressedMatrix >::Type & | operator/= (Other rhs) |
Utility functions | |
size_t | rows () const |
size_t | columns () const |
size_t | capacity () const |
size_t | capacity (size_t j) const |
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) |
CompressedMatrix & | transpose () |
template<typename Other > | |
CompressedMatrix & | scale (const Other &scalar) |
template<typename Other > | |
CompressedMatrix & | scaleDiagonal (Other scalar) |
void | swap (CompressedMatrix &sm) |
Iterator | insert (Iterator pos, size_t i, size_t j, const Type &value) |
size_t | extendCapacity () const |
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 |
template<typename Other > | |
bool | isAliased (const Other *alias) const |
bool | canSMPAssign () const |
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> | |
void | swap (CompressedVector< Type, TF > &a, CompressedVector< Type, TF > &b) |
Swapping the contents of two compressed vectors. More... | |
template<typename Type , bool TF> | |
void | move (CompressedVector< Type, TF > &dst, CompressedVector< Type, TF > &src) |
Moving the contents of one compressed vector to another. More... | |
MatrixAccessProxy operators | |
template<typename MT1 , typename MT2 > | |
bool | operator== (const MatrixAccessProxy< MT1 > &lhs, const MatrixAccessProxy< MT2 > &rhs) |
Equality comparison between two MatrixAccessProxy objects. More... | |
template<typename MT , typename T > | |
bool | operator== (const MatrixAccessProxy< MT > &lhs, const T &rhs) |
Equality comparison between a MatrixAccessProxy object and an object of different type. More... | |
template<typename T , typename MT > | |
bool | operator== (const T &lhs, const MatrixAccessProxy< MT > &rhs) |
Equality comparison between an object of different type and a MatrixAccessProxy object. More... | |
template<typename MT1 , typename MT2 > | |
bool | operator!= (const MatrixAccessProxy< MT1 > &lhs, const MatrixAccessProxy< MT2 > &rhs) |
Inequality comparison between two MatrixAccessProxy objects. More... | |
template<typename MT , typename T > | |
bool | operator!= (const MatrixAccessProxy< MT > &lhs, const T &rhs) |
Inequality comparison between a MatrixAccessProxy object and an object of different type. More... | |
template<typename T , typename MT > | |
bool | operator!= (const T &lhs, const MatrixAccessProxy< MT > &rhs) |
Inquality comparison between an object of different type and a MatrixAccessProxy object. More... | |
template<typename MT1 , typename MT2 > | |
bool | operator< (const MatrixAccessProxy< MT1 > &lhs, const MatrixAccessProxy< MT2 > &rhs) |
Less-than comparison between two MatrixAccessProxy objects. More... | |
template<typename MT , typename T > | |
bool | operator< (const MatrixAccessProxy< MT > &lhs, const T &rhs) |
Less-than comparison between a MatrixAccessProxy object and an object of different type. More... | |
template<typename T , typename MT > | |
bool | operator< (const T &lhs, const MatrixAccessProxy< MT > &rhs) |
Less-than comparison between an object of different type and a MatrixAccessProxy object. More... | |
template<typename MT1 , typename MT2 > | |
bool | operator> (const MatrixAccessProxy< MT1 > &lhs, const MatrixAccessProxy< MT2 > &rhs) |
Greater-than comparison between two MatrixAccessProxy objects. More... | |
template<typename MT , typename T > | |
bool | operator> (const MatrixAccessProxy< MT > &lhs, const T &rhs) |
Greater-than comparison between a MatrixAccessProxy object and an object of different type. More... | |
template<typename T , typename MT > | |
bool | operator> (const T &lhs, const MatrixAccessProxy< MT > &rhs) |
Greater-than comparison between an object of different type and a MatrixAccessProxy object. More... | |
template<typename MT1 , typename MT2 > | |
bool | operator<= (const MatrixAccessProxy< MT1 > &lhs, const MatrixAccessProxy< MT2 > &rhs) |
Less-or-equal-than comparison between two MatrixAccessProxy objects. More... | |
template<typename MT , typename T > | |
bool | operator<= (const MatrixAccessProxy< MT > &lhs, const T &rhs) |
Less-or-equal-than comparison between a MatrixAccessProxy object and an object of different type. More... | |
template<typename T , typename MT > | |
bool | operator<= (const T &lhs, const MatrixAccessProxy< MT > &rhs) |
Less-or-equal-than comparison between an object of different type and a MatrixAccessProxy object. More... | |
template<typename MT1 , typename MT2 > | |
bool | operator>= (const MatrixAccessProxy< MT1 > &lhs, const MatrixAccessProxy< MT2 > &rhs) |
Greater-or-equal-than comparison between two MatrixAccessProxy objects. More... | |
template<typename MT , typename T > | |
bool | operator>= (const MatrixAccessProxy< MT > &lhs, const T &rhs) |
Greater-or-equal-than comparison between a MatrixAccessProxy object and an object of different type. More... | |
template<typename T , typename MT > | |
bool | operator>= (const T &lhs, const MatrixAccessProxy< MT > &rhs) |
Greater-or-equal-than comparison between an object of different type and a MatrixAccessProxy object. More... | |
template<typename MT > | |
std::ostream & | operator<< (std::ostream &os, const MatrixAccessProxy< MT > &proxy) |
Global output operator for the MatrixAccessProxy class template. 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 > | |
void | swap (const MatrixAccessProxy< MT > &a, const MatrixAccessProxy< MT > &b) |
Swapping the contents of two access proxies. More... | |
template<typename MT , typename T > | |
void | swap (const MatrixAccessProxy< MT > &a, T &b) |
Swapping the contents of an access proxy with another element. More... | |
template<typename T , typename MT > | |
void | swap (T &a, const MatrixAccessProxy< MT > &b) |
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 | isDiagonal (const SparseMatrix< MT, SO > &sm) |
Checks if the give sparse matrix is diagonal. 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 | isLower (const SparseMatrix< MT, SO > &sm) |
Checks if the given sparse matrix is a 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> | |
const MT::ElementType | min (const SparseMatrix< MT, SO > &sm) |
Returns the smallest element of the sparse matrix. More... | |
template<typename MT , bool SO> | |
const MT::ElementType | 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> | |
CMathTrait< typename VT::ElementType >::Type | length (const SparseVector< VT, TF > &sv) |
Calculation of the sparse vector length ![]() | |
template<typename VT , bool TF> | |
const VT::ElementType | sqrLength (const SparseVector< VT, TF > &sv) |
Calculation of the sparse vector square length ![]() | |
template<typename VT , bool TF> | |
const VT::ElementType | min (const SparseVector< VT, TF > &sv) |
Returns the smallest element of the sparse vector. More... | |
template<typename VT , bool TF> | |
const VT::ElementType | max (const SparseVector< VT, TF > &sv) |
Returns the largest element of the sparse vector. More... | |
VectorAccessProxy operators | |
template<typename VT1 , typename VT2 > | |
bool | operator== (const VectorAccessProxy< VT1 > &lhs, const VectorAccessProxy< VT2 > &rhs) |
Equality comparison between two VectorAccessProxy objects. More... | |
template<typename VT , typename T > | |
bool | operator== (const VectorAccessProxy< VT > &lhs, const T &rhs) |
Equality comparison between a VectorAccessProxy object and an object of different type. More... | |
template<typename T , typename VT > | |
bool | operator== (const T &lhs, const VectorAccessProxy< VT > &rhs) |
Equality comparison between an object of different type and a VectorAccessProxy object. More... | |
template<typename VT1 , typename VT2 > | |
bool | operator!= (const VectorAccessProxy< VT1 > &lhs, const VectorAccessProxy< VT2 > &rhs) |
Inequality comparison between two VectorAccessProxy objects. More... | |
template<typename VT , typename T > | |
bool | operator!= (const VectorAccessProxy< VT > &lhs, const T &rhs) |
Inequality comparison between a VectorAccessProxy object and an object of different type. More... | |
template<typename T , typename VT > | |
bool | operator!= (const T &lhs, const VectorAccessProxy< VT > &rhs) |
Inquality comparison between an object of different type and a VectorAccessProxy object. More... | |
template<typename VT1 , typename VT2 > | |
bool | operator< (const VectorAccessProxy< VT1 > &lhs, const VectorAccessProxy< VT2 > &rhs) |
Less-than comparison between two VectorAccessProxy objects. More... | |
template<typename VT , typename T > | |
bool | operator< (const VectorAccessProxy< VT > &lhs, const T &rhs) |
Less-than comparison between a VectorAccessProxy object and an object of different type. More... | |
template<typename T , typename VT > | |
bool | operator< (const T &lhs, const VectorAccessProxy< VT > &rhs) |
Less-than comparison between an object of different type and a VectorAccessProxy object. More... | |
template<typename VT1 , typename VT2 > | |
bool | operator> (const VectorAccessProxy< VT1 > &lhs, const VectorAccessProxy< VT2 > &rhs) |
Greater-than comparison between two VectorAccessProxy objects. More... | |
template<typename VT , typename T > | |
bool | operator> (const VectorAccessProxy< VT > &lhs, const T &rhs) |
Greater-than comparison between a VectorAccessProxy object and an object of different type. More... | |
template<typename T , typename VT > | |
bool | operator> (const T &lhs, const VectorAccessProxy< VT > &rhs) |
Greater-than comparison between an object of different type and a VectorAccessProxy object. More... | |
template<typename VT1 , typename VT2 > | |
bool | operator<= (const VectorAccessProxy< VT1 > &lhs, const VectorAccessProxy< VT2 > &rhs) |
Less-or-equal-than comparison between two VectorAccessProxy objects. More... | |
template<typename VT , typename T > | |
bool | operator<= (const VectorAccessProxy< VT > &lhs, const T &rhs) |
Less-or-equal-than comparison between a VectorAccessProxy object and an object of different type. More... | |
template<typename T , typename VT > | |
bool | operator<= (const T &lhs, const VectorAccessProxy< VT > &rhs) |
Less-or-equal-than comparison between an object of different type and a VectorAccessProxy object. More... | |
template<typename VT1 , typename VT2 > | |
bool | operator>= (const VectorAccessProxy< VT1 > &lhs, const VectorAccessProxy< VT2 > &rhs) |
Greater-or-equal-than comparison between two VectorAccessProxy objects. More... | |
template<typename VT , typename T > | |
bool | operator>= (const VectorAccessProxy< VT > &lhs, const T &rhs) |
Greater-or-equal-than comparison between a VectorAccessProxy object and an object of different type. More... | |
template<typename T , typename VT > | |
bool | operator>= (const T &lhs, const VectorAccessProxy< VT > &rhs) |
Greater-or-equal-than comparison between an object of different type and a VectorAccessProxy object. More... | |
template<typename VT > | |
std::ostream & | operator<< (std::ostream &os, const VectorAccessProxy< VT > &proxy) |
Global output operator for the VectorAccessProxy class template. 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 > | |
void | swap (const VectorAccessProxy< VT > &a, const VectorAccessProxy< VT > &b) |
Swapping the contents of two access proxies. More... | |
template<typename VT , typename T > | |
void | swap (const VectorAccessProxy< VT > &a, T &b) |
Swapping the contents of an access proxy with another element. More... | |
template<typename T , typename VT > | |
void | swap (T &a, const VectorAccessProxy< VT > &b) |
Swapping the contents of an access proxy with another element. More... | |
Vector operators | |
template<typename T1 , typename T2 > | |
const MultTrait< typename T1::ElementType, typename T2::ElementType >::Type | operator, (const Vector< T1, false > &lhs, const Vector< T2, false > &rhs) |
Multiplication operator for the scalar product (inner product) of two vectors ( ![]() | |
template<typename T1 , typename T2 > | |
const MultTrait< typename T1::ElementType, typename T2::ElementType >::Type | operator, (const Vector< T1, false > &lhs, const Vector< T2, true > &rhs) |
Multiplication operator for the scalar product (inner product) of two vectors ( ![]() | |
template<typename T1 , typename T2 > | |
const MultTrait< typename T1::ElementType, typename T2::ElementType >::Type | operator, (const Vector< T1, true > &lhs, const Vector< T2, false > &rhs) |
Multiplication operator for the scalar product (inner product) of two vectors ( ![]() | |
template<typename T1 , typename T2 > | |
const MultTrait< typename T1::ElementType, typename T2::ElementType >::Type | operator, (const Vector< T1, true > &lhs, const Vector< T2, true > &rhs) |
Multiplication operator for the scalar product (inner product) of two vectors ( ![]() | |
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... | |
DenseColumn operators | |
template<typename MT , bool SO, bool SF> | |
void | reset (DenseColumn< MT, SO, SF > &column) |
Resetting the given dense column. More... | |
template<typename MT , bool SO, bool SF> | |
void | clear (DenseColumn< MT, SO, SF > &column) |
Clearing the given dense column. More... | |
template<typename MT , bool SO, bool SF> | |
bool | isDefault (const DenseColumn< MT, SO, SF > &column) |
Returns whether the given dense column is in default state. More... | |
template<typename MT , bool SO, bool SF> | |
bool | isSame (const DenseColumn< MT, SO, SF > &a, const DenseColumn< MT, SO, SF > &b) |
Returns whether the two given dense columns represent the same observable state. More... | |
DenseRow operators | |
template<typename MT , bool SO, bool SF> | |
void | reset (DenseRow< MT, SO, SF > &row) |
Resetting the given dense row. More... | |
template<typename MT , bool SO, bool SF> | |
void | clear (DenseRow< MT, SO, SF > &row) |
Clearing the given dense row. More... | |
template<typename MT , bool SO, bool SF> | |
bool | isDefault (const DenseRow< MT, SO, SF > &row) |
Returns whether the given dense row is in default state. More... | |
template<typename MT , bool SO, bool SF> | |
bool | isSame (const DenseRow< MT, SO, SF > &a, const DenseRow< MT, SO, SF > &b) |
Returns whether the two given dense rows represent the same observable state. More... | |
DenseSubmatrix operators | |
template<typename MT , bool AF, bool SO> | |
void | reset (DenseSubmatrix< MT, AF, SO > &dm) |
Resetting the given dense submatrix. More... | |
template<typename MT , bool AF, bool SO> | |
void | reset (DenseSubmatrix< MT, AF, SO > &dm, size_t i) |
Reset the specified row/column of the given dense submatrix. More... | |
template<typename MT , bool AF, bool SO> | |
void | clear (DenseSubmatrix< MT, AF, SO > &dm) |
Clearing the given dense matrix. More... | |
template<typename MT , bool AF, bool SO> | |
bool | isDefault (const DenseSubmatrix< MT, AF, SO > &dm) |
Returns whether the given dense submatrix is in default state. More... | |
template<typename MT , bool AF, bool SO> | |
bool | isSame (const DenseSubmatrix< MT, AF, SO > &a, const DenseMatrix< MT, SO > &b) |
Returns whether the given dense matrix and submatrix represent the same observable state. More... | |
template<typename MT , bool AF, bool SO> | |
bool | isSame (const DenseMatrix< MT, SO > &a, const DenseSubmatrix< MT, AF, SO > &b) |
Returns whether the given dense matrix and submatrix represent the same observable state. More... | |
template<typename MT , bool AF, bool SO> | |
bool | isSame (const DenseSubmatrix< MT, AF, SO > &a, const DenseSubmatrix< MT, AF, SO > &b) |
Returns whether the two given submatrices represent the same observable state. More... | |
DenseSubvector operators | |
template<typename VT , bool AF, bool TF> | |
void | reset (DenseSubvector< VT, AF, TF > &dv) |
Resetting the given dense subvector. More... | |
template<typename VT , bool AF, bool TF> | |
void | clear (DenseSubvector< VT, AF, TF > &dv) |
Clearing the given dense subvector. More... | |
template<typename VT , bool AF, bool TF> | |
bool | isDefault (const DenseSubvector< VT, AF, TF > &dv) |
Returns whether the given dense subvector is in default state. More... | |
template<typename VT , bool AF, bool TF> | |
bool | isSame (const DenseSubvector< VT, AF, TF > &a, const DenseVector< VT, TF > &b) |
Returns whether the given dense vector and subvector represent the same observable state. More... | |
template<typename VT , bool AF, bool TF> | |
bool | isSame (const DenseVector< VT, TF > &a, const DenseSubvector< VT, AF, TF > &b) |
Returns whether the given dense vector and subvector represent the same observable state. More... | |
template<typename VT , bool AF, bool TF> | |
bool | isSame (const DenseSubvector< VT, AF, TF > &a, const DenseSubvector< VT, AF, TF > &b) |
Returns whether the two given subvectors represent the same observable state. More... | |
SparseColumn operators | |
template<typename MT , bool SO, bool SF> | |
void | reset (SparseColumn< MT, SO, SF > &column) |
Resetting the given sparse column. More... | |
template<typename MT , bool SO, bool SF> | |
void | clear (SparseColumn< MT, SO, SF > &column) |
Clearing the given sparse column. More... | |
template<typename MT , bool SO, bool SF> | |
bool | isDefault (const SparseColumn< MT, SO, SF > &column) |
Returns whether the given sparse column is in default state. More... | |
template<typename MT , bool SO, bool SF> | |
bool | isSame (const SparseColumn< MT, SO, SF > &a, const SparseColumn< MT, SO, SF > &b) |
Returns whether the two given sparse columns represent the same observable state. More... | |
SparseRow operators | |
template<typename MT , bool SO, bool SF> | |
void | reset (SparseRow< MT, SO, SF > &row) |
Resetting the given sparse row. More... | |
template<typename MT , bool SO, bool SF> | |
void | clear (SparseRow< MT, SO, SF > &row) |
Clearing the given sparse row. More... | |
template<typename MT , bool SO, bool SF> | |
bool | isDefault (const SparseRow< MT, SO, SF > &row) |
Returns whether the given sparse row is in default state. More... | |
template<typename MT , bool SO, bool SF> | |
bool | isSame (const SparseRow< MT, SO, SF > &a, const SparseRow< MT, SO, SF > &b) |
Returns whether the two given sparse rows represent the same observable state. More... | |
SparseSubmatrix operators | |
template<typename MT , bool AF, bool SO> | |
void | reset (SparseSubmatrix< MT, AF, SO > &sm) |
Resetting the given sparse submatrix. More... | |
template<typename MT , bool AF, bool SO> | |
void | reset (SparseSubmatrix< MT, AF, SO > &sm, size_t i) |
Reset the specified row/column of the given sparse submatrix. More... | |
template<typename MT , bool AF, bool SO> | |
void | clear (SparseSubmatrix< MT, AF, SO > &sm) |
Clearing the given sparse matrix. More... | |
template<typename MT , bool AF, bool SO> | |
bool | isDefault (const SparseSubmatrix< MT, AF, SO > &sm) |
Returns whether the given sparse submatrix is in default state. More... | |
template<typename MT , bool AF, bool SO> | |
bool | isSame (const SparseSubmatrix< MT, AF, SO > &a, const SparseMatrix< MT, SO > &b) |
Returns whether the given sparse matrix and submatrix represent the same observable state. More... | |
template<typename MT , bool AF, bool SO> | |
bool | isSame (const SparseMatrix< MT, SO > &a, const SparseSubmatrix< MT, AF, SO > &b) |
Returns whether the given sparse matrix and submatrix represent the same observable state. More... | |
template<typename MT , bool AF, bool SO> | |
bool | isSame (const SparseSubmatrix< MT, AF, SO > &a, const SparseSubmatrix< MT, AF, SO > &b) |
Returns whether the two given submatrices represent the same observable state. More... | |
SparseSubvector operators | |
template<typename VT , bool AF, bool TF> | |
void | reset (SparseSubvector< VT, AF, TF > &sv) |
Resetting the given sparse subvector. More... | |
template<typename VT , bool AF, bool TF> | |
void | clear (SparseSubvector< VT, AF, TF > &sv) |
Clearing the given sparse subvector. More... | |
template<typename VT , bool AF, bool TF> | |
bool | isDefault (const SparseSubvector< VT, AF, TF > &sv) |
Returns whether the given sparse subvector is in default state. More... | |
template<typename VT , bool AF, bool TF> | |
bool | isSame (const SparseSubvector< VT, AF, TF > &a, const SparseVector< VT, TF > &b) |
Returns whether the given sparse vector and subvector represent the same observable state. More... | |
template<typename VT , bool AF, bool TF> | |
bool | isSame (const SparseVector< VT, TF > &a, const SparseSubvector< VT, AF, TF > &b) |
Returns whether the given sparse vector and subvector represent the same observable state. More... | |
template<typename VT , bool AF, bool TF> | |
bool | isSame (const SparseSubvector< VT, AF, TF > &a, const SparseSubvector< VT, AF, TF > &b) |
Returns whether the two given subvectors represent the same observable state. More... | |
UniquePtr operators | |
template<typename T1 , typename T2 > | |
bool | operator== (const AlignedAllocator< T1 > &lhs, const AlignedAllocator< T2 > &rhs) |
Equality comparison between two AlignedAllocator objects. More... | |
template<typename T1 , typename T2 > | |
bool | operator!= (const AlignedAllocator< T1 > &lhs, const AlignedAllocator< T2 > &rhs) |
Inequality comparison between two AlignedAllocator objects. More... | |
template<typename T1 , typename D1 , typename T2 , typename D2 > | |
bool | operator== (const UniquePtr< T1, D1 > &lhs, const UniquePtr< T2, D2 > &rhs) |
Equality comparison between two UniquePtr objects. More... | |
template<typename T1 , typename D1 , typename T2 , typename D2 > | |
bool | operator!= (const UniquePtr< T1, D1 > &lhs, const UniquePtr< T2, D2 > &rhs) |
Inequality comparison between two UniquePtr objects. More... | |
template<typename T1 , typename D1 , typename T2 , typename D2 > | |
bool | operator< (const UniquePtr< T1, D1 > &lhs, const UniquePtr< T2, D2 > &rhs) |
Less-than comparison between two UniquePtr objects. More... | |
template<typename T1 , typename D1 , typename T2 , typename D2 > | |
bool | operator<= (const UniquePtr< T1, D1 > &lhs, const UniquePtr< T2, D2 > &rhs) |
Less-or-equal-than comparison between two UniquePtr objects. More... | |
template<typename T1 , typename D1 , typename T2 , typename D2 > | |
bool | operator> (const UniquePtr< T1, D1 > &lhs, const UniquePtr< T2, D2 > &rhs) |
Greater-than comparison between two UniquePtr objects. More... | |
template<typename T1 , typename D1 , typename T2 , typename D2 > | |
bool | operator>= (const UniquePtr< T1, D1 > &lhs, const UniquePtr< T2, D2 > &rhs) |
Greater-or-equal-than comparison between two UniquePtr objects. More... | |
template<typename T , typename D > | |
bool | operator== (const UniquePtr< T, D > &ptr, const Null &null) |
Equality comparison between a UniquePtr and NULL. More... | |
template<typename T , typename D > | |
bool | operator!= (const UniquePtr< T, D > &ptr, const Null &null) |
Inequality comparison between a UniquePtr and NULL. More... | |
template<typename T , typename D > | |
bool | operator< (const UniquePtr< T, D > &ptr, const Null &null) |
Less-than comparison between a UniquePtr and NULL. More... | |
template<typename T , typename D > | |
bool | operator> (const UniquePtr< T, D > &ptr, const Null &null) |
Greater-than comparison between a UniquePtr and NULL. More... | |
template<typename T , typename D > | |
bool | operator<= (const UniquePtr< T, D > &ptr, const Null &null) |
Less-or-equal-than comparison between a UniquePtr and NULL. More... | |
template<typename T , typename D > | |
bool | operator>= (const UniquePtr< T, D > &ptr, const Null &null) |
Greater-or-equal-than comparison between a UniquePtr and NULL. More... | |
template<typename T , typename D > | |
bool | operator== (const Null &null, const UniquePtr< T, D > &ptr) |
Equality comparison between NULL and a UniquePtr. More... | |
template<typename T , typename D > | |
bool | operator!= (const Null &null, const UniquePtr< T, D > &ptr) |
Inquality comparison between NULL and a UniquePtr. More... | |
template<typename T , typename D > | |
bool | operator< (const Null &null, const UniquePtr< T, D > &ptr) |
Less-than comparison between NULL and a UniquePtr. More... | |
template<typename T , typename D > | |
bool | operator> (const Null &null, const UniquePtr< T, D > &ptr) |
Greater-than comparison between NULL and a UniquePtr. More... | |
template<typename T , typename D > | |
bool | operator<= (const Null &null, const UniquePtr< T, D > &ptr) |
Less-or-equal-than comparison between NULL and a UniquePtr. More... | |
template<typename T , typename D > | |
bool | operator>= (const Null &null, const UniquePtr< T, D > &ptr) |
Greater-or-equal-than comparison between NULL and a UniquePtr. More... | |
template<typename T , typename D > | |
void | swap (UniquePtr< T, D > &a, UniquePtr< T, D > &b) |
Swapping the contents of two unique pointers. 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... | |
Null operators | |
template<typename T > | |
bool | operator== (const Null &lhs, const T &rhs) |
Equality comparison between Null and a pointer or pointer-to-member. More... | |
template<typename T > | |
bool | operator== (const T &lhs, const Null &rhs) |
Equality comparison between a pointer or pointer-to-member and Null. More... | |
template<typename T > | |
bool | operator!= (const Null &lhs, const T &rhs) |
Inequality comparison between Null and a pointer or pointer-to-member. More... | |
template<typename T > | |
bool | operator!= (const T &lhs, const Null &rhs) |
Inequality comparison between a pointer or pointer-to-member and Null. 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) |
Swapping the contents of two pointer vectors. More... | |
Random number functions | |
template<typename T > | |
T | rand () |
Random number function. More... | |
template<typename T , typename A1 > | |
T | rand (const A1 &a1) |
Random number function. More... | |
template<typename T , typename A1 , typename A2 > | |
T | rand (const A1 &a1, const A2 &a2) |
Random number function. More... | |
template<typename T , typename A1 , typename A2 , typename A3 > | |
T | rand (const A1 &a1, const A2 &a2, const A3 &a3) |
Random number function. More... | |
template<typename T , typename A1 , typename A2 , typename A3 , typename A4 > | |
T | rand (const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4) |
Random number function. More... | |
template<typename T , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 > | |
T | rand (const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5) |
Random number function. More... | |
template<typename T > | |
void | randomize (T &value) |
Randomization of a given variable. More... | |
template<typename T , typename A1 > | |
void | randomize (T &value, const A1 &a1) |
Randomization of a given variable. More... | |
template<typename T , typename A1 , typename A2 > | |
void | randomize (T &value, const A1 &a1, const A2 &a2) |
Randomization of a given variable. More... | |
template<typename T , typename A1 , typename A2 , typename A3 > | |
void | randomize (T &value, const A1 &a1, const A2 &a2, const A3 &a3) |
Randomization of a given variable. More... | |
template<typename T , typename A1 , typename A2 , typename A3 , typename A4 > | |
void | randomize (T &value, const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4) |
Randomization of a given variable. More... | |
template<typename T , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 > | |
void | randomize (T &value, const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5) |
Randomization of a given variable. 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... | |
UniqueArray operators | |
template<typename T1 , typename D1 , typename T2 , typename D2 > | |
bool | operator== (const UniqueArray< T1, D1 > &lhs, const UniqueArray< T2, D2 > &rhs) |
Equality comparison between two UniqueArray objects. More... | |
template<typename T1 , typename D1 , typename T2 , typename D2 > | |
bool | operator!= (const UniqueArray< T1, D1 > &lhs, const UniqueArray< T2, D2 > &rhs) |
Inequality comparison between two UniqueArray objects. More... | |
template<typename T1 , typename D1 , typename T2 , typename D2 > | |
bool | operator< (const UniqueArray< T1, D1 > &lhs, const UniqueArray< T2, D2 > &rhs) |
Less-than comparison between two UniqueArray objects. More... | |
template<typename T1 , typename D1 , typename T2 , typename D2 > | |
bool | operator<= (const UniqueArray< T1, D1 > &lhs, const UniqueArray< T2, D2 > &rhs) |
Less-or-equal-than comparison between two UniqueArray objects. More... | |
template<typename T1 , typename D1 , typename T2 , typename D2 > | |
bool | operator> (const UniqueArray< T1, D1 > &lhs, const UniqueArray< T2, D2 > &rhs) |
Greater-than comparison between two UniqueArray objects. More... | |
template<typename T1 , typename D1 , typename T2 , typename D2 > | |
bool | operator>= (const UniqueArray< T1, D1 > &lhs, const UniqueArray< T2, D2 > &rhs) |
Greater-or-equal-than comparison between two UniqueArray objects. More... | |
template<typename T , typename D > | |
bool | operator== (const UniqueArray< T, D > &ptr, const Null &null) |
Equality comparison between a UniqueArray and NULL. More... | |
template<typename T , typename D > | |
bool | operator!= (const UniqueArray< T, D > &ptr, const Null &null) |
Inequality comparison between a UniqueArray and NULL. More... | |
template<typename T , typename D > | |
bool | operator< (const UniqueArray< T, D > &ptr, const Null &null) |
Less-than comparison between a UniqueArray and NULL. More... | |
template<typename T , typename D > | |
bool | operator> (const UniqueArray< T, D > &ptr, const Null &null) |
Greater-than comparison between a UniqueArray and NULL. More... | |
template<typename T , typename D > | |
bool | operator<= (const UniqueArray< T, D > &ptr, const Null &null) |
Less-or-equal-than comparison between a UniqueArray and NULL. More... | |
template<typename T , typename D > | |
bool | operator>= (const UniqueArray< T, D > &ptr, const Null &null) |
Greater-or-equal-than comparison between a UniqueArray and NULL. More... | |
template<typename T , typename D > | |
bool | operator== (const Null &null, const UniqueArray< T, D > &ptr) |
Equality comparison between NULL and a UniqueArray. More... | |
template<typename T , typename D > | |
bool | operator!= (const Null &null, const UniqueArray< T, D > &ptr) |
Inquality comparison between NULL and a UniqueArray. More... | |
template<typename T , typename D > | |
bool | operator< (const Null &null, const UniqueArray< T, D > &ptr) |
Less-than comparison between NULL and a UniqueArray. More... | |
template<typename T , typename D > | |
bool | operator> (const Null &null, const UniqueArray< T, D > &ptr) |
Greater-than comparison between NULL and a UniqueArray. More... | |
template<typename T , typename D > | |
bool | operator<= (const Null &null, const UniqueArray< T, D > &ptr) |
Less-or-equal-than comparison between NULL and a UniqueArray. More... | |
template<typename T , typename D > | |
bool | operator>= (const Null &null, const UniqueArray< T, D > &ptr) |
Greater-or-equal-than comparison between NULL and a UniqueArray. More... | |
template<typename T , typename D > | |
void | swap (UniqueArray< T, D > &a, UniqueArray< T, D > &b) |
Swapping the contents of two unique arrays. 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 | |
const 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... | |
const 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... | |
const 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... | |
const size_t | DMATDVECMULT_THRESHOLD = 10000UL |
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 prefered over the custom Blaze kernels. In case the number of elements in the dense matrix is smaller, the Blaze kernels are used. More... | |
const size_t | TDMATDVECMULT_THRESHOLD = 10000UL |
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 prefered over the custom Blaze kernels. In case the number of elements in the dense matrix is smaller, the Blaze kernels are used. More... | |
const size_t | TDVECDMATMULT_THRESHOLD = 10000UL |
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 prefered over the custom Blaze kernels. In case the number of elements in the dense matrix is smaller, the Blaze kernels are used. More... | |
const size_t | TDVECTDMATMULT_THRESHOLD = 10000UL |
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 prefered over the custom Blaze kernels. In case the number of elements in the dense matrix is smaller, the Blaze kernels are used. More... | |
const size_t | DMATDMATMULT_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 prefered over the custom Blaze kernels. In case the number of elements in the target matrix is smaller, the Blaze kernels are used. More... | |
const size_t | DMATTDMATMULT_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 prefered over the custom Blaze kernels. In case the number of elements in the target matrix is smaller, the Blaze kernels are used. More... | |
const size_t | TDMATDMATMULT_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 prefered over the custom Blaze kernels. In case the number of elements in the target matrix is smaller, the Blaze kernels are used. More... | |
const size_t | TDMATTDMATMULT_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 prefered over the custom Blaze kernels. In case the number of elements in the target matrix is smaller, the Blaze kernels are used. More... | |
const size_t | SMP_DVECASSIGN_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... | |
const size_t | SMP_DVECDVECADD_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... | |
const size_t | SMP_DVECDVECSUB_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... | |
const size_t | SMP_DVECDVECMULT_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... | |
const size_t | SMP_DVECSCALARMULT_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... | |
const size_t | SMP_DMATDVECMULT_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... | |
const size_t | SMP_TDMATDVECMULT_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... | |
const size_t | SMP_TDVECDMATMULT_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... | |
const size_t | SMP_TDVECTDMATMULT_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... | |
const size_t | SMP_DMATSVECMULT_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... | |
const size_t | SMP_TDMATSVECMULT_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... | |
const size_t | SMP_TSVECDMATMULT_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... | |
const size_t | SMP_TSVECTDMATMULT_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... | |
const size_t | SMP_SMATDVECMULT_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... | |
const size_t | SMP_TSMATDVECMULT_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... | |
const size_t | SMP_TDVECSMATMULT_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... | |
const size_t | SMP_TDVECTSMATMULT_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... | |
const size_t | SMP_SMATSVECMULT_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... | |
const size_t | SMP_TSMATSVECMULT_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... | |
const size_t | SMP_TSVECSMATMULT_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... | |
const size_t | SMP_TSVECTSMATMULT_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... | |
const size_t | SMP_DMATASSIGN_THRESHOLD = 220UL |
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 rows/columns of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of rows/columns is below this threshold the operation is executed single-threaded. More... | |
const size_t | SMP_DMATDMATADD_THRESHOLD = 190UL |
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 rows/columns of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of rows/columns is below this threshold the operation is executed single-threaded. More... | |
const size_t | SMP_DMATTDMATADD_THRESHOLD = 175UL |
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 rows/columns of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of rows/columns is below this threshold the operation is executed single-threaded. More... | |
const size_t | SMP_DMATDMATSUB_THRESHOLD = 190UL |
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 rows/columns of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of rows/columns is below this threshold the operation is executed single-threaded. More... | |
const size_t | SMP_DMATTDMATSUB_THRESHOLD = 175UL |
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 rows/columns of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of rows/columns is below this threshold the operation is executed single-threaded. More... | |
const size_t | SMP_DMATSCALARMULT_THRESHOLD = 220UL |
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 rows/columns of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of rows/columns is below this threshold the operation is executed single-threaded. More... | |
const size_t | SMP_DMATDMATMULT_THRESHOLD = 55UL |
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 rows/columns of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of rows/columns is below this threshold the operation is executed single-threaded. More... | |
const size_t | SMP_DMATTDMATMULT_THRESHOLD = 55UL |
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 rows/columns of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of rows/columns is below this threshold the operation is executed single-threaded. More... | |
const size_t | SMP_TDMATDMATMULT_THRESHOLD = 55UL |
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 rows/columns of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of rows/columns is below this threshold the operation is executed single-threaded. More... | |
const size_t | SMP_TDMATTDMATMULT_THRESHOLD = 55UL |
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 rows/columns of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of rows/columns is below this threshold the operation is executed single-threaded. More... | |
const size_t | SMP_DMATSMATMULT_THRESHOLD = 64UL |
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 rows/columns of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of rows/columns is below this threshold the operation is executed single-threaded. More... | |
const size_t | SMP_DMATTSMATMULT_THRESHOLD = 68UL |
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 rows/columns of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of rows/columns is below this threshold the operation is executed single-threaded. More... | |
const size_t | SMP_TDMATSMATMULT_THRESHOLD = 90UL |
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 rows/columns of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of rows/columns is below this threshold the operation is executed single-threaded. More... | |
const size_t | SMP_TDMATTSMATMULT_THRESHOLD = 90UL |
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 rows/columns of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of rows/columns is below this threshold the operation is executed single-threaded. More... | |
const size_t | SMP_SMATDMATMULT_THRESHOLD = 88UL |
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 rows/columns of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of rows/columns is below this threshold the operation is executed single-threaded. More... | |
const size_t | SMP_SMATTDMATMULT_THRESHOLD = 72UL |
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 rows/columns of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of rows/columns is below this threshold the operation is executed single-threaded. More... | |
const size_t | SMP_TSMATDMATMULT_THRESHOLD = 66UL |
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 rows/columns of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of rows/columns is below this threshold the operation is executed single-threaded. More... | |
const size_t | SMP_TSMATTDMATMULT_THRESHOLD = 66UL |
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 rows/columns of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of rows/columns is below this threshold the operation is executed single-threaded. More... | |
const size_t | SMP_SMATSMATMULT_THRESHOLD = 150UL |
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 rows/columns of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of rows/columns is below this threshold the operation is executed single-threaded. More... | |
const size_t | SMP_SMATTSMATMULT_THRESHOLD = 140UL |
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 rows/columns of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of rows/columns is below this threshold the operation is executed single-threaded. More... | |
const size_t | SMP_TSMATSMATMULT_THRESHOLD = 140UL |
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 rows/columns of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of rows/columns is below this threshold the operation is executed single-threaded. More... | |
const size_t | SMP_TSMATTSMATMULT_THRESHOLD = 150UL |
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 rows/columns of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of rows/columns is below this threshold the operation is executed single-threaded. More... | |
const size_t | SMP_DVECTDVECMULT_THRESHOLD = 290UL |
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 rows/columns of the target matrix is larger or equal to this threshold, the operation is executed in parallel. If the number of rows/columns is below this threshold the operation is executed single-threaded. More... | |
const 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 real | M_E = 2.7182818284590452353602874713526625 |
Definition of the mathematical constant ![]() | |
const real | M_LOG2E = 1.4426950408889634073599246810018921 |
Definition of the mathematical constant ![]() | |
const real | M_LOG10E = 0.4342944819032518276511289189166051 |
Definition of the mathematical constant ![]() | |
const real | M_LN2 = 0.6931471805599453094172321214581766 |
Definition of the mathematical constant ![]() | |
const real | M_LN10 = 2.3025850929940456840179914546843642 |
Definition of the mathematical constant ![]() | |
const real | M_PI = 3.1415926535897932384626433832795029 |
Definition of the mathematical constant ![]() | |
const real | M_SQRT2 = 1.4142135623730950488016887242096981 |
Definition of the mathematical constant ![]() | |
const real | M_SQRT3 = 1.7320508075688772935274463415058724 |
Definition of the mathematical constant ![]() | |
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 | 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... | |
const bool | unaligned = false |
Alignment flag for unaligned subvectors and submatrices. More... | |
const bool | aligned = true |
Alignment flag for aligned subvectors and submatrices. More... | |
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. | |
Iterator * | begin_ |
Pointers to the first non-zero element of each column. | |
Iterator * | end_ |
Pointers one past the last non-zero element of each column. | |
static const Type | zero_ |
Neutral element for accesses to zero elements. | |
Namespace of the Blaze C++ math library.
anonymous enum |
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).
Aligned array allocation for user-specific class types.
size | The number of elements of the given type to allocate. |
std::bad_alloc | Allocation failed. |
The allocate() function provides the functionality to allocate memory based on the alignment restrictions of the given user-specific class type. For instance, in case the given type has the requirement to be 32-byte aligned, the returned pointer is guaranteed to be 32-byte aligned. Additionally, all elements of the array are guaranteed to be default constructed. Note that the allocate() function provides exception safety similar to the new operator: In case any element throws an exception during construction, all elements that have already been constructed are destroyed in reverse order and the allocated memory is deallocated again.
BLAZE_ALWAYS_INLINE VT::Iterator blaze::begin | ( | Vector< VT, TF > & | vector | ) |
Returns an iterator to the first element of the given vector.
vector | The given dense or sparse vector. |
BLAZE_ALWAYS_INLINE VT::ConstIterator blaze::begin | ( | const Vector< VT, TF > & | vector | ) |
Returns an iterator to the first element of the given vector.
vector | The given dense or sparse vector. |
BLAZE_ALWAYS_INLINE MT::Iterator blaze::begin | ( | Matrix< MT, SO > & | matrix, |
size_t | i | ||
) |
Returns an iterator to the first element of row/column i.
matrix | The given dense or sparse matrix. |
i | The row/column index. |
This function returns a row/column iterator to the first element of row/column i. In case the given matrix is a row-major matrix the function returns an iterator to the first element of row i, in case it is a column-major matrix the function returns an iterator to the first element of column i.
BLAZE_ALWAYS_INLINE MT::ConstIterator blaze::begin | ( | const Matrix< MT, SO > & | matrix, |
size_t | i | ||
) |
Returns an iterator to the first element of row/column i.
matrix | The given dense or sparse matrix. |
i | The row/column index. |
This function returns a row/column iterator to the first element of row/column i. In case the given matrix is a row-major matrix the function returns an iterator to the first element of row i, in case it is a column-major matrix the function returns an iterator to the first element of column i.
BLAZE_ALWAYS_INLINE VT::ConstIterator blaze::cbegin | ( | const Vector< VT, TF > & | vector | ) |
Returns an iterator to the first element of the given vector.
vector | The given dense or sparse vector. |
BLAZE_ALWAYS_INLINE MT::ConstIterator blaze::cbegin | ( | const Matrix< MT, SO > & | matrix, |
size_t | i | ||
) |
Returns an iterator to the first element of row/column i.
matrix | The given dense or sparse matrix. |
i | The row/column index. |
This function returns a row/column iterator to the first element of row/column i. In case the given matrix is a row-major matrix the function returns an iterator to the first element of row i, in case it is a column-major matrix the function returns an iterator to the first element of column i.
BLAZE_ALWAYS_INLINE VT::ConstIterator blaze::cend | ( | const Vector< VT, TF > & | vector | ) |
Returns an iterator just past the last element of the given vector.
vector | The given dense or sparse vector. |
BLAZE_ALWAYS_INLINE MT::ConstIterator blaze::cend | ( | const Matrix< MT, SO > & | matrix, |
size_t | i | ||
) |
Returns an iterator just past the last element of row/column i.
matrix | The given dense or sparse matrix. |
i | The row/column index. |
This function returns an row/column iterator just past the last element of row/column i. In case the given matrix is a row-major matrix the function returns an iterator just past the last element of row i, in case it is a column-major matrix the function returns an iterator just past the last element of column i.
|
inline |
Conversion from type From to type To.
from | The data value to be converted. |
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
The convert function supports any possible type conversion in the most efficient way.
Deallocation of memory for user-specific class types.
address | The address of the first element of the array to be deallocated. |
This function deallocates the given memory that was previously allocated via the allocate() function.
void blaze::deserialize | ( | Archive & | archive, |
Vector< VT, TF > & | vec | ||
) |
Deserializes a vector from the given archive.
archive | The archive to be read from. |
vec | The vector to be deserialized. |
std::runtime_error | Vector could not be deserialized. |
The deserialize() function converts the portable, binary representation contained in the given archive into the given vector type. For a detailed example that demonstrates the (de-)serialization process of vectors, see the serialize() function.
void blaze::deserialize | ( | Archive & | archive, |
Matrix< MT, SO > & | mat | ||
) |
Deserializes a matrix from the given archive.
archive | The archive to be read from. |
mat | The matrix to be deserialized. |
std::runtime_error | Matrix could not be deserialized. |
The deserialize() function converts the portable, binary representation contained in the given archive into the given matrix type. For a detailed example that demonstrates the (de-)serialization process of matrices, see the serialize() function.
BLAZE_ALWAYS_INLINE VT::Iterator blaze::end | ( | Vector< VT, TF > & | vector | ) |
Returns an iterator just past the last element of the given vector.
vector | The given dense or sparse vector. |
BLAZE_ALWAYS_INLINE VT::ConstIterator blaze::end | ( | const Vector< VT, TF > & | vector | ) |
Returns an iterator just past the last element of the given vector.
vector | The given dense or sparse vector. |
BLAZE_ALWAYS_INLINE MT::Iterator blaze::end | ( | Matrix< MT, SO > & | matrix, |
size_t | i | ||
) |
Returns an iterator just past the last element of row/column i.
matrix | The given dense or sparse matrix. |
i | The row/column index. |
This function returns an row/column iterator just past the last element of row/column i. In case the given matrix is a row-major matrix the function returns an iterator just past the last element of row i, in case it is a column-major matrix the function returns an iterator just past the last element of column i.
BLAZE_ALWAYS_INLINE MT::ConstIterator blaze::end | ( | const Matrix< MT, SO > & | matrix, |
size_t | i | ||
) |
Returns an iterator just past the last element of row/column i.
matrix | The given dense or sparse matrix. |
i | The row/column index. |
This function returns an row/column iterator just past the last element of row/column i. In case the given matrix is a row-major matrix the function returns an iterator just past the last element of row i, in case it is a column-major matrix the function returns an iterator just past the last element of column i.
|
inline |
Normalization of the sparse vector ( ).
vec | The given sparse vector. |
This function represents the normalization of a sparse vector:
The function returns an expression representing the normalized sparse vector. Note that this function only works for floating point vectors. The attempt to use this function for an integral vector results in a compile time error.
|
inline |
Normalization of the dense vector ( ).
vec | The given dense vector. |
This function represents the normalization of a dense vector:
The function returns an expression representing the normalized dense vector. Note that this function only works for floating point vectors. The attempt to use this function for an integral vector results in a compile time error.
|
inline |
Inequality comparison between two UnsignedValue objects.
lhs | The left-hand side UnsignedValue wrapper. |
rhs | The right-hand side UnsignedValue wrapper. |
|
inline |
Inequality comparison between Null and a pointer or pointer-to-member.
This operator takes a reference to an object of type T instead of a pointer of a pointer- to-member to avoid the ambiguity with the built-in pointer comparison operators. However, only pointers and pointers-to-member can be compared to Null.
|
inline |
Inequality comparison between a pointer or pointer-to-member and Null.
This operator takes a reference to an object of type T instead of a pointer of a pointer- to-member to avoid the ambiguity with the built-in pointer comparison operators. However, only pointers and pointers-to-member can be compared to Null.
|
inline |
Inequality comparison between two UniqueArray objects.
lhs | The left-hand side unique array. |
rhs | The right-hand side unique array. |
|
inline |
Inequality comparison between two AlignedAllocator objects.
lhs | The left-hand side aligned allocator. |
rhs | The right-hand side aligned allocator. |
|
inline |
Inequality comparison between two UniquePtr objects.
lhs | The left-hand side unique pointer. |
rhs | The right-hand side unique pointer. |
|
inline |
Inequality comparison between a UniqueArray and NULL.
ptr | The left-hand side unique array. |
null | The right-hand side NULL pointer. |
|
inline |
Inequality comparison between a UniquePtr and NULL.
ptr | The left-hand side unique pointer. |
null | The right-hand side NULL pointer. |
|
inline |
Inquality comparison between NULL and a UniqueArray.
null | The left-hand side NULL pointer. |
ptr | The right-hand side unique array. |
|
inline |
Inquality comparison between NULL and a UniquePtr.
null | The left-hand side NULL pointer. |
ptr | The right-hand side unique pointer. |
|
inline |
Inequality comparison between two DenseIterator objects.
lhs | The left-hand side iterator. |
rhs | The right-hand side iterator. |
|
inline |
Inequality comparison between two PtrIterator objects.
lhs | The left-hand side pointer iterator. |
rhs | The right-hand side pointer iterator. |
|
inline |
Inequality comparison between two pointer vectors.
lhs | The left hand side pointer vector. |
rhs | The right hand side pointer vector. |
|
inline |
Intrinsic optimized multiplication operator for the scalar product (inner product) of two dense vectors ( ).
lhs | The left-hand side dense vector for the inner product. |
rhs | The right-hand side dense vector for the inner product. |
std::invalid_argument | Vector sizes do not match. |
This operator represents the scalar product (inner product) of two dense vectors:
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.
|
inline |
Addition between a DenseIterator and an integral value.
it | The iterator to be incremented. |
inc | The number of elements the iterator is incremented. |
|
inline |
Addition between an integral value and a DenseIterator.
inc | The number of elements the iterator is incremented. |
it | The iterator to be incremented. |
|
inline |
Subtraction between a DenseIterator and an integral value.
it | The iterator to be decremented. |
dec | The number of elements the iterator is decremented. |
|
inline |
Calculating the number of elements between two DenseIterator objects.
lhs | The left-hand side iterator. |
rhs | The right-hand side iterator. |
|
inline |
Less-than comparison between two UnsignedValue objects.
lhs | The left-hand side UnsignedValue wrapper. |
rhs | The right-hand side UnsignedValue wrapper. |
|
inline |
Less-than comparison between two UniqueArray objects.
lhs | The left-hand side unique array. |
rhs | The right-hand side unique array. |
|
inline |
Less-than comparison between two UniquePtr objects.
lhs | The left-hand side unique pointer. |
rhs | The right-hand side unique pointer. |
|
inline |
Less-than comparison between a UniqueArray and NULL.
ptr | The left-hand side unique array. |
null | The right-hand side NULL pointer. |
|
inline |
Less-than comparison between a UniquePtr and NULL.
ptr | The left-hand side unique pointer. |
null | The right-hand side NULL pointer. |
|
inline |
Less-than comparison between NULL and a UniqueArray.
null | The left-hand side NULL pointer. |
ptr | The right-hand side unique array. |
|
inline |
Less-than comparison between NULL and a UniquePtr.
null | The left-hand side NULL pointer. |
ptr | The right-hand side unique pointer. |
|
inline |
Less-than comparison between two DenseIterator objects.
lhs | The left-hand side iterator. |
rhs | The right-hand side iterator. |
|
inline |
Less-than comparison between two PtrIterator objects.
lhs | The left-hand side pointer iterator. |
rhs | The right-hand side pointer iterator. |
|
inline |
Global output operator for the UnsignedValue wrapper.
os | Reference to the output stream. |
uv | Reference to a UnsignedValue object. |
|
inline |
Less-or-equal-than comparison between two UnsignedValue objects.
lhs | The left-hand side UnsignedValue wrapper. |
rhs | The right-hand side UnsignedValue wrapper. |
|
inline |
Less-or-equal-than comparison between two UniqueArray objects.
lhs | The left-hand side unique array. |
rhs | The right-hand side unique array. |
|
inline |
Less-or-equal-than comparison between two UniquePtr objects.
lhs | The left-hand side unique pointer. |
rhs | The right-hand side unique pointer. |
|
inline |
Less-or-equal-than comparison between a UniqueArray and NULL.
ptr | The left-hand side unique array. |
null | The right-hand side NULL pointer. |
|
inline |
Less-or-equal-than comparison between a UniquePtr and NULL.
ptr | The left-hand side unique pointer. |
null | The right-hand side NULL pointer. |
|
inline |
Less-or-equal-than comparison between NULL and a UniqueArray.
null | The left-hand side NULL pointer. |
ptr | The right-hand side unique array. |
|
inline |
Less-or-equal-than comparison between NULL and a UniquePtr.
null | The left-hand side NULL pointer. |
ptr | The right-hand side unique pointer. |
|
inline |
Less-or-equal-than comparison between a NegativeAccuracy object and a floating point value.
rhs | The right-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Less-or-equal-than comparison between a NegativeEpsilon object and a floating point value.
rhs | The right-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Less-or-equal-than comparison between a floating point value and a NegativeEpsilon object.
lhs | The left-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Less-or-equal-than comparison between a floating point value and a NegativeAccuracy object.
lhs | The left-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Less-or-equal-than comparison between two DenseIterator objects.
lhs | The left-hand side iterator. |
rhs | The right-hand side iterator. |
|
inline |
Less-or-equal-than comparison between two PtrIterator objects.
lhs | The left-hand side pointer iterator. |
rhs | The right-hand side pointer iterator. |
|
inline |
Equality comparison between two UnsignedValue objects.
lhs | The left-hand side UnsignedValue wrapper. |
rhs | The right-hand side UnsignedValue wrapper. |
|
inline |
Equality comparison between Null and a pointer or pointer-to-member.
This operator takes a reference to an object of type T instead of a pointer of a pointer- to-member to avoid the ambiguity with the built-in pointer comparison operators. However, only pointers and pointers-to-member can be compared to Null.
|
inline |
Equality comparison between a pointer or pointer-to-member and Null.
This operator takes a reference to an object of type T instead of a pointer of a pointer- to-member to avoid the ambiguity with the built-in pointer comparison operators. However, only pointers and pointers-to-member can be compared to Null.
|
inline |
Equality comparison between two UniqueArray objects.
lhs | The left-hand side unique array. |
rhs | The right-hand side unique array. |
|
inline |
Equality comparison between two AlignedAllocator objects.
lhs | The left-hand side aligned allocator. |
rhs | The right-hand side aligned allocator. |
|
inline |
Equality comparison between two UniquePtr objects.
lhs | The left-hand side unique pointer. |
rhs | The right-hand side unique pointer. |
|
inline |
Equality comparison between a UniqueArray and NULL.
ptr | The left-hand side unique array. |
null | The right-hand side NULL pointer. |
|
inline |
Equality comparison between a UniquePtr and NULL.
ptr | The left-hand side unique pointer. |
null | The right-hand side NULL pointer. |
|
inline |
Equality comparison between NULL and a UniqueArray.
null | The left-hand side NULL pointer. |
ptr | The right-hand side unique array. |
|
inline |
Equality comparison between NULL and a UniquePtr.
null | The left-hand side NULL pointer. |
ptr | The right-hand side unique pointer. |
|
inline |
Equality comparison between two DenseIterator objects.
lhs | The left-hand side iterator. |
rhs | The right-hand side iterator. |
|
inline |
Equality comparison between two PtrIterator objects.
lhs | The left-hand side pointer iterator. |
rhs | The right-hand side pointer iterator. |
|
inline |
Equality comparison between two pointer vectors.
lhs | The left hand side pointer vector. |
rhs | The right hand side pointer vector. |
|
inline |
Greater-than comparison between two UnsignedValue objects.
lhs | The left-hand side UnsignedValue wrapper. |
rhs | The right-hand side UnsignedValue wrapper. |
|
inline |
Greater-than comparison between two UniqueArray objects.
lhs | The left-hand side unique array. |
rhs | The right-hand side unique array. |
|
inline |
Greater-than comparison between a UniqueArray and NULL.
ptr | The left-hand side unique array. |
null | The right-hand side NULL pointer. |
|
inline |
Greater-than comparison between two UniquePtr objects.
lhs | The left-hand side unique pointer. |
rhs | The right-hand side unique pointer. |
|
inline |
Greater-than comparison between a UniquePtr and NULL.
ptr | The left-hand side unique pointer. |
null | The right-hand side NULL pointer. |
|
inline |
Greater-than comparison between NULL and a UniqueArray.
null | The left-hand side NULL pointer. |
ptr | The right-hand side unique array. |
|
inline |
Greater-than comparison between NULL and a UniquePtr.
null | The left-hand side NULL pointer. |
ptr | The right-hand side unique pointer. |
|
inline |
Greater-than comparison between two DenseIterator objects.
lhs | The left-hand side iterator. |
rhs | The right-hand side iterator. |
|
inline |
Greater-than comparison between two PtrIterator objects.
lhs | The left-hand side pointer iterator. |
rhs | The right-hand side pointer iterator. |
|
inline |
Greater-or-equal-than comparison between two UnsignedValue objects.
lhs | The left-hand side UnsignedValue wrapper. |
rhs | The right-hand side UnsignedValue wrapper. |
|
inline |
Greater-or-equal-than comparison between two UniqueArray objects.
lhs | The left-hand side unique array. |
rhs | The right-hand side unique array. |
|
inline |
Greater-or-equal-than comparison between two UniquePtr objects.
lhs | The left-hand side unique pointer. |
rhs | The right-hand side unique pointer. |
|
inline |
Greater-or-equal-than comparison between a UniqueArray and NULL.
ptr | The left-hand side unique array. |
null | The right-hand side NULL pointer. |
|
inline |
Greater-or-equal-than comparison between a UniquePtr and NULL.
ptr | The left-hand side unique pointer. |
null | The right-hand side NULL pointer. |
|
inline |
Greater-or-equal-than comparison between NULL and a UniqueArray.
null | The left-hand side NULL pointer. |
ptr | The right-hand side unique array. |
|
inline |
Greater-or-equal-than comparison between NULL and a UniquePtr.
null | The left-hand side NULL pointer. |
ptr | The right-hand side unique pointer. |
|
inline |
Greater-or-equal-than comparison between two DenseIterator objects.
lhs | The left-hand side iterator. |
rhs | The right-hand side iterator. |
|
inline |
Greater-or-equal-than comparison between a NegativeAccuracy object and a floating point value.
rhs | The right-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Greater-or-equal-than comparison between a NegativeEpsilon object and a floating point value.
rhs | The right-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Less-or-equal-than comparison between a floating point value and a NegativeAccuracy object.
lhs | The left-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Less-or-equal-than comparison between a floating point value and a NegativeEpsilon object.
lhs | The left-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Greater-or-equal-than comparison between two PtrIterator objects.
lhs | The left-hand side pointer iterator. |
rhs | The right-hand side pointer iterator. |
std::istream & blaze::operator>> | ( | std::istream & | is, |
UnsignedValue< T > & | uv | ||
) |
Global input operator for the UnsignedValue wrapper.
is | Reference to the input stream. |
uv | Reference to a UnsignedValue object. |
The input operator guarantees that this object is not changed in the case of an input error. Only values suitable for the according built-in unsigned integral data type T are allowed. Otherwise, the input stream's position is returned to its previous position and the std::istream::failbit is set.
|
inline |
Counts the pointer to objects with dynamic type D.
first | Iterator to the first pointer of the pointer range. |
last | Iterator to the pointer one past the last pointer of the pointer range. |
This function traverses the range 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!
|
inline |
Finds the next pointer to an object with dynamic type D.
first | Iterator to the first pointer of the pointer range. |
last | Iterator to the pointer one past the last pointer of the pointer range. |
This function traverses the range 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!
void blaze::serialize | ( | Archive & | archive, |
const Vector< VT, TF > & | vec | ||
) |
Serializes the given vector and writes it to the archive.
archive | The archive to be written. |
vec | The vector to be serialized. |
std::runtime_error | Error during serialization. |
The serialize() function converts the given vector into a portable, binary representation. The following example demonstrates the (de-)serialization process of vectors:
As the example demonstrates, the vector serialization offers an enormous flexibility. However, several actions result in errors:
In case an error is encountered during (de-)serialization, a std::runtime_exception is thrown.
void blaze::serialize | ( | Archive & | archive, |
const Matrix< MT, SO > & | mat | ||
) |
Serializes the given matrix and writes it to the archive.
archive | The archive to be written. |
mat | The matrix to be serialized. |
std::runtime_error | Matrix could not be serialized. |
The serialize() function converts the given matrix into a portable, binary representation. The following example demonstrates the (de-)serialization process of matrices:
As the example demonstrates, the matrix serialization offers an enormous flexibility. However, several actions result in errors:
In case an error is encountered during (de-)serialization, a std::runtime_exception is thrown.
|
inline |
Default implementation of the SMP addition assignment of a matrix to a sparse matrix.
lhs | The target left-hand side sparse matrix. |
rhs | The right-hand side matrix to be added. |
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.
|
inline |
Default implementation of the SMP addition assignment of a vector to a sparse vector.
lhs | The target left-hand side sparse vector. |
rhs | The right-hand side vector to be added. |
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.
|
inline |
Default implementation of the SMP assignment of a matrix to a sparse matrix.
lhs | The target left-hand side sparse matrix. |
rhs | The right-hand side matrix to be assigned. |
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.
|
inline |
Default implementation of the SMP assignment of a vector to a sparse vector.
lhs | The target left-hand side sparse vector. |
rhs | The right-hand side vector to be assigned. |
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.
|
inline |
Default implementation of the SMP multiplication assignment of a vector to a sparse vector.
lhs | The target left-hand side sparse vector. |
rhs | The right-hand side vector to be multiplied. |
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.
|
inline |
Default implementation of the SMP subtraction assignment of a matrix to sparse matrix.
lhs | The target left-hand side sparse matrix. |
rhs | The right-hand side matrix to be subtracted. |
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.
|
inline |
Default implementation of the SMP subtraction assignment of a vector to a sparse vector.
lhs | The target left-hand side sparse vector. |
rhs | The right-hand side vector to be subtracted. |
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.
|
inline |
Swapping the contents of two unique arrays.
a | The first unique array to be swapped. |
b | The second unique array to be swapped. |
no-throw | guarantee. |
|
inline |
Swapping the contents of two unique pointers.
a | The first unique pointer to be swapped. |
b | The second unique pointer to be swapped. |
no-throw | guarantee. |
|
inline |
Swapping the contents of two pointer vectors.
a | The first pointer vector to be swapped. |
b | The second pointer vector to be swapped. |
no-throw | guarantee. |
const bool blaze::aligned = true |
Alignment flag for aligned subvectors and submatrices.
Via this flag it is possible to specify subvectors and submatrices as aligned. The following example demonstrates the setup of an aligned subvector:
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
in case of column-major order the elements are stored in the order
The following example demonstrates the setup of this matrix:
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
in case of row-major order the elements are stored in the order
The following example demonstrates the setup of this matrix:
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:
const bool blaze::unaligned = false |
Alignment flag for unaligned subvectors and submatrices.
Via this flag it is possible to specify subvectors and submatrices as unaligned. The following example demonstrates the setup of an unaligned subvector: