►CA | |
Cblaze::SmallArray< T, N, A > | Implementation of a dynamic array with small array optimization.The SmallArray class template is a hybrid data structure between a static array and a dynamic array. It provides static, in-place memory for up to N elements of type T, but can grow beyond this size by allocating dynamic memory via its allocator of type A |
Cblaze::Abs | Generic wrapper for the abs() function |
Cblaze::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 |
Cblaze::Acos | Generic wrapper for the acos() function |
Cblaze::Acosh | Generic wrapper for the acosh() function |
Cblaze::Add | Generic wrapper for the addition operator |
Cblaze::AddAssign | Generic wrapper for addition assignment |
Cblaze::AddConst< T > | Addition of a top level 'const' qualifier.The AddConst type trait adds a top level 'const' qualifier to the given type T |
Cblaze::AddCV< T > | 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 |
Cblaze::AddPointer< T > | Addition of a top level pointer.The AddPointer type trait adds a top level pointer to the given type T. It has the same effect as blaze::RemovePointer<T>::Type* |
Cblaze::AddReference< T > | 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 |
Cblaze::AddTrait< T1, T2, typename > | Base template for the AddTrait class |
Cblaze::AddVolatile< T > | Addition of a top level 'volatile' qualifier.The AddVolatile type trait adds a top level 'volatile' qualifier to the given type T |
Cblaze::AlignedAllocator< Type > | 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 |
Cblaze::AlignedArray< Type, N, Alignment > | 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: |
Cblaze::AlignedArray< Type, M *NN, Alignment > | |
Cblaze::AlignedArray< Type, NN, Alignment > | |
Cblaze::And | Generic wrapper for the logical AND operator |
Cblaze::AndAssign | Generic wrapper for bitwise AND assignment |
Cblaze::Append< TL, T > | Appending a type to a type list.The Append class can be used to append the data type T to a type list TL. In order to append a data type, the Append class has to be instantiated for a particular type list and another type. The following example gives an impression of the use of the Append class: |
Cblaze::Archive< Stream > | 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 |
Cblaze::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! |
Cblaze::Asin | Generic wrapper for the asin() function |
Cblaze::Asinh | Generic wrapper for the asinh() function |
Cblaze::Assign | Generic wrapper for plain assignment |
Cblaze::Atan | Generic wrapper for the atan() function |
Cblaze::Atan2 | Generic wrapper for the atan2() function |
Cblaze::Atanh | Generic wrapper for the atanh() function |
Cblaze::BandData< CBAs > | Auxiliary class template for the data members of the Band class.The auxiliary BandData class template represents an abstraction of the data members of the Band class template. The necessary set of data member is selected depending on the number of compile time band arguments |
Cblaze::BandTrait< MT, CBAs > | Base template for the BandTrait class |
Cblaze::Bind1st< OP, A1 > | Generic wrapper for a binary operation with fixed 1st argument |
Cblaze::Bind2nd< OP, A2 > | Generic wrapper for a binary operation with fixed 2nd argument |
Cblaze::Bitand | Generic wrapper for the bitwise AND ('&') operator |
Cblaze::Bitor | Generic wrapper for the bitwise OR ('|') operator |
Cblaze::Bitxor | Generic wrapper for the bitwise XOR ('^') operator |
Cblaze::MemoryPool< Type, Blocksize >::Block | Memory block within the memory bool |
Cblaze::Bools<... > | Auxiliary tool for unwrapping a pack of variadic boolean values.The Bools class template represents an auxiliary tool for unwrapping a pack of variadic boolean values |
Cblaze::Cbrt | Generic wrapper for the cbrt() function |
Cblaze::Ceil | Generic wrapper for the ceil() function |
Cblaze::Check< C > | Template for the blaze::checked and blaze::unchecked instances.blaze::Check is the template for the blaze::checked and blaze::unchecked instance, which is an optional token for the creation of views. It can be used to enforce or skip all runtime checks during the creation of a view (subvectors, submatrices, rows, columns, bands, ...) |
Cblaze::Clamp< DT > | Generic wrapper for the clamp() function |
Cblaze::Clear | Generic wrapper for the clear() function |
Cblaze::ColumnData< CCAs > | Auxiliary class template for the data members of the Column class.The auxiliary ColumnData class template represents an abstraction of the data members of the Column class template. The necessary set of data members is selected depending on the number of compile time column arguments |
Cblaze::ColumnsTrait< MT, N > | Base template for the ColumnsTrait class |
Cblaze::ColumnTrait< MT, CCAs > | Base template for the ColumnTrait class |
Cblaze::CommonType< T > | Deduction of a type common to several types.The CommonType type trait deduces the result type of a mixed-mode arithmetic expression between all types T..., that is the type all T... can be implicitly converted to. Note that cv and reference qualifiers are generally ignored |
Cblaze::complex | Complex data type of the Blaze library |
Cblaze::ComplexProxy< PT, CT > | Proxy backend for complex types.The ComplexProxy class serves as a backend for the Proxy class. It is used in case the data type represented by the proxy is a complex number and augments the Proxy interface by the complete interface required of complex numbers |
Cblaze::Conj | Generic wrapper for the conj() function |
Cblaze::DMatSMatSchurExpr< MT1, MT2 >::ConstIterator | Iterator over the elements of the dense matrix/sparse matrix Schur product expression |
Cblaze::DMatTSMatSchurExpr< MT1, MT2 >::ConstIterator | Iterator over the elements of the dense matrix/sparse matrix Schur product expression |
Cblaze::DVecDVecAddExpr< VT1, VT2, TF >::ConstIterator | Iterator over the elements of the dense vector |
Cblaze::DVecDVecDivExpr< VT1, VT2, TF >::ConstIterator | Iterator over the elements of the dense vector |
Cblaze::DVecDVecMapExpr< VT1, VT2, OP, TF >::ConstIterator | Iterator over the elements of the dense vector map expression |
Cblaze::DVecDVecMultExpr< VT1, VT2, TF >::ConstIterator | Iterator over the elements of the dense vector |
Cblaze::DVecDVecOuterExpr< VT1, VT2 >::ConstIterator | Iterator over the elements of the dense matrix |
Cblaze::DVecDVecSubExpr< VT1, VT2, TF >::ConstIterator | Iterator over the elements of the dense vector |
Cblaze::DVecScalarDivExpr< VT, ST, TF >::ConstIterator | Iterator over the elements of the dense vector |
Cblaze::IdentityMatrix< Type, SO >::ConstIterator | Iterator over the elements of the identity matrix |
Cblaze::DVecMapExpr< VT, OP, TF >::ConstIterator | Iterator over the elements of the dense vector map expression |
Cblaze::DVecScalarMultExpr< VT, ST, TF >::ConstIterator | Iterator over the elements of the dense vector |
Cblaze::DVecSVecMultExpr< VT1, VT2, TF >::ConstIterator | Iterator over the elements of the dense vector-sparse vector multiplication expression |
Cblaze::DVecSVecOuterExpr< VT1, VT2 >::ConstIterator | Iterator over the elements of the dense vector-sparse vector outer product expression |
Cblaze::SMatMapExpr< MT, OP, SO >::ConstIterator | Iterator over the elements of the sparse matrix map expression |
Cblaze::SMatDMatSchurExpr< MT1, MT2 >::ConstIterator | Iterator over the elements of the sparse matrix/dense matrix Schur product expression |
Cblaze::SMatReduceExpr< MT, OP, rowwise >::ConstIterator | Iterator over the elements of the dense vector |
Cblaze::SMatScalarDivExpr< MT, ST, SO >::ConstIterator | Iterator over the elements of the sparse matrix/scalar division expression |
Cblaze::SMatScalarMultExpr< MT, ST, SO >::ConstIterator | Iterator over the elements of the sparse matrix/scalar multiplication expression |
Cblaze::SMatVarExpr< MT, rowwise >::ConstIterator | Iterator over the elements of the dense vector |
Cblaze::SVecDVecDivExpr< VT1, VT2, TF >::ConstIterator | Iterator over the elements of the sparse vector-dense vector division expression |
Cblaze::SVecDVecMultExpr< VT1, VT2, TF >::ConstIterator | Iterator over the elements of the sparse vector-dense vector multiplication expression |
Cblaze::SVecDVecOuterExpr< VT1, VT2 >::ConstIterator | Iterator over the elements of the sparse vector-dense vector outer product expression |
Cblaze::SVecMapExpr< VT, OP, TF >::ConstIterator | Iterator over the elements of the sparse vector map expression |
Cblaze::SVecScalarDivExpr< VT, ST, TF >::ConstIterator | Iterator over the elements of the sparse vector/scalar multiplication expression |
Cblaze::TSMatDMatSchurExpr< MT1, MT2 >::ConstIterator | Iterator over the elements of the sparse matrix/dense matrix Schur product expression |
Cblaze::SVecScalarMultExpr< VT, ST, TF >::ConstIterator | Iterator over the elements of the sparse vector/scalar multiplication expression |
Cblaze::DMatDMatAddExpr< MT1, MT2, SO >::ConstIterator | Iterator over the elements of the dense matrix |
Cblaze::DMatDMatMapExpr< MT1, MT2, OP, SO >::ConstIterator | Iterator over the elements of the dense matrix map expression |
Cblaze::DMatDMatSchurExpr< MT1, MT2, SO >::ConstIterator | Iterator over the elements of the dense matrix |
Cblaze::DMatDMatSubExpr< MT1, MT2, SO >::ConstIterator | Iterator over the elements of the dense matrix |
Cblaze::DMatMapExpr< MT, OP, SO >::ConstIterator | Iterator over the elements of the dense matrix map expression |
Cblaze::DMatReduceExpr< MT, OP, rowwise >::ConstIterator | Iterator over the elements of the dense vector |
Cblaze::DMatScalarDivExpr< MT, ST, SO >::ConstIterator | Iterator over the elements of the dense matrix |
Cblaze::DMatScalarMultExpr< MT, ST, SO >::ConstIterator | Iterator over the elements of the dense matrix |
Cblaze::Contains< TL, T > | Searching a type list.The Contains class can be used to search the type list for a particular type Type. In contrast to the IndexOf class, the Contains class does not evaluate the index of the type but only checks whether or not the type is contained in the type list. Additionally, in contrast to the ContainsRelated class, the Contains class strictly searches for the given type Type and not for a related data type. In case the type is contained in the type list, the value member enumeration is set to true, else it is set to false. In order to check whether a type is part of a type list, the Contains class has to be instantiated for a particular type list and another type. The following example gives an impression of the use of the Contains class: |
Cblaze::ContainsRelated< TL, T > | Searching a type list.The ContainsRelated class can be used to search the type list for a type related to Type. In contrast to the Contains class, the ContainsRelated class only searches for a type the given data type Type can be converted to. In case a related type is found in the type list, the value member enumeration is set to true, else it is set to false. In order to check whether a related type is contained in the type list, the ContainsRelated class has to be instantiated for a particular type list and another type. The following example gives an impression of the use of the ContainsRelated class: |
Cblaze::Cos | Generic wrapper for the cos() function |
Cblaze::Cosh | Generic wrapper for the cosh() function |
Cblaze::timing::CpuPolicy | Timing policy for the measurement of the CPU time.The CpuPolicy class represents the timing policy for CPU time measurements that can be used in combination with the Timer class template. This combination is realized with the CpuTimer type definition |
Cblaze::CrossTrait< T1, T2, typename > | Base template for the CrossTrait class |
Cblaze::CTrans | Generic wrapper for the ctrans() function |
Cblaze::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! |
Cblaze::Decay< T > | Applies the type conversions for by-value function arguments.This type trait applies the type conversions that are used for by-value function arguments. This conversions include lvalue-to-rvalue, array-to-pointer, and function-to-pointer implicit conversions to the type T , and the removal of top level cv-qualifiers |
Cblaze::DeclDiag | Generic wrapper for the decldiag() function |
Cblaze::DeclDiagTrait< MT > | Base template for the DeclDiagTrait class |
Cblaze::DeclHerm | Generic wrapper for the declherm() function |
Cblaze::DeclHermTrait< MT > | Base template for the DeclHermTrait class |
Cblaze::DeclId | Generic wrapper for the declid() function |
Cblaze::DeclIdTrait< MT > | Base template for the DeclIdTrait class |
Cblaze::DeclLow | Generic wrapper for the decllow() function |
Cblaze::DeclLowTrait< MT > | Base template for the DeclLowTrait class |
Cblaze::DeclSym | Generic wrapper for the declsym() function |
Cblaze::DeclSymTrait< MT > | Base template for the DeclSymTrait class |
Cblaze::DeclUpp | Generic wrapper for the declupp() function |
Cblaze::DeclUppTrait< MT > | Base template for the DeclUppTrait class |
Cblaze::DeclZero | Generic wrapper for the declzero() function |
Cblaze::DeclZeroTrait< T > | Base template for the DeclZeroTrait class |
Cblaze::DefaultDelete< Type > | 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: |
Cblaze::DefaultProxy< PT, RT > | Default proxy backend for built-in and alternate user-specific class types.The DefaultProxy class serves as a backend for the Proxy class. It is used in case the data type represented by the proxy is a built-in or alternate user-specific class type. This proxy does not augment the Proxy interface by any additional interface |
Cblaze::DenseIterator< Type, AF > | Implementation of a generic iterator for dense vectors and matrices.The DenseIterator represents a generic random-access iterator that can be used for dense vectors and specific rows/columns of dense matrices |
Cblaze::Dependency< T > | 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: |
Cblaze::DerestrictTrait< T > | Evaluation of the return type of the derestrict function.Via this type trait it is possible to evaluate the resulting return type of the derestrict function. Given the non-const vector or matrix type T, the nested type Type corresponds to the resulting return type. In case T is neither a dense or sparse vector or matrix type, the resulting Type is set to INVALID_TYPE |
Cblaze::DiagonalMatrix< MT, SO, DF > | Matrix adapter for diagonal matrices |
Cblaze::DisableIf< Condition, T > | 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 |
Cblaze::Div | Generic wrapper for the division operator |
Cblaze::DivAssign | Generic wrapper for division assignment |
Cblaze::DivTrait< T1, T2, typename > | Base template for the DivTrait class |
Cblaze::DMatExpExpr< typename, bool > | |
Cblaze::DMatReduceExpr< MT, OP, RF > | Base template for row-major dense matrix partial reduction operations.The DMatReduceExpr class represents the compile time expression for partial reduction operations of row-major dense matrices |
Cblaze::ElementsTrait< VT, N > | Base template for the ElementsTrait class |
Cblaze::EmptyType | Empty data type for utility purposes |
Cblaze::EnableIf< Condition, T > | 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 |
Cblaze::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 |
Cblaze::Erase< TL, T > | Erasing the first occurrence of a type from a type list.The Erase class can be used to erase the first occurrence of data type T from a type list TL. In order to erase the first occurrence of a data type, the Erase class has to be instantiated for a particular type list and another type. The following example gives an impression of the use of the Erase class: |
Cblaze::EraseAll< TL, T > | Erasing all occurrences of a type from a type list.The EraseAll class can be used to erase all occurrences of data type Type from a type list TList. In order to erase all occurrences of a data type, the EraseAll class has to be instantiated for a particular type list and another type. The following example gives an impression of the use of the EraseAll class: |
Cblaze::Erf | Generic wrapper for the erf() function |
Cblaze::Erfc | Generic wrapper for the erfc() function |
Cblaze::Eval | Generic wrapper for the eval() function |
Cblaze::Exp | Generic wrapper for the exp() function |
Cblaze::Exp10 | Generic wrapper for the exp10() function |
Cblaze::Exp2 | Generic wrapper for the exp2() function |
Cblaze::ExpandExprData< CEAs > | Auxiliary class template for the data members of expressions expression classes.The auxiliary ExpandExprData class template represents an abstraction of the data members of expansion expression template classes. The necessary set of data member is selected depending on the number of compile time expansion arguments |
►Cblaze::ExpandExprData< CEAs... > | |
Cblaze::DVecExpandExpr< VT, TF, CEAs > | Expression object for dense vector expansion.The DVecExpandExpr class represents the compile time expression for expansions of dense vectors |
Cblaze::SVecExpandExpr< VT, TF, CEAs > | Expression object for sparse vector expansion.The SVecExpandExpr class represents the compile time expression for expansions of sparse vectors |
Cblaze::ExpandTrait< T, CEAs > | Base template for the ExpandTrait class |
Cblaze::Floor | Generic wrapper for the floor() function |
Cblaze::MemoryPool< Type, Blocksize >::FreeObject | A single element of the free list of the memory pool |
Cblaze::FunctionTrace | RAII object for function tracing.The FunctionTrace class is an auxiliary helper class for the tracing of function calls. It is implemented as a wrapper around std::cerr and is responsible for the atomicity of the output of trace information |
Cblaze::Greater | Generic wrapper for the greater-than relational operator |
►CHasAbsHelper | |
Cblaze::HasAbs< T, typename > | Availability of the abs() operation for the given data types.This type trait provides the information whether the abs() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CHasAcosHelper | |
Cblaze::HasAcos< T, typename > | Availability of the acos() operation for the given data types.This type trait provides the information whether the acos() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CHasAcoshHelper | |
Cblaze::HasAcosh< T, typename > | Availability of the acosh() operation for the given data types.This type trait provides the information whether the acosh() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CHasAddHelper | |
Cblaze::HasAdd< T1, T2, typename > | Availability of an addition operator for the given data types.This type trait provides the information whether an addition operator (i.e. operator+) exists for the two given data types T1 and T2 (taking the cv-qualifiers into account). In case the operator is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CHasAsinHelper | |
Cblaze::HasAsin< T, typename > | Availability of the asin() operation for the given data types.This type trait provides the information whether the asin() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CHasAsinhHelper | |
Cblaze::HasAsinh< T, typename > | Availability of the asinh() operation for the given data types.This type trait provides the information whether the asinh() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CHasAtan2Helper | |
Cblaze::HasAtan2< T1, T2, typename > | Availability of the atan2() operation for the given data types.This type trait provides the information whether the atan2() operation exists for the two given data types T1 and T2 (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CHasAtanHelper | |
Cblaze::HasAtan< T, typename > | Availability of the atan() operation for the given data types.This type trait provides the information whether the atan() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CHasAtanhHelper | |
Cblaze::HasAtanh< T, typename > | Availability of the atanh() operation for the given data types.This type trait provides the information whether the atanh() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CHasCbrtHelper | |
Cblaze::HasCbrt< T, typename > | Availability of the cbrt() operation for the given data types.This type trait provides the information whether the cbrt() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CHasCeilHelper | |
Cblaze::HasCeil< T, typename > | Availability of the ceil() operation for the given data types.This type trait provides the information whether the ceil() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CHasClampHelper | |
Cblaze::HasClamp< T, typename > | Availability of the clamp() operation for the given data types.This type trait provides the information whether the clamp() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CHasConjHelper | |
Cblaze::HasConj< T, typename > | Availability of the conj() operation for the given data types.This type trait provides the information whether the conj() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CHasCosHelper | |
Cblaze::HasCos< T, typename > | Availability of the cos() operation for the given data types.This type trait provides the information whether the cos() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CHasCoshHelper | |
Cblaze::HasCosh< T, typename > | Availability of the cosh() operation for the given data types.This type trait provides the information whether the cosh() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
Cblaze::HasCyclicDependency< T, TL, C > | |
►CHasDivHelper | |
Cblaze::HasDiv< T1, T2, typename > | Availability of a division operator for the given data types.This type trait provides the information whether a division operator (i.e. operator/) exists for the two given data types T1 and T2 (taking the cv-qualifiers into account). In case the operator is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CHasErfcHelper | |
Cblaze::HasErfc< T, typename > | Availability of the erfc() operation for the given data types.This type trait provides the information whether the erfc() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CHasErfHelper | |
Cblaze::HasErf< T, typename > | Availability of the erf() operation for the given data types.This type trait provides the information whether the erf() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CHasExp10Helper | |
Cblaze::HasExp10< T, typename > | Availability of the exp10() operation for the given data types.This type trait provides the information whether the exp10() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CHasExp2Helper | |
Cblaze::HasExp2< T, typename > | Availability of the exp2() operation for the given data types.This type trait provides the information whether the exp2() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CHasExpHelper | |
Cblaze::HasExp< T, typename > | Availability of the exp() operation for the given data types.This type trait provides the information whether the exp() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CHasFloorHelper | |
Cblaze::HasFloor< T, typename > | Availability of the floor() operation for the given data types.This type trait provides the information whether the floor() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CHasHypotHelper | |
Cblaze::HasHypot< T1, T2, typename > | Availability of the hypot() operation for the given data types.This type trait provides the information whether the hypot() operation exists for the two given data types T1 and T2 (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CHasImagHelper | |
Cblaze::HasImag< T, typename > | Availability of the imag() operation for the given data types.This type trait provides the information whether the imag() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CHasInvCbrtHelper | |
Cblaze::HasInvCbrt< T, typename > | Availability of the invcbrt() operation for the given data types.This type trait provides the information whether the invcbrt() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CHasInvSqrtHelper | |
Cblaze::HasInvSqrt< T, typename > | Availability of the invsqrt() operation for the given data types.This type trait provides the information whether the invsqrt() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CHasLog10Helper | |
Cblaze::HasLog10< T, typename > | Availability of the log10() operation for the given data types.This type trait provides the information whether the log10() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CHasLog2Helper | |
Cblaze::HasLog2< T, typename > | Availability of the log2() operation for the given data types.This type trait provides the information whether the log2() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CHasLogHelper | |
Cblaze::HasLog< T, typename > | Availability of the log() operation for the given data types.This type trait provides the information whether the log() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CHasMaxHelper | |
Cblaze::HasMax< T1, T2, typename > | Availability of a max() operation for the given data types.This type trait provides the information whether a binary max() operation exists for the two given data types T1 and T2 (taking the cv-qualifiers into account). In case a binary max() operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CHasMinHelper | |
Cblaze::HasMin< T1, T2, typename > | Availability of a min() operation for the given data types.This type trait provides the information whether a binary min() operation exists for the two given data types T1 and T2 (taking the cv-qualifiers into account). In case a binary min() operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CHasMultHelper | |
Cblaze::HasMult< T1, T2, typename > | Availability of a multiplication operator for the given data types.This type trait provides the information whether a multiplication operator (i.e. operator*) exists for the two given data types T1 and T2 (taking the cv-qualifiers into account). In case the operator is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CHasPowHelper | |
Cblaze::HasPow< T1, T2, typename > | Availability of the pow() operation for the given data types.This type trait provides the information whether the pow() operation exists for the two given data types T1 and T2 (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CHasRealHelper | |
Cblaze::HasReal< T, typename > | Availability of the real() operation for the given data types.This type trait provides the information whether the real() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CHasRoundHelper | |
Cblaze::HasRound< T, typename > | Availability of the round() operation for the given data types.This type trait provides the information whether the round() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CHasSignHelper | |
Cblaze::HasSign< T, typename > | Availability of the sign() operation for the given data types.This type trait provides the information whether the sign() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CHasSinHelper | |
Cblaze::HasSin< T, typename > | Availability of the sin() operation for the given data types.This type trait provides the information whether the sin() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CHasSinhHelper | |
Cblaze::HasSinh< T, typename > | Availability of the sinh() operation for the given data types.This type trait provides the information whether the sinh() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CHasSqrtHelper | |
Cblaze::HasSqrt< T, typename > | Availability of the sqrt() operation for the given data types.This type trait provides the information whether the sqrt() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CHasSubHelper | |
Cblaze::HasSub< T1, T2, typename > | Availability of a subtraction operator for the given data types.This type trait provides the information whether a subtraction operator (i.e. operator+) exists for the two given data types T1 and T2 (taking the cv-qualifiers into account). In case the operator is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CHasTanHelper | |
Cblaze::HasTan< T, typename > | Availability of the tan() operation for the given data types.This type trait provides the information whether the tan() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CHasTanhHelper | |
Cblaze::HasTanh< T, typename > | Availability of the tanh() operation for the given data types.This type trait provides the information whether the tanh() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CHasTruncHelper | |
Cblaze::HasTrunc< T, typename > | Availability of the trunc() operation for the given data types.This type trait provides the information whether the trunc() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
Cblaze::HermitianMatrix< MT, SO, DF > | Matrix adapter for Hermitian matrices |
Cblaze::HighType< T1, T2, typename > | Base template for the HighType type trait |
Cblaze::Hypot | Generic wrapper for the hypot() function |
Cblaze::If< Condition, T1, T2 > | Compile time type selection.The If class template selects one of the two given types T1 and T2 depending on the Condition template argument. In case the Condition compile time constant expression evaluates to true, the member type definition Type is set to T1. In case Condition evaluates to false, Type is set to T2 |
►CIf_t | |
Cblaze::Declaration< T > | Base class for all declaration expression templates.The Declaration class serves as a tag for all declaration expression templates. All classes that represent a declaration and that are used within the expression template environment of the Blaze library have to derive publicly from this class in order to qualify as declaration expression template. Only in case a class is derived publicly from the Declaration base class, the IsDeclaration type trait recognizes the class as valid declaration expression template |
Cblaze::Proxy< PT, RT > | Proxy base class.The Proxy class is a base class for all proxy classes within the Blaze library that may represent non-numeric data types (vectors, matrices, ...). It augments the interface of the deriving proxy class depending on the data type represented by the proxy. In addition, it provides an abstraction from the actual type of the proxy, but enables a type-safe conversion back to this type via the 'Curiously Recurring Template Pattern' (CRTP) |
►Cblaze::Declaration< MT > | |
Cblaze::DMatDeclDiagExpr< MT, SO > | Expression object for the explicit diagonal declaration of dense matrices.The DMatDeclDiagExpr class represents the compile time expression for the explicit diagonal declaration of a dense matrix |
Cblaze::DMatDeclHermExpr< MT, SO > | Expression object for the explicit Hermitian declaration of dense matrices.The DMatDeclHermExpr class represents the compile time expression for the explicit Hermitian declaration of a dense matrix |
Cblaze::DMatDeclLowExpr< MT, SO > | Expression object for the explicit lower declaration of dense matrices.The DMatDeclLowExpr class represents the compile time expression for the explicit lower declaration of a dense matrix |
Cblaze::DMatDeclSymExpr< MT, SO > | Expression object for the explicit symmetry declaration of dense matrices.The DMatDeclSymExpr class represents the compile time expression for the explicit symmetry declaration of a dense matrix |
Cblaze::DMatDeclUppExpr< MT, SO > | Expression object for the explicit upper declaration of dense matrices.The DMatDeclUppExpr class represents the compile time expression for the explicit upper declaration of a dense matrix |
Cblaze::SMatDeclDiagExpr< MT, SO > | Expression object for the explicit diagonal declaration of sparse matrices.The SMatDeclDiagExpr class represents the compile time expression for the explicit diagonal declaration of a sparse matrix |
Cblaze::SMatDeclHermExpr< MT, SO > | Expression object for the explicit Hermitian declaration of sparse matrices.The SMatDeclHermExpr class represents the compile time expression for the explicit Hermitian declaration of a sparse matrix |
Cblaze::SMatDeclLowExpr< MT, SO > | Expression object for the explicit lower declaration of sparse matrices.The SMatDeclLowExpr class represents the compile time expression for the explicit lower declaration of a sparse matrix |
Cblaze::SMatDeclSymExpr< MT, SO > | Expression object for the explicit symmetry declaration of sparse matrices.The SMatDeclSymExpr class represents the compile time expression for the explicit symmetry declaration of a sparse matrix |
Cblaze::SMatDeclUppExpr< MT, SO > | Expression object for the explicit upper declaration of sparse matrices.The SMatDeclUppExpr class represents the compile time expression for the explicit upper declaration of a sparse matrix |
►Cblaze::Proxy< DiagonalProxy< MT >, ElementType_t< MT > > | |
Cblaze::DiagonalProxy< MT > | Access proxy for diagonal matrices.The DiagonalProxy provides controlled access to the elements of a non-const diagonal matrix. It guarantees that the diagonal matrix invariant is not violated, i.e. that elements in the lower and upper part of the matrix remain default values. The following example illustrates this by means of a dense diagonal matrix: |
►Cblaze::Proxy< HermitianProxy< MT > > | |
Cblaze::HermitianProxy< MT > | Access proxy for Hermitian matrices.The HermitianProxy provides controlled access to the elements of a non-const Hermitian matrix. It guarantees that a modification of element of the accessed matrix is also applied to element . The following example illustrates this by means of a dense Hermitian matrix: |
►Cblaze::Proxy< HermitianValue< MT > > | |
Cblaze::HermitianValue< MT > | Representation of two synchronized values within a sparse Hermitian matrix.The HermitianValue class represents two synchronized values within a sparse Hermitian matrix. It guarantees that a modification of value via iterator is also applied to the value . The following example illustrates this by means of a sparse Hermitian matrix: |
►Cblaze::Proxy< LowerProxy< MT >, ElementType_t< MT > > | |
Cblaze::LowerProxy< MT > | Access proxy for lower triangular matrices.The LowerProxy provides controlled access to the elements of a non-const lower triangular matrix. It guarantees that the lower matrix invariant is not violated, i.e. that elements in the upper part of the matrix remain default values. The following example illustrates this by means of a dense lower matrix: |
►Cblaze::Proxy< MatrixAccessProxy< MT >, ElementType_t< MT > > | |
Cblaze::MatrixAccessProxy< MT > | Access proxy for sparse, matrices.The MatrixAccessProxy provides safe access to the elements of a non-const sparse matrices.
The proxied access to the elements of a sparse matrix is necessary since it may be possible that several insertion operations happen in the same statement. The following code illustrates this with two examples by means of the CompressedMatrix class: |
►Cblaze::Proxy< NonNumericProxy< MT >, ValueType_t< ElementType_t< MT > > > | |
Cblaze::NonNumericProxy< MT > | 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 of the accessed matrix is also applied to element . The following example illustrates this by means of a sparse symmetric matrix with StaticVector elements: |
►Cblaze::Proxy< NumericProxy< MT > > | |
Cblaze::NumericProxy< MT > | 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 of the accessed matrix is also applied to element . The following example illustrates this by means of a dense symmetric matrix: |
►Cblaze::Proxy< StrictlyLowerProxy< MT >, ElementType_t< MT > > | |
Cblaze::StrictlyLowerProxy< MT > | Access proxy for strictly lower triangular matrices.The StrictlyLowerProxy provides controlled access to the elements of a non-const strictly lower triangular matrix. It guarantees that the strictly lower matrix invariant is not violated, i.e. that elements on the diagonal and in the upper part of the matrix remain 0. The following example illustrates this by means of a dense strictly lower triangular matrix: |
►Cblaze::Proxy< StrictlyUpperProxy< MT >, ElementType_t< MT > > | |
Cblaze::StrictlyUpperProxy< MT > | Access proxy for strictly upper triangular matrices.The StrictlyUpperProxy provides controlled access to the elements of a non-const strictly upper triangular matrix. It guarantees that the strictly upper matrix invariant is not violated, i.e. that elements on the diagonal and in the lower part of the matrix remain 0. The following example illustrates this by means of a dense strictly upper triangular matrix: |
►Cblaze::Proxy< SymmetricValue< MT > > | |
Cblaze::SymmetricValue< MT > | Representation of two synchronized values within a sparse symmetric matrix.The SymmetricValue class represents two synchronized values within a sparse symmetric matrix. It guarantees that a modification of value via iterator is also applied to the value . The following example illustrates this by means of a sparse symmetric matrix: |
►Cblaze::Proxy< UniLowerProxy< MT > > | |
Cblaze::UniLowerProxy< MT > | Access proxy for lower unitriangular matrices.The UniLowerProxy provides controlled access to the elements of a non-const lower unitriangular matrix. It guarantees that the unilower matrix invariant is not violated, i.e. that elements in the upper part of the matrix remain 0 and the diagonal elements remain 1. The following example illustrates this by means of a dense lower unitriangular matrix: |
►Cblaze::Proxy< UniLowerValue< MT > > | |
Cblaze::UniLowerValue< MT > | Representation of a value within a sparse lower unitriangular matrix.The UniLowerValue class represents a single value within a sparse lower unitriangular matrix. It guarantees that the unilower matrix invariant is not violated, i.e. that elements in the upper part of the matrix remain 0 and the diagonal elements remain 1. The following example illustrates this by means of a sparse lower unitriangular matrix: |
►Cblaze::Proxy< UniUpperProxy< MT > > | |
Cblaze::UniUpperProxy< MT > | Access proxy for upper unitriangular matrices.The UniUpperProxy provides controlled access to the elements of a non-const upper unitriangular matrix. It guarantees that the uniupper matrix invariant is not violated, i.e. that elements in the lower part of the matrix remain 0 and the diagonal elements remain 1. The following example illustrates this by means of a dense upper unitriangular matrix: |
►Cblaze::Proxy< UniUpperValue< MT > > | |
Cblaze::UniUpperValue< MT > | Representation of a value within a sparse upper unitriangular matrix.The UniUpperValue class represents a single value within a sparse upper unitriangular matrix. It guarantees that the uniupper matrix invariant is not violated, i.e. that elements in the upper part of the matrix remain 0 and the diagonal elements remain 1. The following example illustrates this by means of a sparse upper unitriangular matrix: |
►Cblaze::Proxy< UpperProxy< MT >, ElementType_t< MT > > | |
Cblaze::UpperProxy< MT > | Access proxy for upper triangular matrices.The UpperProxy provides controlled access to the elements of a non-const upper triangular matrix. It guarantees that the upper matrix invariant is not violated, i.e. that elements in the lower part of the matrix remain default values. The following example illustrates this by means of a dense upper matrix: |
►Cblaze::Proxy< VectorAccessProxy< VT >, ElementType_t< VT > > | |
Cblaze::VectorAccessProxy< VT > | 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: |
Cblaze::Imag | Generic wrapper for the imag() function |
Cblaze::index_sequence | Index sequence type of the Blaze library |
Cblaze::IndexOf< TL, T > | Searching a type list.The IndexOf class can be used to search the type list for a particular type Type. In contrast to the Contains and the ContainsRelated classes, the IndexOf class evaluates the index of the given type in the type list. In case the type is contained in the type list, the value member represents the index of the queried type. Otherwise the value member is set to the length of the type list. In order to search for a type, the IndexOf class has to be instantiated for a particular type list and a search type. The following example gives an impression of the use of the IndexOf class: |
Cblaze::Indices | Auxiliary class for the generation of random indices |
Cblaze::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: |
Cblaze::initializer_list | Initializer list type of the Blaze library |
Cblaze::initializer_list< initializer_list< Type > > | |
Cblaze::initializer_list< Type > | |
Cblaze::InitializerIterator< Type > | Implementation of an iterator for (extended) initializer lists.The InitializerIterator represents a generic random-access iterator for (extended) initializer lists. It can be used for initializer lists representing dense vectors and specific rows of dense matrices |
Cblaze::int16_t | 16-bit signed integer type of the Blaze library |
Cblaze::int32_t | 32-bit signed integer type of the Blaze library |
Cblaze::int64_t | 64-bit signed integer type of the Blaze library |
Cblaze::int8_t | 8-bit signed integer type of the Blaze library |
Cblaze::integer_sequence | Integer sequence type of the Blaze library |
►Cintegral_constant | |
►Cblaze::IntegralConstant< T, N > | Generic wrapper for a compile time constant integral value.The IntegralConstant class template represents a generic wrapper for a compile time constant integral value. The value of an IntegralConstant can be accessed via the nested value (which is guaranteed to be of type T), the type can be accessed via the nested type definition ValueType |
Cblaze::All< TypeTrait, T1, T2, Ts > | Compile time type check.This type trait determines whether the given type trait TypeTrait evaluates to true for all given types Ts. If the expression |
Cblaze::AlwaysFalse< T > | Type dependent compile time false.This type trait represents a type dependent compile time false. For all possible types, the value member constant is set to false, the nested type definition Type is FalseType, and the class derives from FalseType |
Cblaze::AlwaysTrue< T > | Type dependent compile time true.This type trait represents a type dependent compile time true. For all possible types, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType |
Cblaze::Any< TypeTrait, T1, T2, Ts > | Compile time type check.This type trait determines whether the given type trait TypeTrait evaluates to true for at least one of the given types Ts. If the expression |
Cblaze::HasConstDataAccess< T > | Compile time check for low-level access to constant data.This type trait tests whether the given data type provides a low-level access to constant data via a const 'data' member function. In case the according member function is provided, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. Examples: |
Cblaze::HasMutableDataAccess< T > | Compile time check for low-level access to mutable data.This type trait tests whether the given data type provides a low-level access to mutable data via a non-const 'data' member function. In case the according member function is provided, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. Examples: |
Cblaze::HasSIMDAbs< T > | Availability of a SIMD absolute value operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD absolute value operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that AVX is available: |
Cblaze::HasSIMDAcos< T > | Availability of a SIMD inverse cosine operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD inverse cosine operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that the Intel SVML is available: |
Cblaze::HasSIMDAcosh< T > | Availability of a SIMD inverse hyperbolic cosine operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD inverse hyperbolic cosine operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that the Intel SVML is available: |
Cblaze::HasSIMDAdd< T1, T2, typename > | Availability of a SIMD addition for the given data types.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...), and the used compiler, this type trait provides the information whether a SIMD addition operation exists for the two given data types T1 and T2 (ignoring the cv-qualifiers). In case the SIMD addition is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that AVX is available: |
Cblaze::HasSIMDAsin< T > | Availability of a SIMD inverse sine operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD inverse sine operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that the Intel SVML is available: |
Cblaze::HasSIMDAsinh< T > | Availability of a SIMD inverse hyperbolic sine operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD hyperbolic inverse sine operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that the Intel SVML is available: |
Cblaze::HasSIMDAtan< T > | Availability of a SIMD inverse tangent operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD inverse tangent operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that the Intel SVML is available: |
Cblaze::HasSIMDAtan2< T1, T2 > | Availability of a SIMD inverse tangent operation for the given data types.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD multi-valued inverse tangent operation exists for the given data types T1 and T2 (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that the Intel SVML is available: |
Cblaze::HasSIMDAtanh< T > | Availability of a SIMD inverse hyperbolic tangent operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD inverse hyperbolic tangent operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that the Intel SVML is available: |
Cblaze::HasSIMDBitand< T1, T2 > | Availability of a SIMD bitwise AND ('&') for the given data types.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...), and the used compiler, this type trait provides the information whether a SIMD bitwise AND ('&') operation exists for the two given data types T1 and T2 (ignoring the cv-qualifiers). In case the SIMD bitwise AND is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that AVX2 is available: |
Cblaze::HasSIMDBitor< T1, T2 > | Availability of a SIMD bitwise OR ('|') for the given data types.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...), and the used compiler, this type trait provides the information whether a SIMD bitwise OR ('|') operation exists for the two given data types T1 and T2 (ignoring the cv-qualifiers). In case the SIMD bitwise OR is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that AVX2 is available: |
Cblaze::HasSIMDBitxor< T1, T2 > | Availability of a SIMD bitwise XOR ('^') for the given data types.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...), and the used compiler, this type trait provides the information whether a SIMD bitwise XOR ('^') operation exists for the two given data types T1 and T2 (ignoring the cv-qualifiers). In case the SIMD bitwise XOR is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that AVX2 is available: |
Cblaze::HasSIMDCbrt< T > | Availability of a SIMD cubic root operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD cubic root operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that the Intel SVML is available: |
Cblaze::HasSIMDCeil< T > | Availability of a SIMD ceil operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD ceil operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that AVX is available: |
Cblaze::HasSIMDConj< T > | Availability of a SIMD conjugate operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD conjugate operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that AVX is available: |
Cblaze::HasSIMDCos< T > | Availability of a SIMD cosine operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD cosine operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that the Intel SVML is available: |
Cblaze::HasSIMDCosh< T > | Availability of a SIMD hyperbolic cosine operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD hyperbolic cosine operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that the Intel SVML is available: |
Cblaze::HasSIMDDiv< T1, T2, typename > | Availability of a SIMD division for the given data types.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD division operation exists for the two given data types T1 and T2 (ignoring the cv-qualifiers). In case the SIMD division is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that AVX is available: |
Cblaze::HasSIMDEqual< T1, T2, typename > | Availability of a SIMD equality comparison for the given data types.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...), and the used compiler, this type trait provides the information whether a SIMD equality comparison exists for the two given data types T1 and T2 (ignoring the cv-qualifiers). In case the SIMD equality comparison is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that AVX is available: |
Cblaze::HasSIMDErf< T > | Availability of a SIMD error function (erf ) operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD error function (erf ) operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that the Intel SVML is available: |
Cblaze::HasSIMDErfc< T > | Availability of a SIMD complementary error function (erfc ) operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD complementary error function (erfc ) operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that the Intel SVML is available: |
Cblaze::HasSIMDExp< T > | Availability of a SIMD exp() operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD exp() operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that the Intel SVML is available: |
Cblaze::HasSIMDExp10< T > | Availability of a SIMD exp10() operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD exp10() operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that the Intel SVML is available: |
Cblaze::HasSIMDExp2< T > | Availability of a SIMD exp2() operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD exp2() operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that the Intel SVML is available: |
Cblaze::HasSIMDFloor< T > | Availability of a SIMD floor operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD floor operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that AVX is available: |
Cblaze::HasSIMDHypot< T1, T2 > | Availability of a SIMD hypotenous operation for the given data types.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD hypotenous operation exists for the given data types T1 and T2 (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that the Intel SVML is available: |
Cblaze::HasSIMDInvCbrt< T > | Availability of a SIMD inverse cubic root operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD inverse cubic root operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that the Intel SVML is available: |
Cblaze::HasSIMDInvSqrt< T > | Availability of a SIMD inverse square root operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD inverse square root operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that the Intel SVML is available: |
Cblaze::HasSIMDLog< T > | Availability of a SIMD natural logarithm operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD natural logarithm operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that the Intel SVML is available: |
Cblaze::HasSIMDLog10< T > | Availability of a SIMD common logarithm operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD common logarithm operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that the Intel SVML is available: |
Cblaze::HasSIMDLog2< T > | Availability of a SIMD binary logarithm operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD binary logarithm operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that the Intel SVML is available: |
Cblaze::HasSIMDMax< T1, T2, typename > | Availability of a SIMD max operation for the given data types.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...), and the used compiler, this type trait provides the information whether a SIMD max operation exists for the two given data types T1 and T2 (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that AVX is available: |
Cblaze::HasSIMDMin< T1, T2, typename > | Availability of a SIMD min operation for the given data types.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...), and the used compiler, this type trait provides the information whether a SIMD min operation exists for the two given data types T1 and T2 (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that AVX is available: |
Cblaze::HasSIMDMult< T1, T2, typename > | Availability of a SIMD multiplication for the given data types.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD multiplication operation exists for the two given data types T1 and T2 (ignoring the cv-qualifiers). In case the SIMD multiplication is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that AVX is available: |
Cblaze::HasSIMDPow< T1, T2 > | Availability of a SIMD power operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD power operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that the Intel SVML is available: |
Cblaze::HasSIMDRound< T > | Availability of a SIMD round operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD round operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that AVX is available: |
Cblaze::HasSIMDShiftLI< T > | Availability of a SIMD uniform left-shift for the given data types.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...), and the used compiler, this type trait provides the information whether a SIMD uniform left-shift operation exists for the two given data types T1 and T2 (ignoring the cv-qualifiers). In case the SIMD uniform left-shift is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that AVX2 is available: |
Cblaze::HasSIMDShiftLV< T1, T2 > | Availability of an SIMD elementwise left-shift for the given data types.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...), and the used compiler, this type trait provides the information whether an SIMD elementwise left-shift operation exists for the two given data types T1 and T2 (ignoring the cv-qualifiers). In case the SIMD elementwise left-shift is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that AVX2 is available: |
Cblaze::HasSIMDShiftRI< T > | Availability of a SIMD uniform right-shift for the given data types.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...), and the used compiler, this type trait provides the information whether a SIMD uniform right-shift operation exists for the two given data types T1 and T2 (ignoring the cv-qualifiers). In case the SIMD uniform right-shift is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that AVX2 is available: |
Cblaze::HasSIMDShiftRV< T1, T2 > | Availability of a SIMD elementwise right-shift for the given data types.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...), and the used compiler, this type trait provides the information whether an SIMD elementwise right-shift operation exists for the two given data types T1 and T2 (ignoring the cv-qualifiers). In case the SIMD elementwise right-shift is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that AVX2 is available: |
Cblaze::HasSIMDSign< T > | Availability of a SIMD sign operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD sign operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that AVX is available: |
Cblaze::HasSIMDSin< T > | Availability of a SIMD sine operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD sine operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that the Intel SVML is available: |
Cblaze::HasSIMDSinh< T > | Availability of a SIMD hyperbolic sine operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD hyperbolic sine operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that the Intel SVML is available: |
Cblaze::HasSIMDSqrt< T > | Availability of a SIMD square root operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD square root operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that AVX is available: |
Cblaze::HasSIMDSub< T1, T2, typename > | Availability of a SIMD subtraction for the given data types.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD subtraction operation exists for the two given data types T1 and T2 (ignoring the cv-qualifiers). In case the SIMD subtraction is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that AVX is available: |
Cblaze::HasSIMDTan< T > | Availability of a SIMD tangent operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD tangent operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that the Intel SVML is available: |
Cblaze::HasSIMDTanh< T > | Availability of a SIMD hyperbolic tangent operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD hyperbolic tangent operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that the Intel SVML is available: |
Cblaze::HasSIMDTrunc< T > | Availability of a SIMD trunc operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD trunc operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that the Intel SVML is available: |
Cblaze::HasSize< T, S > | Compile time size check.This class offers the possibility to test the size of a type at compile time. If the type T is exactly S bytes large, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
Cblaze::HaveSameSize< T1, T2 > | Compile time size check.This class offers the possibility to test the size of two types at compile time. If an object of type T1 has the same size as an object of type T2, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
Cblaze::IsAdaptor< T > | Compile time check for adaptors.This type trait tests whether the given template parameter is an adaptor type (for instance LowerMatrix, UpperMatrix, or SymmetricMatrix). In case the type is an adaptor type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example demonstrates this by means of the mentioned matrix adaptors: |
Cblaze::IsAligned< T > | Compile time check for the alignment of data types.This type trait tests whether the given data type guarantees to provide aligned data values with respect to the requirements of the available instruction set. For instance, vectorizable data types such as built-in and complex data types are required to be 16-bit aligned for SSE, 32-bit aligned for AVX, and 64-bit aligned for MIC. In case the data type is properly aligned, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. Examples: |
Cblaze::IsArithmetic< T > | Compile time check for arithmetic data types.This type trait tests whether or not the given template parameter is a (possibly cv-qualified) arithmetic (integral or floating point) data type. In case the type is an arithmetic type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType and the class derives from FalseType |
Cblaze::IsArray< T > | Compile time type check.The IsArray type trait tests whether or not the given template parameter is an array type. In case the given data type is an array type, the value member constant is set to true, the nested type definition Type is set to TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType and the class derives from FalseType |
Cblaze::IsAssignable< T, U > | Compile time type check.The IsAssignable type trait tests whether the expression |
Cblaze::IsBand< T > | Compile time check for bands.This type trait tests whether or not the given template parameter is a band (i.e. dense or sparse band). In case the type is a band, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
Cblaze::IsBaseOf< Base, Derived > | Compile time analysis of an inheritance relationship.This type trait tests for an inheritance relationship between the two types Base and Derived. If Derived is a type derived from Base or the same type as Base the value member contant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
Cblaze::IsBLASCompatible< T > | Compile time check for data types.This type trait tests whether or not the given template parameter is a data type compatible to the BLAS standard. The BLAS standard supports float , double , complex<float> and complex<double> values. If the type is BLAS compatible, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
Cblaze::IsBoolean< T > | Compile time check for boolean types.This type trait tests whether or not the given template parameter is of boolean type. In case the type is a boolean (ignoring the cv-qualifiers), the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
Cblaze::IsBuiltin< T > | Compile time check for built-in data types.This type trait tests whether or not the given template parameter is a built-in/fundamental data type. In case the type is a built-in type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
Cblaze::IsCharacter< T > | Compile time check for character types.This type trait tests whether or not the given template parameter is a character type (i.e., either char, signed char, unsigned char, or wchar_t, possibly cv-qualified). In case the type is a character type (ignoring the cv-qualifiers), the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
Cblaze::IsClass< T > | Compile time type check.The IsClass type trait tests whether or not the given template parameter is a (possibly cv-qualified) class type. In case the given data type is a class type, the value member constant is set to true, the nested type definition Type is set to TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType and the class derives from FalseType |
Cblaze::IsColumn< T > | Compile time check for columns.This type trait tests whether or not the given template parameter is a column (i.e. dense or sparse column). In case the type is a column, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
Cblaze::IsColumns< T > | Compile time check for column selections.This type trait tests whether or not the given template parameter is a column selection (i.e. a view on columns of a dense or sparse matrix). In case the type is a column selection, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
Cblaze::IsCommutative< T1, T2, typename > | Compile time check for the commutativity of data types.This type trait tests whether or not the two given data types T1 and T2 are commutative with respect to mathematical operations. If the types are commutative, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
Cblaze::IsComplex< T > | Compile time check for complex types.This type trait tests whether or not the given template parameter is a complex data type. In case the type is a complex data type (ignoring the cv-qualifiers), the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
Cblaze::IsComplexDouble< T > | Compile time check for single precision complex types.This type trait tests whether or not the given template parameter is of type complex<double> . In case the type is complex<double> (ignoring the cv-qualifiers), the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
Cblaze::IsComplexFloat< T > | Compile time check for single precision complex types.This type trait tests whether or not the given template parameter is of type complex<float> . In case the type is complex<float> (ignoring the cv-qualifiers), the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
Cblaze::IsComputation< T > | Compile time check whether the given type is a computational expression template.This type trait class tests whether or not the given type Type is a computational expression template (i.e. a mathematical operation such as an addition, a subtraction, a multiplication, a division, an absolute value calculation, ...). In order to qualify as a valid computational expression template, the given type has to derive (publicly or privately) from the Computation base class. In case the given type is a valid computational expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
Cblaze::IsConst< T > | Compile time check for constant data types.The IsConst type trait tests whether or not the given template parameter is a (top level) const-qualified data type. In case the given data type is const-qualified, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
Cblaze::IsConstructible< T, Args > | Compile time type check.The IsConstructible type trait tests whether the expression |
Cblaze::IsContiguous< T > | Compile time check for the memory layout of data types.This type trait tests whether the given data type is array-like and all its elements lie contiguous in memory. In case the data type has contiguous elements, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. Examples: |
Cblaze::IsConvertible< From, To > | Compile time pointer relationship constraint.This type traits tests whether the first given template argument can be converted to the second template argument via copy construction. If the first argument can be converted to the second argument, the value member constnt is set to true, the nested type definition type is TrueType, and the class derives from TrueType. Otherwise value is set to false, type is FalseType, and the class derives from FalseType |
Cblaze::IsCopyAssignable< T > | Compile time type check.The IsCopyAssignable type trait tests whether the expression |
Cblaze::IsCopyConstructible< T > | Compile time type check.The IsCopyConstructible type trait tests whether the expression |
Cblaze::IsCustom< T > | Compile time check for custom data types.This type trait tests whether the given data type is a custom data type, i.e. a custom vector or a custom matrix. In case the data type a custom data type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. Examples: |
Cblaze::IsDefaultConstructible< T > | Compile time type check.The IsDefaultConstructible type trait tests whether the expression |
Cblaze::IsDestructible< T > | Compile time type check.The IsDestructible type trait tests whether the expression |
Cblaze::IsDiagonal< T > | Compile time check for diagonal matrices.This type trait tests whether or not the given template parameter is a diagonal matrix type (i.e. a matrix type that is guaranteed to be diagonal at compile time). In case the type is a diagonal matrix type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
Cblaze::IsDouble< T > | Compile time check for double precision floating point types.This type trait tests whether or not the given template parameter is of double type. In case the type is double (ignoring the cv-qualifiers), the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
Cblaze::IsElements< T > | Compile time check for element selections.This type trait tests whether or not the given template parameter is an element selection (i.e. a view on elements of a dense or sparse vector). In case the type is an element selection, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
Cblaze::IsEmpty< T > | Compile time type check.This class tests whether the given template parameter is an empty class type, i.e. a type without member data and virtual functions. If it is an empty class type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
Cblaze::IsEnum< T > | Compile time check for complete enumeration types.This type trait tests whether or not the given template parameter is an enumeration type. In case the type is an enumeration type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
Cblaze::IsEven< N > | Compile time check whether a compile time constant expression is even.This value trait tests whether the given integral value N is an even value. In case the value is even, the value member enumeration is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
Cblaze::IsFloat< T > | Compile time check for single precision floating point types.This type trait tests whether or not the given template parameter is of float type. In case the type is float (ignoring the cv-qualifiers), the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
Cblaze::IsFloatingPoint< T > | Compile time check for floating point data types.This type trait tests whether or not the given template parameter is a floating point data type (ignoring the cv-qualifiers). In case the type is a floating point data type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
Cblaze::IsGeneral< T > | Compile time check for general matrices.This type trait tests whether or not the given template parameter is a general matrix type (i.e. a matrix type that is neither symmetric, Hermitian, lower triangular or upper triangular at compile time). In case the type is a general matrix type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
Cblaze::IsIdentity< T > | Compile time check for identity matrices.This type trait tests whether or not the given template parameter is an identity matrix type (i.e. a matrix type that is guaranteed to be an identity matrix at compile time). In case the type is an identity matrix type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
Cblaze::IsInitializer< T > | Compile time check for custom data types.This type trait tests whether the given data type represents an initializer list, i.e. is an initializer vector or an initializer matrix. In case the data type represents an initializer list, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. Examples: |
Cblaze::IsInteger< T > | Compile time check for integer types.This type trait tests whether or not the given template parameter is an integer type (i.e., either (signed) int or unsigned int, possibly cv-qualified). In case the type is an integer type (ignoring the cv-qualifiers), the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
Cblaze::IsIntegral< T > | Compile time check for integral data types.This type trait tests whether or not the given template parameter is an integral data type. In case the type is an integral data type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
Cblaze::IsInvertible< T > | Compile time check for data types.This type trait tests whether or not the given template parameter is invertible. The type is considered to be invertible if it is either BLAS compatible (i.e. float , double , complex<float> , or complex<double> ), long double , complex<long double> or any dense matrix type with a BLAS compatible element type. If the given type is invertible, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
Cblaze::IsLong< T > | Compile time check for long integer types.This type trait tests whether or not the given template parameter is a long integer type (i.e., either (signed) long or unsigned long, possibly cv-qualified). In case the type is a long integer type (ignoring the cv-qualifiers), the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
Cblaze::IsLongDouble< T > | Compile time check for extended precision floating point types.This type trait tests whether or not the given template parameter is of long double type. In case the type is long double (ignoring the cv-qualifiers), the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
Cblaze::IsLValueReference< T > | Compile time type check.This class tests whether the given template parameter T is an lvalue reference type. If it is an lvalue reference type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
Cblaze::IsMoveAssignable< T > | Compile time type check.The IsMoveAssignable type trait tests whether the expression |
Cblaze::IsMoveConstructible< T > | Compile time type check.The IsMoveConstructible type trait tests whether the expression |
Cblaze::IsMultipleOf< M, N > | Compile time check for a multiplicative relationship of two integral values.This value trait tests whether the first given integral value M is a multiple of the second integral value N (i.e. if , where x is any positive integer in the range ). In case the value is a multiple of N, the value member enumeration is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
Cblaze::IsNothrowAssignable< T, U > | Compile time type check.The IsNothrowAssignable type trait tests whether the expression |
Cblaze::IsNothrowConstructible< T, Args > | Compile time type check.The IsNothrowConstructible type trait tests whether the expression |
Cblaze::IsNothrowCopyAssignable< T > | Compile time type check.The IsNothrowCopyAssignable type trait tests whether the expression |
Cblaze::IsNothrowCopyConstructible< T > | Compile time type check.The IsNothrowCopyConstructible type trait tests whether the expression |
Cblaze::IsNothrowDefaultConstructible< T > | Compile time type check.The IsNothrowDefaultConstructible type trait tests whether the expression |
Cblaze::IsNothrowDestructible< T > | Compile time type check.The IsDestructible type trait tests whether the expression |
Cblaze::IsNothrowMoveAssignable< T > | Compile time type check.The IsNothrowMoveAssignable type trait tests whether the expression |
Cblaze::IsNothrowMoveConstructible< T > | Compile time type check.The IsNothrowMoveConstructible type trait tests whether the expression |
Cblaze::IsNumeric< T > | Compile time check for numeric types.This type trait tests whether or not the given template parameter is a numeric data type. Blaze considers all integral (except bool), floating point, and complex data types as numeric data types. In case the type is a numeric type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
Cblaze::IsNumericMatrix< T > | Compile time check for numeric matrix types.This type trait tests whether or not the given template parameter is a numeric matrix type, i.e. a matrix with numeric element type. In case the type is a numeric matrix type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise yes is set to false, Type is FalseType, and the class derives from FalseType |
Cblaze::IsNumericVector< T > | Compile time check for numeric vector types.This type trait tests whether or not the given template parameter is a numeric vector type, i.e. a vector with numeric element type. In case the type is a numeric vector type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise yes is set to false, Type is FalseType, and the class derives from FalseType |
Cblaze::IsObject< T > | Compile time type check.This class tests whether the given template parameter T is an object type. All types are considered object types except references, void, and function types. If T is an object type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
Cblaze::IsOdd< N > | 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 |
Cblaze::IsOperation< T > | Compile time check whether the given type is an operational expression template.This type trait class tests whether or not the given type Type is either a transformation or a computational expression template. In order to qualify as a valid operational expression template, the given type has to derive (publicly or privately) from the Operation base class. In case the given type is a valid operational expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
Cblaze::IsOpposedView< T > | Compile time check for resizable data types.This type trait tests whether the given data type is an opposed view, i.e. a view that is opposed to the natural storage order of its underlying type. In case the data type is an opposed view, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. Examples: |
Cblaze::IsPadded< T > | Compile time check for data types with padding.This type trait tests whether the given data type employs or simulates padding such that no special treatment of remainder elements is necessary for vectorized operations on the type. In case the data type is padded, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. Examples: |
Cblaze::IsPaddingEnabled< T > | Compile time check for data types.This type trait queries the nested paddingEnabled member of the given data type T, which indicates whether the type provides support for padding (i.e. can properly deal with zeros). If the type is supporting padding, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. Examples: |
Cblaze::IsPod< T > | Compile time check for pod data types.This type trait tests whether or not the given template parameter is a POD (Plain Old Data). In case the type is a POD, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
Cblaze::IsPointer< T > | Compile time type check.This class tests whether the given template parameter is a pointer type (including function pointers, but excluding pointers to members) or not. If it is a pointer type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
Cblaze::IsPowerOf< B, N > | 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 , where x is any positive integer in the range . In case the value is a power of B, the value member enumeration is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
Cblaze::IsReference< T > | Compile time type check.This class tests whether the given template parameter T is a reference type (including references to functions). If it is a reference type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
Cblaze::IsResizable< T > | Compile time check for resizable data types.This type trait tests whether the given data type is a resizable data type. In case the data type can be resized (via the resize() function), the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. Examples: |
Cblaze::IsRestricted< T > | Compile time check for data types with restricted data access.This type trait tests whether the given data type has a restricted data access. Examples are the LowerMatrix and UpperMatrix adaptors that don't allow write access to the elements in the upper or lower part of the matrix, respectively. In case the data type has a restricted data access, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. Examples: |
Cblaze::IsRow< T > | Compile time check for rows.This type trait tests whether or not the given template parameter is a row (i.e. a view on a row of a dense or sparse matrix). In case the type is a row, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
Cblaze::IsRows< T > | Compile time check for row selections.This type trait tests whether or not the given template parameter is a row selection (i.e. a view on rows of a dense or sparse matrix). In case the type is a row selection, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
Cblaze::IsRValueReference< T > | Compile time type check.This class tests whether the given template parameter T is an rvalue reference type. If it is an rvalue reference type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
Cblaze::IsSame< A, B > | Type relationship analysis.This class tests if the two data types A and B are equal. For this type comparison, the cv-qualifiers of both data types are ignored. If A and B are the same data type (ignoring the cv-qualifiers), then the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
Cblaze::IsShort< T > | Compile time check for short integer types.This type trait tests whether or not the given template parameter is a short integer type (i.e., either (signed) short or unsigned short, possibly cv-qualified). In case the type is a short integer type (ignoring the cv-qualifiers), the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
Cblaze::IsShrinkable< T > | Compile time check for shrinkable data types.This type trait tests whether the given data type is a shrinkable data type. In case the data type can be shrunk (via the shrinkToFit() function), the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. Examples: |
Cblaze::IsSigned< T > | Compile time check for signed data types.This type trait tests whether or not the given template parameter is a signed integral or a floating point data type. In case the type is a signed (possibly cv-qualified) data type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
Cblaze::IsSIMDCombinable< T1, T2, Ts > | Compile time check for data types.This type trait tests whether or not the given types can be combined in the context of SIMD operations. By default, all numeric data types are considered combinable to themselves. Also, different integral types of the same size can be combined. If the types are determined to be SIMD combinable, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
Cblaze::IsSIMDEnabled< T, Args > | Compile time check for data types.This type trait tests whether or not the given data type T is a SIMD-enabled data type (i.e. provides the according SIMD-related member functions, such as load() , store(), etc). If the type is SIMD-enabled, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
Cblaze::IsSMPAssignable< T > | Compile time check for data types.This type trait tests whether or not the given template parameter is an SMP-assignable data type (i.e. if it is a data type that can possibly and efficiently be assigned by several threads). In this context, built-in data types as well as complex numbers are non-SMP-assignable, whereas several vector and matrix types (as for instance DynamicVector and DynamicMatrix) can be SMP-assignable. If the type is SMP-assignable, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
Cblaze::IsSparseElement< T > | Compile time check whether the given type is a sparse element type.This type trait class tests whether or not the given type Type is a Blaze sparse element type, i.e. if the type implements the sparse element concept by providing a value() and an index() member function. In order to qualify as a valid sparse element type, the given type has to derive (publicly or privately) from the SparseElement base class. In case the given type is a valid sparse element, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
Cblaze::IsSquare< T > | Compile time check for square matrices.This type trait tests whether or not the given template parameter is a square matrix type (i.e. a matrix type that is guaranteed to be square at compile time). In case the type is a square matrix type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
Cblaze::IsStatic< T > | Compile time check for static data types.This type trait tests whether the given data type is a static data type, i.e. a vector or matrix with dimensions fixed at compile time. In case the data type a static data type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. Examples: |
Cblaze::IsStrictlySame< A, B > | Compile time type relationship analysis.This class tests if the two data types A and B are equal. For this type comparison, the cv-qualifiers of both data types are not ignored. If A and B are the same data type, then the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
Cblaze::IsStrictlyTriangular< T > | Compile time check for strictly triangular matrix types.This type trait tests whether or not the given template parameter is a strictly lower or upper triangular matrix type. In case the type is a triangular matrix type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise yes is set to false, Type is FalseType, and the class derives from FalseType |
Cblaze::IsSubmatrix< T > | Compile time check for submatrices.This type trait tests whether or not the given template parameter is a submatrix (i.e. a view on the part of a dense or sparse matrix). In case the type is a submatrix, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
Cblaze::IsSubvector< T > | Compile time check for subvectors.This type trait tests whether or not the given template parameter is a subvector (i.e. a view on the part of a dense or sparse vector). In case the type is a subvector, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
Cblaze::IsTemporary< T > | Compile time check whether the given type is a temporary vector or matrix type.This type trait class tests whether the given type is a temporary vector or matrix type, i.e. can be used for a temporary vector or matrix. In case the given type can be used as temporary, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
Cblaze::IsTransformation< T > | Compile time check whether the given type is a transformation expression template.This type trait class tests whether the given type Type is a transformation expression template (e.g. a transpose operation). In order to qualify as a valid transformation expression template, the given type has to derive (publicly or privately) from the Transformation base class. In case the given type is a valid transformation expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
Cblaze::IsTriangular< T > | Compile time check for triangular matrix types.This type trait tests whether or not the given template parameter is a lower or upper triangular matrix type. In case the type is a triangular matrix type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise yes is set to false, Type is FalseType, and the class derives from FalseType |
Cblaze::IsUnion< T > | Compile time check for union data types.This type trait tests whether or not the given template parameter is a union data type. In case the type is a union, the value member constant is set o true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
Cblaze::IsUniTriangular< T > | Compile time check for unitriangular matrix types.This type trait tests whether or not the given template parameter is a lower or upper unitriangular matrix type. In case the type is an unitriangular matrix type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise yes is set to false, Type is FalseType, and the class derives from FalseType |
Cblaze::IsUnsigned< T > | Compile time check for unsigned data types.This type trait tests whether or not the given template parameter is an unsigned, integral data type. In case the type is an unsigned (possibly cv-qualified) data type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
Cblaze::IsValid< T > | Compile time type check.This class tests whether the given template parameter is a valid or invalid data type (i.e. if the type is the INVALID_TYPE). If T is not the INVALID_TYPE class type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
Cblaze::IsVectorizable< T > | Compile time check for vectorizable types.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...), this type trait tests whether or not the given template parameter is a vectorizable type, i.e. a type for which intrinsic vector operations and optimizations can be used. Currently, all built-in data types except bool and the according complex numbers are considered to be vectorizable types. In case the type is vectorizable, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
Cblaze::IsVoid< T > | Compile time check for the void data type.This type trait tests whether or not the given template parameter is of type void (ignoring the cv-qualifiers). In case the type is of type void, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
Cblaze::IsVolatile< T > | Compile time check for volatile data types.The IsVolatile type trait tests whether or not the given template parameter is a (top level) volatile-qualified data type. In case the given data type is volatile, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
Cblaze::RequiresEvaluation< T > | Compile time check to query the requirement to evaluate an expression.Via this type trait it is possible to determine whether a given vector or matrix expression type requires an intermediate evaluation in the context of a compound expression. In case the given type requires an evaluation, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
Cblaze::StorageOrder< T > | Evaluation of the storage order of a given matrix type.Via this type trait it is possible to evaluate the storage order of a given matrix type. In case the given type is a row-major matrix type the nested boolean value is set to rowMajor, in case it is a column-major matrix type it is set to columnMajor. If the given type is not a matrix type a compilation error is created |
Cblaze::TransposeFlag< T > | Evaluation of the transpose flag of a given matrix type.Via this type trait it is possible to evaluate the transpose flag of a given vector type. In case the given type is a row vector type the nested boolean value is set to rowVector, in case it is a column vector type it is set to columnVector. If the given type is not a vector type a compilation error is created |
Cblaze::YieldsDiagonal< OP, MT, MTs > | Compile time check for operations on matrices.This type trait tests whether or not the given operation OP yields a diagonal matrix when applied to several matrices of types MT and MTs. In case the operation yields a diagonal matrix, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
Cblaze::YieldsHermitian< OP, MT, MTs > | Compile time check for operations on matrices.This type trait tests whether or not the given operation OP yields a Hermitian matrix when applied to several matrices of types MT and MTs. In case the operation yields a Hermitian matrix, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
Cblaze::YieldsIdentity< OP, MT, MTs > | Compile time check for operations on matrices.This type trait tests whether or not the given operation OP yields an identity matrix when applied to several matrices of types MT and MTs. In case the operation yields an identity matrix, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
Cblaze::YieldsLower< OP, MT, MTs > | Compile time check for operations on matrices.This type trait tests whether or not the given operation OP yields a lower matrix when applied to several matrices of types MT and MTs. In case the operation yields a lower matrix, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
Cblaze::YieldsStrictlyLower< OP, MT, MTs > | Compile time check for operations on matrices.This type trait tests whether or not the given operation OP yields a strictly lower matrix when applied to several matrices of types MT and MTs. In case the operation yields a strictly lower matrix, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
Cblaze::YieldsStrictlyTriangular< OP, MT, MTs > | Compile time check for operations on matrices.This type trait tests whether or not the given operation OP yields a lower or upper strictly triangular matrix when applied to several matrices of types MT and MTs. In case the operation yields a strictly triangular matrix, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
Cblaze::YieldsStrictlyUpper< OP, MT, MTs > | Compile time check for operations on matrices.This type trait tests whether or not the given operation OP yields a strictly upper matrix when applied to several matrices of types MT and MTs. In case the operation yields a strictly upper matrix, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
Cblaze::YieldsSymmetric< OP, MT, MTs > | Compile time check for operations on matrices.This type trait tests whether or not the given operation OP yields a symmetric matrix when applied to several matrices of types MT and MTs. In case the operation yields a symmetric matrix, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
Cblaze::YieldsTriangular< OP, MT, MTs > | Compile time check for operations on matrices.This type trait tests whether or not the given operation OP yields a lower or upper triangular matrix when applied to several matrices of types MT and MTs. In case the operation yields a triangular matrix, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
Cblaze::YieldsUniform< OP, T, Ts > | Compile time check for operations on vectors and matrices.This type trait tests whether or not the given operation OP yields a uniform vector or matrix when applied to several vectors or matrices of types T and Ts. In case the operation yields a uniform vector or matrix, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
Cblaze::YieldsUniLower< OP, MT, MTs > | Compile time check for operations on matrices.This type trait tests whether or not the given operation OP yields an unilower matrix when applied to several matrices of types MT and MTs. In case the operation yields an unilower matrix, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
Cblaze::YieldsUniTriangular< OP, MT, MTs > | Compile time check for operations on matrices.This type trait tests whether or not the given operation OP yields a lower or upper unitriangular matrix when applied to several matrices of types MT and MTs. In case the operation yields an unitriangular matrix, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
Cblaze::YieldsUniUpper< OP, MT, MTs > | Compile time check for operations on matrices.This type trait tests whether or not the given operation OP yields an uniupper matrix when applied to several matrices of types MT and MTs. In case the operation yields an uniupper matrix, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
Cblaze::YieldsUpper< OP, MT, MTs > | Compile time check for operations on matrices.This type trait tests whether or not the given operation OP yields an upper matrix when applied to several matrices of types MT and MTs. In case the operation yields an upper matrix, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
Cblaze::YieldsZero< OP, T, Ts > | Compile time check for operations on vectors and matrices.This type trait tests whether or not the given operation OP yields a zero vector or zero matrix when applied to several vectors or matrices of types T and Ts. In case the operation yields a zero vector or matrix, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►Cblaze::HasSize< T, 1UL > | |
Cblaze::Has1Byte< T > | Compile time size check.This type trait offers the possibility to test whether a given type has a size of exactly one byte. If the type T has one byte, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►Cblaze::HasSize< T, 2UL > | |
Cblaze::Has2Bytes< T > | Compile time size check.This type trait offers the possibility to test whether a given type has a size of exactly two bytes. If the type T has two bytes, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►Cblaze::HasSize< T, 4UL > | |
Cblaze::Has4Bytes< T > | Compile time size check.This type trait offers the possibility to test whether a given type has a size of exactly four bytes. If the type T has four bytes, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►Cblaze::HasSize< T, 8UL > | |
Cblaze::Has8Bytes< T > | Compile time size check.This type trait offers the possibility to test whether a given type has a size of exactly four bytes. If the type T has four bytes, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives fromTrueType. Otherwise value is set to false, Type is FalseType, and the classderives from FalseType |
►Cblaze::IntegralConstant< size_t, 0UL > | |
Cblaze::Extent< T, N > | Compile time check for the size of array bounds.Via this type trait it is possible to query at compile time for the size of a particular array extent. In case the given template argument is an array type with a rank greater than N, the value member constant is set to the number of elements of the N'th array dimension. In all other cases, and especially in case the N'th array dimension is incomplete, value is set to 0 |
Cblaze::Rank< T > | Compile time check for array ranks.This type trait determines the rank of the given template argument. In case the given type is an array type, the nested value member constant is set to the number of dimensions of T. Otherwise value is set to 0 |
►Cblaze::IntegralConstant< size_t, AlignmentOfHelper< T >::value > | |
Cblaze::AlignmentOf< T > | 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 |
Cblaze::Inv | Generic wrapper for the inv() function |
Cblaze::InvAdd | Generic wrapper for the inverted addition operator |
Cblaze::InvCbrt | Generic wrapper for the invcbrt() function |
Cblaze::InvSqrt | Generic wrapper for the invsqrt() function |
►CIsCUDAAssignableHelper | |
Cblaze::IsCUDAAssignable< T > | Compile time check for data types.This type trait tests whether or not the given template parameter is an CUDA-assignable data type (i.e. if it is a data type that can possibly and efficiently be assigned by several threads). In this context, built-in data types as well as complex numbers are not considered CUDA-assignable, whereas several vector and matrix types (as for instance DynamicVector and DynamicMatrix) can be CUDA-assignable. If the type is CUDA-assignable, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CIsHermitianHelper | |
Cblaze::IsHermitian< T > | Compile time check for Hermitian matrices.This type trait tests whether or not the given template parameter is an Hermitian matrix type (i.e. a matrix type that is guaranteed to be Hermitian at compile time). In case the type is a Hermitian matrix type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CIsLowerHelper | |
Cblaze::IsLower< T > | Compile time check for lower triangular matrices.This type trait tests whether or not the given template parameter is a lower triangular matrix type (i.e. a matrix type that is guaranteed to be lower triangular at compile time). This also includes lower unitriangular and strictly lower triangular matrices. In case the type is a lower triangular matrix type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CIsStrictlyLowerHelper | |
Cblaze::IsStrictlyLower< T > | Compile time check for strictly lower triangular matrices.This type trait tests whether or not the given template parameter is a strictly lower triangular matrix type (i.e. a matrix type that is guaranteed to be strictly lower triangular at compile time). In case the type is a strictly lower triangular matrix type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CIsStrictlyUpperHelper | |
Cblaze::IsStrictlyUpper< T > | Compile time check for strictly upper triangular matrices.This type trait tests whether or not the given template parameter is a strictly upper triangular matrix type (i.e. a matrix type that is guaranteed to be strictly upper triangular at compile time). In case the type is a strictly upper triangular matrix type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CIsSymmetricHelper | |
Cblaze::IsSymmetric< T > | Compile time check for symmetric matrices.This type trait tests whether or not the given template parameter is a symmetric matrix type (i.e. a matrix type that is guaranteed to be symmetric at compile time). In case the type is a symmetric matrix type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CIsUniformHelper | |
Cblaze::IsUniform< T > | Compile time check for uniform vectors and matrices.This type trait tests whether or not the given template parameter is a uniform vector or matrix type (i.e. a data type that is guaranteed to be a uniform vector or matrix at compile time). In case the type is a uniform vector or matrix type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CIsUniLowerHelper | |
Cblaze::IsUniLower< T > | Compile time check for lower unitriangular matrices.This type trait tests whether or not the given template parameter is a lower unitriangular matrix type (i.e. a matrix type that is guaranteed to be lower unitriangular at compile time). In case the type is a lower unitriangular matrix type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CIsUniUpperHelper | |
Cblaze::IsUniUpper< T > | Compile time check for upper unitriangular matrices.This type trait tests whether or not the given template parameter is an upper unitriangular matrix type (i.e. a matrix type that is guaranteed to be upper unitriangular at compile time). In case the type is an upper unitriangular matrix type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CIsUpperHelper | |
Cblaze::IsUpper< T > | Compile time check for upper triangular matrices.This type trait tests whether or not the given template parameter is an upper triangular matrix type (i.e. a matrix type that is guaranteed to be upper triangular at compile time). This also includes upper unitriangular and strictly upper triangular matrices. In case the type is an upper triangular matrix type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CIsZeroHelper | |
Cblaze::IsZero< T > | Compile time check for zero vectors or matrices.This type trait tests whether or not the given template parameter is a zero vector or matrix type (i.e. a vector or matrix type that is guaranteed to be zero at compile time). In case the type is a zero vector or matrix type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
Cblaze::Kron | Generic wrapper for the Kronecker product |
Cblaze::KronTrait< T1, T2, typename > | Base template for the KronTrait class |
Cblaze::L1Norm | Generic wrapper for the l1Norm() function |
Cblaze::L2Norm | Generic wrapper for the l2Norm() function |
Cblaze::L3Norm | Generic wrapper for the l3Norm() function |
Cblaze::L4Norm | Generic wrapper for the l4Norm() function |
Cblaze::LeftShiftAssign | Generic wrapper for bitwise left-shift assignment |
Cblaze::Length< TL > | 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: |
Cblaze::Less | Generic wrapper for the less-than relational operator |
Cblaze::Limits< Type > | Numerical limits of built-in data types.The Limits class provides numerical limits for the following built-in data types: |
Cblaze::Log | Generic wrapper for the log() function |
Cblaze::Log10 | Generic wrapper for the log10() function |
Cblaze::Log2 | Generic wrapper for the log2() function |
Cblaze::LowerMatrix< MT, SO, DF > | Matrix adapter for lower triangular matrices |
Cblaze::LowType< T1, T2, typename > | Base template for the LowType type trait |
Cblaze::LpNorm< P > | Generic wrapper for the lpNorm() function |
Cblaze::make_index_sequence | Import of the std::make_index_sequence alias template into the Blaze namespace |
Cblaze::make_integer_sequence | Import of the std::make_integer_sequence alias template into the Blaze namespace |
Cblaze::MakeSigned< T > | Compile time type conversion into a signed integral type.This type trait provides the feature to convert the given integral or constant type T to the corresponding signed integral data type with the same size and with the same cv-qualifiers. Note that in case T is bool or a non-integral data type, a compilation error is created |
Cblaze::MakeUnsigned< T > | Compile time type conversion into an unsigned integral type.This type trait provides the feature to convert the given integral or constant type T to the corresponding unsigned integral data type with the same size and with the same cv-qualifiers. Note that in case T is bool or a non-integral data type, a compilation error is created |
Cblaze::MapTrait< Args > | Base template for the MapTrait class |
►Cblaze::Matrix< MT, SO > | 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) |
Cblaze::DenseMatrix< MT, SO > | 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 |
Cblaze::SparseMatrix< MT, SO > | 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 |
►Cblaze::DenseMatrix< CustomMatrix< Type, AF, PF, SO, RT >, SO > | |
Cblaze::CustomMatrix< Type, AF, PF, SO, RT > | Efficient implementation of a customizable matrix.The CustomMatrix class template provides the functionality to represent an external array of elements of arbitrary type and a fixed size as a native Blaze dense matrix data structure. Thus in contrast to all other dense matrix types a custom matrix does not perform any kind of memory allocation by itself, but it is provided with an existing array of element during construction. A custom matrix can therefore be considered an alias to the existing array |
►Cblaze::DenseMatrix< DMatDeclDiagExpr< MT, SO >, SO > | |
►Cblaze::Expression< DenseMatrix< DMatDeclDiagExpr< MT, SO >, SO > > | |
►Cblaze::DeclExpr< DenseMatrix< DMatDeclDiagExpr< MT, SO >, SO > > | |
►Cblaze::DeclDiagExpr< DenseMatrix< DMatDeclDiagExpr< MT, SO >, SO > > | |
Cblaze::DMatDeclDiagExpr< MT, SO > | Expression object for the explicit diagonal declaration of dense matrices.The DMatDeclDiagExpr class represents the compile time expression for the explicit diagonal declaration of a dense matrix |
►Cblaze::DenseMatrix< DMatDeclHermExpr< MT, SO >, SO > | |
►Cblaze::Expression< DenseMatrix< DMatDeclHermExpr< MT, SO >, SO > > | |
►Cblaze::DeclExpr< DenseMatrix< DMatDeclHermExpr< MT, SO >, SO > > | |
►Cblaze::DeclHermExpr< DenseMatrix< DMatDeclHermExpr< MT, SO >, SO > > | |
Cblaze::DMatDeclHermExpr< MT, SO > | Expression object for the explicit Hermitian declaration of dense matrices.The DMatDeclHermExpr class represents the compile time expression for the explicit Hermitian declaration of a dense matrix |
►Cblaze::DenseMatrix< DMatDeclLowExpr< MT, SO >, SO > | |
►Cblaze::Expression< DenseMatrix< DMatDeclLowExpr< MT, SO >, SO > > | |
►Cblaze::DeclExpr< DenseMatrix< DMatDeclLowExpr< MT, SO >, SO > > | |
►Cblaze::DeclLowExpr< DenseMatrix< DMatDeclLowExpr< MT, SO >, SO > > | |
Cblaze::DMatDeclLowExpr< MT, SO > | Expression object for the explicit lower declaration of dense matrices.The DMatDeclLowExpr class represents the compile time expression for the explicit lower declaration of a dense matrix |
►Cblaze::DenseMatrix< DMatDeclSymExpr< MT, SO >, SO > | |
►Cblaze::Expression< DenseMatrix< DMatDeclSymExpr< MT, SO >, SO > > | |
►Cblaze::DeclExpr< DenseMatrix< DMatDeclSymExpr< MT, SO >, SO > > | |
►Cblaze::DeclSymExpr< DenseMatrix< DMatDeclSymExpr< MT, SO >, SO > > | |
Cblaze::DMatDeclSymExpr< MT, SO > | Expression object for the explicit symmetry declaration of dense matrices.The DMatDeclSymExpr class represents the compile time expression for the explicit symmetry declaration of a dense matrix |
►Cblaze::DenseMatrix< DMatDeclUppExpr< MT, SO >, SO > | |
►Cblaze::Expression< DenseMatrix< DMatDeclUppExpr< MT, SO >, SO > > | |
►Cblaze::DeclExpr< DenseMatrix< DMatDeclUppExpr< MT, SO >, SO > > | |
►Cblaze::DeclUppExpr< DenseMatrix< DMatDeclUppExpr< MT, SO >, SO > > | |
Cblaze::DMatDeclUppExpr< MT, SO > | Expression object for the explicit upper declaration of dense matrices.The DMatDeclUppExpr class represents the compile time expression for the explicit upper declaration of a dense matrix |
►Cblaze::DenseMatrix< DMatDMatAddExpr< MT1, MT2, SO >, SO > | |
►Cblaze::Expression< DenseMatrix< DMatDMatAddExpr< MT1, MT2, SO >, SO > > | |
►Cblaze::AddExpr< DenseMatrix< DMatDMatAddExpr< MT1, MT2, SO >, SO > > | |
►Cblaze::MatMatAddExpr< DenseMatrix< DMatDMatAddExpr< MT1, MT2, SO >, SO > > | |
Cblaze::DMatDMatAddExpr< MT1, MT2, SO > | 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 |
►Cblaze::DenseMatrix< DMatDMatKronExpr< MT1, MT2, SO >, SO > | |
►Cblaze::Expression< DenseMatrix< DMatDMatKronExpr< MT1, MT2, SO >, SO > > | |
►Cblaze::KronExpr< DenseMatrix< DMatDMatKronExpr< MT1, MT2, SO >, SO > > | |
►Cblaze::MatMatKronExpr< DenseMatrix< DMatDMatKronExpr< MT1, MT2, SO >, SO > > | |
Cblaze::DMatDMatKronExpr< MT1, MT2, SO > | Expression object for dense matrix-dense matrix Kronecker products.The DMatDMatKronExpr class represents the compile time expression for Kronecker products between dense matrices of any storage order |
►Cblaze::DenseMatrix< DMatDMatMapExpr< MT1, MT2, OP, SO >, SO > | |
►Cblaze::Expression< DenseMatrix< DMatDMatMapExpr< MT1, MT2, OP, SO >, SO > > | |
►Cblaze::BinaryMapExpr< DenseMatrix< DMatDMatMapExpr< MT1, MT2, OP, SO >, SO > > | |
►Cblaze::MatMatMapExpr< DenseMatrix< DMatDMatMapExpr< MT1, MT2, OP, SO >, SO > > | |
Cblaze::DMatDMatMapExpr< MT1, MT2, OP, SO > | Expression object for the dense matrix-dense matrix map() function.The DMatDMatMapExpr class represents the compile time expression for the pairwise evaluation of a binary custom operation on the elements of two dense matrices with identical storage order via the map() function |
►Cblaze::DenseMatrix< DMatDMatMultExpr< MT1, MT2, SF, HF, LF, UF >, false > | |
►Cblaze::Expression< DenseMatrix< DMatDMatMultExpr< MT1, MT2, SF, HF, LF, UF >, false > > | |
►Cblaze::MultExpr< DenseMatrix< DMatDMatMultExpr< MT1, MT2, SF, HF, LF, UF >, false > > | |
►Cblaze::MatMatMultExpr< DenseMatrix< DMatDMatMultExpr< MT1, MT2, SF, HF, LF, UF >, false > > | |
Cblaze::DMatDMatMultExpr< MT1, MT2, SF, HF, LF, UF > | Expression object for dense matrix-dense matrix multiplications.The DMatDMatMultExpr class represents the compile time expression for multiplications between row-major dense matrices |
►Cblaze::DenseMatrix< DMatDMatSchurExpr< MT1, MT2, SO >, SO > | |
►Cblaze::Expression< DenseMatrix< DMatDMatSchurExpr< MT1, MT2, SO >, SO > > | |
►Cblaze::SchurExpr< DenseMatrix< DMatDMatSchurExpr< MT1, MT2, SO >, SO > > | |
Cblaze::DMatDMatSchurExpr< MT1, MT2, SO > | Expression object for dense matrix-dense matrix Schur products.The DMatDMatSchurExpr class represents the compile time expression for Schur products between dense matrices with identical storage order |
►Cblaze::DenseMatrix< DMatDMatSubExpr< MT1, MT2, SO >, SO > | |
►Cblaze::Expression< DenseMatrix< DMatDMatSubExpr< MT1, MT2, SO >, SO > > | |
►Cblaze::SubExpr< DenseMatrix< DMatDMatSubExpr< MT1, MT2, SO >, SO > > | |
►Cblaze::MatMatSubExpr< DenseMatrix< DMatDMatSubExpr< MT1, MT2, SO >, SO > > | |
Cblaze::DMatDMatSubExpr< MT1, MT2, SO > | 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 |
►Cblaze::DenseMatrix< DMatEvalExpr< MT, SO >, SO > | |
►Cblaze::Expression< DenseMatrix< DMatEvalExpr< MT, SO >, SO > > | |
►Cblaze::EvalExpr< DenseMatrix< DMatEvalExpr< MT, SO >, SO > > | |
►Cblaze::MatEvalExpr< DenseMatrix< DMatEvalExpr< MT, SO >, SO > > | |
Cblaze::DMatEvalExpr< MT, SO > | 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 |
►Cblaze::DenseMatrix< DMatInvExpr< MT, SO >, SO > | |
►Cblaze::Expression< DenseMatrix< DMatInvExpr< MT, SO >, SO > > | |
►Cblaze::MatInvExpr< DenseMatrix< DMatInvExpr< MT, SO >, SO > > | |
Cblaze::DMatInvExpr< MT, SO > | Expression object for dense matrix inversions.The DMatInvExpr class represents the compile time expression for inversions of dense matrices |
►Cblaze::DenseMatrix< DMatMapExpr< MT, OP, SO >, SO > | |
►Cblaze::Expression< DenseMatrix< DMatMapExpr< MT, OP, SO >, SO > > | |
►Cblaze::UnaryMapExpr< DenseMatrix< DMatMapExpr< MT, OP, SO >, SO > > | |
►Cblaze::MatMapExpr< DenseMatrix< DMatMapExpr< MT, OP, SO >, SO > > | |
Cblaze::DMatMapExpr< MT, OP, SO > | Expression object for the dense matrix map() function.The DMatMapExpr class represents the compile time expression for the evaluation of a custom operation on each element of a dense matrix via the map() function |
►Cblaze::DenseMatrix< DMatScalarDivExpr< MT, ST, SO >, SO > | |
►Cblaze::Expression< DenseMatrix< DMatScalarDivExpr< MT, ST, SO >, SO > > | |
►Cblaze::DivExpr< DenseMatrix< DMatScalarDivExpr< MT, ST, SO >, SO > > | |
►Cblaze::MatScalarDivExpr< DenseMatrix< DMatScalarDivExpr< MT, ST, SO >, SO > > | |
Cblaze::DMatScalarDivExpr< MT, ST, SO > | 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 |
►Cblaze::DenseMatrix< DMatScalarMultExpr< MT, ST, SO >, SO > | |
►Cblaze::Expression< DenseMatrix< DMatScalarMultExpr< MT, ST, SO >, SO > > | |
►Cblaze::MultExpr< DenseMatrix< DMatScalarMultExpr< MT, ST, SO >, SO > > | |
►Cblaze::MatScalarMultExpr< DenseMatrix< DMatScalarMultExpr< MT, ST, SO >, SO > > | |
Cblaze::DMatScalarMultExpr< MT, ST, SO > | 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 |
►Cblaze::DenseMatrix< DMatSerialExpr< MT, SO >, SO > | |
►Cblaze::Expression< DenseMatrix< DMatSerialExpr< MT, SO >, SO > > | |
►Cblaze::SerialExpr< DenseMatrix< DMatSerialExpr< MT, SO >, SO > > | |
►Cblaze::MatSerialExpr< DenseMatrix< DMatSerialExpr< MT, SO >, SO > > | |
Cblaze::DMatSerialExpr< MT, SO > | 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 |
►Cblaze::DenseMatrix< DMatSMatAddExpr< MT1, MT2, SO >, SO > | |
►Cblaze::Expression< DenseMatrix< DMatSMatAddExpr< MT1, MT2, SO >, SO > > | |
►Cblaze::AddExpr< DenseMatrix< DMatSMatAddExpr< MT1, MT2, SO >, SO > > | |
►Cblaze::MatMatAddExpr< DenseMatrix< DMatSMatAddExpr< MT1, MT2, SO >, SO > > | |
Cblaze::DMatSMatAddExpr< MT1, MT2, SO > | 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 |
►Cblaze::DenseMatrix< DMatSMatMultExpr< MT1, MT2, SF, HF, LF, UF >, false > | |
►Cblaze::Expression< DenseMatrix< DMatSMatMultExpr< MT1, MT2, SF, HF, LF, UF >, false > > | |
►Cblaze::MultExpr< DenseMatrix< DMatSMatMultExpr< MT1, MT2, SF, HF, LF, UF >, false > > | |
►Cblaze::MatMatMultExpr< DenseMatrix< DMatSMatMultExpr< MT1, MT2, SF, HF, LF, UF >, false > > | |
Cblaze::DMatSMatMultExpr< MT1, MT2, SF, HF, LF, UF > | 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 |
►Cblaze::DenseMatrix< DMatSMatSubExpr< MT1, MT2, SO >, SO > | |
►Cblaze::Expression< DenseMatrix< DMatSMatSubExpr< MT1, MT2, SO >, SO > > | |
►Cblaze::SubExpr< DenseMatrix< DMatSMatSubExpr< MT1, MT2, SO >, SO > > | |
►Cblaze::MatMatSubExpr< DenseMatrix< DMatSMatSubExpr< MT1, MT2, SO >, SO > > | |
Cblaze::DMatSMatSubExpr< MT1, MT2, SO > | 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 |
►Cblaze::DenseMatrix< DMatTDMatAddExpr< MT1, MT2 >, false > | |
►Cblaze::Expression< DenseMatrix< DMatTDMatAddExpr< MT1, MT2 >, false > > | |
►Cblaze::AddExpr< DenseMatrix< DMatTDMatAddExpr< MT1, MT2 >, false > > | |
►Cblaze::MatMatAddExpr< DenseMatrix< DMatTDMatAddExpr< MT1, MT2 >, false > > | |
Cblaze::DMatTDMatAddExpr< MT1, MT2 > | 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 |
►Cblaze::DenseMatrix< DMatTDMatMapExpr< MT1, MT2, OP >, false > | |
►Cblaze::Expression< DenseMatrix< DMatTDMatMapExpr< MT1, MT2, OP >, false > > | |
►Cblaze::BinaryMapExpr< DenseMatrix< DMatTDMatMapExpr< MT1, MT2, OP >, false > > | |
►Cblaze::MatMatMapExpr< DenseMatrix< DMatTDMatMapExpr< MT1, MT2, OP >, false > > | |
Cblaze::DMatTDMatMapExpr< MT1, MT2, OP > | Expression object for the dense matrix/tranpose dense matrix map() function.The DMatTDMatMapExpr class represents the compile time expression for the pairwise evaluation of a binary custom operation on the elements of a row-major dense matrix and a column-major matrix via the map() function |
►Cblaze::DenseMatrix< DMatTDMatMultExpr< MT1, MT2, SF, HF, LF, UF >, false > | |
►Cblaze::Expression< DenseMatrix< DMatTDMatMultExpr< MT1, MT2, SF, HF, LF, UF >, false > > | |
►Cblaze::MultExpr< DenseMatrix< DMatTDMatMultExpr< MT1, MT2, SF, HF, LF, UF >, false > > | |
►Cblaze::MatMatMultExpr< DenseMatrix< DMatTDMatMultExpr< MT1, MT2, SF, HF, LF, UF >, false > > | |
Cblaze::DMatTDMatMultExpr< MT1, MT2, SF, HF, LF, UF > | 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 |
►Cblaze::DenseMatrix< DMatTDMatSchurExpr< MT1, MT2 >, false > | |
►Cblaze::Expression< DenseMatrix< DMatTDMatSchurExpr< MT1, MT2 >, false > > | |
►Cblaze::SchurExpr< DenseMatrix< DMatTDMatSchurExpr< MT1, MT2 >, false > > | |
Cblaze::DMatTDMatSchurExpr< MT1, MT2 > | Expression object for dense matrix-transpose dense matrix Schur product.The DMatTDMatSchurExpr class represents the compile time expression for Schur product between a row-major dense matrix and a column-major dense matrix |
►Cblaze::DenseMatrix< DMatTDMatSubExpr< MT1, MT2 >, false > | |
►Cblaze::Expression< DenseMatrix< DMatTDMatSubExpr< MT1, MT2 >, false > > | |
►Cblaze::SubExpr< DenseMatrix< DMatTDMatSubExpr< MT1, MT2 >, false > > | |
►Cblaze::MatMatSubExpr< DenseMatrix< DMatTDMatSubExpr< MT1, MT2 >, false > > | |
Cblaze::DMatTDMatSubExpr< MT1, MT2 > | 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 |
►Cblaze::DenseMatrix< DMatTransExpr< MT, SO >, SO > | |
►Cblaze::Expression< DenseMatrix< DMatTransExpr< MT, SO >, SO > > | |
►Cblaze::TransExpr< DenseMatrix< DMatTransExpr< MT, SO >, SO > > | |
►Cblaze::MatTransExpr< DenseMatrix< DMatTransExpr< MT, SO >, SO > > | |
Cblaze::DMatTransExpr< MT, SO > | Expression object for dense matrix transpositions.The DMatTransExpr class represents the compile time expression for transpositions of dense matrices |
►Cblaze::DenseMatrix< DMatTransposer< MT, SO >, SO > | |
Cblaze::DMatTransposer< MT, SO > | Expression object for the transposition of a dense matrix.The DMatTransposer class is a wrapper object for the temporary transposition of a dense matrix |
►Cblaze::DenseMatrix< DMatTSMatAddExpr< MT1, MT2 >, false > | |
►Cblaze::Expression< DenseMatrix< DMatTSMatAddExpr< MT1, MT2 >, false > > | |
►Cblaze::AddExpr< DenseMatrix< DMatTSMatAddExpr< MT1, MT2 >, false > > | |
►Cblaze::MatMatAddExpr< DenseMatrix< DMatTSMatAddExpr< MT1, MT2 >, false > > | |
Cblaze::DMatTSMatAddExpr< MT1, MT2 > | 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 |
►Cblaze::DenseMatrix< DMatTSMatMultExpr< MT1, MT2, SF, HF, LF, UF >, false > | |
►Cblaze::Expression< DenseMatrix< DMatTSMatMultExpr< MT1, MT2, SF, HF, LF, UF >, false > > | |
►Cblaze::MultExpr< DenseMatrix< DMatTSMatMultExpr< MT1, MT2, SF, HF, LF, UF >, false > > | |
►Cblaze::MatMatMultExpr< DenseMatrix< DMatTSMatMultExpr< MT1, MT2, SF, HF, LF, UF >, false > > | |
Cblaze::DMatTSMatMultExpr< MT1, MT2, SF, HF, LF, UF > | 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 |
►Cblaze::DenseMatrix< DMatTSMatSubExpr< MT1, MT2 >, false > | |
►Cblaze::Expression< DenseMatrix< DMatTSMatSubExpr< MT1, MT2 >, false > > | |
►Cblaze::SubExpr< DenseMatrix< DMatTSMatSubExpr< MT1, MT2 >, false > > | |
►Cblaze::MatMatSubExpr< DenseMatrix< DMatTSMatSubExpr< MT1, MT2 >, false > > | |
Cblaze::DMatTSMatSubExpr< MT1, MT2 > | 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 |
►Cblaze::DenseMatrix< DVecDVecOuterExpr< VT1, VT2 >, false > | |
►Cblaze::Expression< DenseMatrix< DVecDVecOuterExpr< VT1, VT2 >, false > > | |
►Cblaze::MultExpr< DenseMatrix< DVecDVecOuterExpr< VT1, VT2 >, false > > | |
►Cblaze::VecTVecMultExpr< DenseMatrix< DVecDVecOuterExpr< VT1, VT2 >, false > > | |
Cblaze::DVecDVecOuterExpr< VT1, VT2 > | Expression object for outer products between two dense vectors.The DVecDVecOuterExpr class represents the compile time expression for outer products between dense vectors |
►Cblaze::DenseMatrix< DVecExpandExpr< VT, TF, CEAs... >, !TF > | |
►Cblaze::Expression< DenseMatrix< DVecExpandExpr< VT, TF, CEAs... >, !TF > > | |
►Cblaze::ExpandExpr< DenseMatrix< DVecExpandExpr< VT, TF, CEAs... >, !TF > > | |
►Cblaze::VecExpandExpr< DenseMatrix< DVecExpandExpr< VT, TF, CEAs... >, !TF >, CEAs... > | |
Cblaze::DVecExpandExpr< VT, TF, CEAs > | Expression object for dense vector expansion.The DVecExpandExpr class represents the compile time expression for expansions of dense vectors |
►Cblaze::DenseMatrix< DynamicMatrix< Type, SO >, SO > | |
Cblaze::DynamicMatrix< Type, SO > | Efficient implementation of a dynamic matrix.The DynamicMatrix class template is the representation of an arbitrary sized matrix with dynamically allocated elements of arbitrary type. The type of the elements and the storage order of the matrix can be specified via the two template parameters: |
►Cblaze::DenseMatrix< HybridMatrix< Type, M, N, SO >, SO > | |
Cblaze::HybridMatrix< Type, M, N, SO > | 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: |
►Cblaze::DenseMatrix< InitializerMatrix< Type >, false > | |
Cblaze::InitializerMatrix< Type > | Dense matrix representation of an initializer list.The InitializerMatrix class template is a dense matrix representation of an (extended) initializer list of arbitrary type. The type of the elements of the matrix can be specified via the single template parameters: |
►Cblaze::DenseMatrix< SMatDMatMultExpr< MT1, MT2, SF, HF, LF, UF >, false > | |
►Cblaze::Expression< DenseMatrix< SMatDMatMultExpr< MT1, MT2, SF, HF, LF, UF >, false > > | |
►Cblaze::MultExpr< DenseMatrix< SMatDMatMultExpr< MT1, MT2, SF, HF, LF, UF >, false > > | |
►Cblaze::MatMatMultExpr< DenseMatrix< SMatDMatMultExpr< MT1, MT2, SF, HF, LF, UF >, false > > | |
Cblaze::SMatDMatMultExpr< MT1, MT2, SF, HF, LF, UF > | 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 |
►Cblaze::DenseMatrix< SMatDMatSubExpr< MT1, MT2, SO >, SO > | |
►Cblaze::Expression< DenseMatrix< SMatDMatSubExpr< MT1, MT2, SO >, SO > > | |
►Cblaze::SubExpr< DenseMatrix< SMatDMatSubExpr< MT1, MT2, SO >, SO > > | |
►Cblaze::MatMatSubExpr< DenseMatrix< SMatDMatSubExpr< MT1, MT2, SO >, SO > > | |
Cblaze::SMatDMatSubExpr< MT1, MT2, SO > | 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 |
►Cblaze::DenseMatrix< SMatTDMatMultExpr< MT1, MT2, SF, HF, LF, UF >, true > | |
►Cblaze::Expression< DenseMatrix< SMatTDMatMultExpr< MT1, MT2, SF, HF, LF, UF >, true > > | |
►Cblaze::MultExpr< DenseMatrix< SMatTDMatMultExpr< MT1, MT2, SF, HF, LF, UF >, true > > | |
►Cblaze::MatMatMultExpr< DenseMatrix< SMatTDMatMultExpr< MT1, MT2, SF, HF, LF, UF >, true > > | |
Cblaze::SMatTDMatMultExpr< MT1, MT2, SF, HF, LF, UF > | 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 |
►Cblaze::DenseMatrix< SMatTDMatSubExpr< MT1, MT2 >, true > | |
►Cblaze::Expression< DenseMatrix< SMatTDMatSubExpr< MT1, MT2 >, true > > | |
►Cblaze::SubExpr< DenseMatrix< SMatTDMatSubExpr< MT1, MT2 >, true > > | |
►Cblaze::MatMatSubExpr< DenseMatrix< SMatTDMatSubExpr< MT1, MT2 >, true > > | |
Cblaze::SMatTDMatSubExpr< MT1, MT2 > | 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 |
►Cblaze::DenseMatrix< StaticMatrix< Type, M, N, SO >, SO > | |
Cblaze::StaticMatrix< Type, M, N, SO > | 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: |
►Cblaze::DenseMatrix< TDMatDMatMultExpr< MT1, MT2, SF, HF, LF, UF >, true > | |
►Cblaze::Expression< DenseMatrix< TDMatDMatMultExpr< MT1, MT2, SF, HF, LF, UF >, true > > | |
►Cblaze::MultExpr< DenseMatrix< TDMatDMatMultExpr< MT1, MT2, SF, HF, LF, UF >, true > > | |
►Cblaze::MatMatMultExpr< DenseMatrix< TDMatDMatMultExpr< MT1, MT2, SF, HF, LF, UF >, true > > | |
Cblaze::TDMatDMatMultExpr< MT1, MT2, SF, HF, LF, UF > | 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 |
►Cblaze::DenseMatrix< TDMatSMatAddExpr< MT1, MT2 >, true > | |
►Cblaze::Expression< DenseMatrix< TDMatSMatAddExpr< MT1, MT2 >, true > > | |
►Cblaze::AddExpr< DenseMatrix< TDMatSMatAddExpr< MT1, MT2 >, true > > | |
►Cblaze::MatMatAddExpr< DenseMatrix< TDMatSMatAddExpr< MT1, MT2 >, true > > | |
Cblaze::TDMatSMatAddExpr< MT1, MT2 > | 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 |
►Cblaze::DenseMatrix< TDMatSMatMultExpr< MT1, MT2, SF, HF, LF, UF >, true > | |
►Cblaze::Expression< DenseMatrix< TDMatSMatMultExpr< MT1, MT2, SF, HF, LF, UF >, true > > | |
►Cblaze::MultExpr< DenseMatrix< TDMatSMatMultExpr< MT1, MT2, SF, HF, LF, UF >, true > > | |
►Cblaze::MatMatMultExpr< DenseMatrix< TDMatSMatMultExpr< MT1, MT2, SF, HF, LF, UF >, true > > | |
Cblaze::TDMatSMatMultExpr< MT1, MT2, SF, HF, LF, UF > | 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 |
►Cblaze::DenseMatrix< TDMatSMatSubExpr< MT1, MT2 >, true > | |
►Cblaze::Expression< DenseMatrix< TDMatSMatSubExpr< MT1, MT2 >, true > > | |
►Cblaze::SubExpr< DenseMatrix< TDMatSMatSubExpr< MT1, MT2 >, true > > | |
►Cblaze::MatMatSubExpr< DenseMatrix< TDMatSMatSubExpr< MT1, MT2 >, true > > | |
Cblaze::TDMatSMatSubExpr< MT1, MT2 > | 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 |
►Cblaze::DenseMatrix< TDMatTDMatMultExpr< MT1, MT2, SF, HF, LF, UF >, true > | |
►Cblaze::Expression< DenseMatrix< TDMatTDMatMultExpr< MT1, MT2, SF, HF, LF, UF >, true > > | |
►Cblaze::MultExpr< DenseMatrix< TDMatTDMatMultExpr< MT1, MT2, SF, HF, LF, UF >, true > > | |
►Cblaze::MatMatMultExpr< DenseMatrix< TDMatTDMatMultExpr< MT1, MT2, SF, HF, LF, UF >, true > > | |
Cblaze::TDMatTDMatMultExpr< MT1, MT2, SF, HF, LF, UF > | 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 |
►Cblaze::DenseMatrix< TDMatTSMatMultExpr< MT1, MT2, SF, HF, LF, UF >, true > | |
►Cblaze::Expression< DenseMatrix< TDMatTSMatMultExpr< MT1, MT2, SF, HF, LF, UF >, true > > | |
►Cblaze::MultExpr< DenseMatrix< TDMatTSMatMultExpr< MT1, MT2, SF, HF, LF, UF >, true > > | |
►Cblaze::MatMatMultExpr< DenseMatrix< TDMatTSMatMultExpr< MT1, MT2, SF, HF, LF, UF >, true > > | |
Cblaze::TDMatTSMatMultExpr< MT1, MT2, SF, HF, LF, UF > | 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 |
►Cblaze::DenseMatrix< TSMatDMatMultExpr< MT1, MT2, SF, HF, LF, UF >, false > | |
►Cblaze::Expression< DenseMatrix< TSMatDMatMultExpr< MT1, MT2, SF, HF, LF, UF >, false > > | |
►Cblaze::MultExpr< DenseMatrix< TSMatDMatMultExpr< MT1, MT2, SF, HF, LF, UF >, false > > | |
►Cblaze::MatMatMultExpr< DenseMatrix< TSMatDMatMultExpr< MT1, MT2, SF, HF, LF, UF >, false > > | |
Cblaze::TSMatDMatMultExpr< MT1, MT2, SF, HF, LF, UF > | 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 |
►Cblaze::DenseMatrix< TSMatDMatSubExpr< MT1, MT2 >, false > | |
►Cblaze::Expression< DenseMatrix< TSMatDMatSubExpr< MT1, MT2 >, false > > | |
►Cblaze::SubExpr< DenseMatrix< TSMatDMatSubExpr< MT1, MT2 >, false > > | |
►Cblaze::MatMatSubExpr< DenseMatrix< TSMatDMatSubExpr< MT1, MT2 >, false > > | |
Cblaze::TSMatDMatSubExpr< MT1, MT2 > | 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 |
►Cblaze::DenseMatrix< TSMatTDMatMultExpr< MT1, MT2, SF, HF, LF, UF >, true > | |
►Cblaze::Expression< DenseMatrix< TSMatTDMatMultExpr< MT1, MT2, SF, HF, LF, UF >, true > > | |
►Cblaze::MultExpr< DenseMatrix< TSMatTDMatMultExpr< MT1, MT2, SF, HF, LF, UF >, true > > | |
►Cblaze::MatMatMultExpr< DenseMatrix< TSMatTDMatMultExpr< MT1, MT2, SF, HF, LF, UF >, true > > | |
Cblaze::TSMatTDMatMultExpr< MT1, MT2, SF, HF, LF, UF > | 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 |
►Cblaze::DenseMatrix< UniformMatrix< Type, SO >, SO > | |
►Cblaze::Expression< DenseMatrix< UniformMatrix< Type, SO >, SO > > | |
Cblaze::UniformMatrix< Type, SO > | Efficient implementation of a uniform matrix.The UniformMatrix class template is the representation of an arbitrary sized uniform matrix with elements of arbitrary type. The type of the elements and the storage order of the matrix can be specified via the two template parameters: |
►Cblaze::Matrix< CompressedMatrix< Type, SO >, SO > | |
►Cblaze::SparseMatrix< CompressedMatrix< Type, SO >, SO > | |
Cblaze::CompressedMatrix< Type, SO > | Efficient implementation of a compressed matrix.The CompressedMatrix class template is the representation of an arbitrary sized sparse matrix with dynamically allocated elements of arbitrary type. The type of the elements and the storage order of the matrix can be specified via the two template parameters: |
►Cblaze::Matrix< DMatSMatKronExpr< MT1, MT2, SO >, SO > | |
►Cblaze::SparseMatrix< DMatSMatKronExpr< MT1, MT2, SO >, SO > | |
►Cblaze::Expression< SparseMatrix< DMatSMatKronExpr< MT1, MT2, SO >, SO > > | |
►Cblaze::KronExpr< SparseMatrix< DMatSMatKronExpr< MT1, MT2, SO >, SO > > | |
►Cblaze::MatMatKronExpr< SparseMatrix< DMatSMatKronExpr< MT1, MT2, SO >, SO > > | |
Cblaze::DMatSMatKronExpr< MT1, MT2, SO > | Expression object for dense matrix-sparse matrix Kronecker product.The DMatSMatKronExpr class represents the compile time expression for Kronecker products between a dense matrix and a sparse matrix |
►Cblaze::Matrix< DMatSMatSchurExpr< MT1, MT2 >, SO > | |
►Cblaze::SparseMatrix< DMatSMatSchurExpr< MT1, MT2 >, false > | |
►Cblaze::Expression< SparseMatrix< DMatSMatSchurExpr< MT1, MT2 >, false > > | |
►Cblaze::SchurExpr< SparseMatrix< DMatSMatSchurExpr< MT1, MT2 >, false > > | |
Cblaze::DMatSMatSchurExpr< MT1, MT2 > | Expression object for dense matrix-sparse matrix Schur product.The DMatSMatSchurExpr class represents the compile time expression for Schur products between a dense matrix and a row-major sparse matrix |
►Cblaze::Matrix< DMatTSMatSchurExpr< MT1, MT2 >, SO > | |
►Cblaze::SparseMatrix< DMatTSMatSchurExpr< MT1, MT2 >, true > | |
►Cblaze::Expression< SparseMatrix< DMatTSMatSchurExpr< MT1, MT2 >, true > > | |
►Cblaze::SchurExpr< SparseMatrix< DMatTSMatSchurExpr< MT1, MT2 >, true > > | |
Cblaze::DMatTSMatSchurExpr< MT1, MT2 > | Expression object for dense matrix-transpose sparse matrix Schur product.The DMatTSMatSchurExpr class represents the compile time expression for Schur products between a dense matrix and a column-major sparse matrix |
►Cblaze::Matrix< DVecSVecOuterExpr< VT1, VT2 >, SO > | |
►Cblaze::SparseMatrix< DVecSVecOuterExpr< VT1, VT2 >, false > | |
►Cblaze::Expression< SparseMatrix< DVecSVecOuterExpr< VT1, VT2 >, false > > | |
►Cblaze::MultExpr< SparseMatrix< DVecSVecOuterExpr< VT1, VT2 >, false > > | |
►Cblaze::VecTVecMultExpr< SparseMatrix< DVecSVecOuterExpr< VT1, VT2 >, false > > | |
Cblaze::DVecSVecOuterExpr< VT1, VT2 > | Expression object for dense vector-sparse vector outer products.The DVecSVecOuterExpr class represents the compile time expression for dense vector-sparse vector outer products |
►Cblaze::Matrix< IdentityMatrix< Type, SO >, SO > | |
►Cblaze::SparseMatrix< IdentityMatrix< Type, SO >, SO > | |
►Cblaze::Expression< SparseMatrix< IdentityMatrix< Type, SO >, SO > > | |
Cblaze::IdentityMatrix< Type, SO > | Efficient implementation of an identity matrix.The IdentityMatrix class template is the representation of an immutable, arbitrary sized identity matrix with elements of arbitrary type. The type of the elements and the storage order of the matrix can be specified via the two template parameters: |
►Cblaze::Matrix< PT, SO > | |
►Cblaze::DenseMatrix< PT, IsColumnMajorMatrix_v< MT > > | |
Cblaze::DenseMatrixProxy< PT, MT > | Proxy backend for dense matrix types.The DenseMatrixProxy class serves as a backend for the Proxy class. It is used in case the data type represented by the proxy is a dense matrix and augments the Proxy interface by the complete interface required of dense matrices |
►Cblaze::SparseMatrix< PT, IsColumnMajorMatrix_v< MT > > | |
Cblaze::SparseMatrixProxy< PT, MT > | Proxy backend for sparse matrix types.The SparseMatrixProxy class serves as a backend for the Proxy class. It is used in case the data type represented by the proxy is a sparse matrix and augments the Proxy interface by the complete interface required of sparse matrices |
►Cblaze::Matrix< SMatDeclDiagExpr< MT, SO >, SO > | |
►Cblaze::SparseMatrix< SMatDeclDiagExpr< MT, SO >, SO > | |
►Cblaze::Expression< SparseMatrix< SMatDeclDiagExpr< MT, SO >, SO > > | |
►Cblaze::DeclExpr< SparseMatrix< SMatDeclDiagExpr< MT, SO >, SO > > | |
►Cblaze::DeclDiagExpr< SparseMatrix< SMatDeclDiagExpr< MT, SO >, SO > > | |
Cblaze::SMatDeclDiagExpr< MT, SO > | Expression object for the explicit diagonal declaration of sparse matrices.The SMatDeclDiagExpr class represents the compile time expression for the explicit diagonal declaration of a sparse matrix |
►Cblaze::Matrix< SMatDeclHermExpr< MT, SO >, SO > | |
►Cblaze::SparseMatrix< SMatDeclHermExpr< MT, SO >, SO > | |
►Cblaze::Expression< SparseMatrix< SMatDeclHermExpr< MT, SO >, SO > > | |
►Cblaze::DeclExpr< SparseMatrix< SMatDeclHermExpr< MT, SO >, SO > > | |
►Cblaze::DeclHermExpr< SparseMatrix< SMatDeclHermExpr< MT, SO >, SO > > | |
Cblaze::SMatDeclHermExpr< MT, SO > | Expression object for the explicit Hermitian declaration of sparse matrices.The SMatDeclHermExpr class represents the compile time expression for the explicit Hermitian declaration of a sparse matrix |
►Cblaze::Matrix< SMatDeclLowExpr< MT, SO >, SO > | |
►Cblaze::SparseMatrix< SMatDeclLowExpr< MT, SO >, SO > | |
►Cblaze::Expression< SparseMatrix< SMatDeclLowExpr< MT, SO >, SO > > | |
►Cblaze::DeclExpr< SparseMatrix< SMatDeclLowExpr< MT, SO >, SO > > | |
►Cblaze::DeclLowExpr< SparseMatrix< SMatDeclLowExpr< MT, SO >, SO > > | |
Cblaze::SMatDeclLowExpr< MT, SO > | Expression object for the explicit lower declaration of sparse matrices.The SMatDeclLowExpr class represents the compile time expression for the explicit lower declaration of a sparse matrix |
►Cblaze::Matrix< SMatDeclSymExpr< MT, SO >, SO > | |
►Cblaze::SparseMatrix< SMatDeclSymExpr< MT, SO >, SO > | |
►Cblaze::Expression< SparseMatrix< SMatDeclSymExpr< MT, SO >, SO > > | |
►Cblaze::DeclExpr< SparseMatrix< SMatDeclSymExpr< MT, SO >, SO > > | |
►Cblaze::DeclSymExpr< SparseMatrix< SMatDeclSymExpr< MT, SO >, SO > > | |
Cblaze::SMatDeclSymExpr< MT, SO > | Expression object for the explicit symmetry declaration of sparse matrices.The SMatDeclSymExpr class represents the compile time expression for the explicit symmetry declaration of a sparse matrix |
►Cblaze::Matrix< SMatDeclUppExpr< MT, SO >, SO > | |
►Cblaze::SparseMatrix< SMatDeclUppExpr< MT, SO >, SO > | |
►Cblaze::Expression< SparseMatrix< SMatDeclUppExpr< MT, SO >, SO > > | |
►Cblaze::DeclExpr< SparseMatrix< SMatDeclUppExpr< MT, SO >, SO > > | |
►Cblaze::DeclUppExpr< SparseMatrix< SMatDeclUppExpr< MT, SO >, SO > > | |
Cblaze::SMatDeclUppExpr< MT, SO > | Expression object for the explicit upper declaration of sparse matrices.The SMatDeclUppExpr class represents the compile time expression for the explicit upper declaration of a sparse matrix |
►Cblaze::Matrix< SMatDMatKronExpr< MT1, MT2, SO >, SO > | |
►Cblaze::SparseMatrix< SMatDMatKronExpr< MT1, MT2, SO >, SO > | |
►Cblaze::Expression< SparseMatrix< SMatDMatKronExpr< MT1, MT2, SO >, SO > > | |
►Cblaze::KronExpr< SparseMatrix< SMatDMatKronExpr< MT1, MT2, SO >, SO > > | |
►Cblaze::MatMatKronExpr< SparseMatrix< SMatDMatKronExpr< MT1, MT2, SO >, SO > > | |
Cblaze::SMatDMatKronExpr< MT1, MT2, SO > | Expression object for sparse matrix-dense matrix Kronecker product.The SMatDMatKronExpr class represents the compile time expression for Kronecker products between a sparse matrix and a dense matrix |
►Cblaze::Matrix< SMatDMatSchurExpr< MT1, MT2 >, SO > | |
►Cblaze::SparseMatrix< SMatDMatSchurExpr< MT1, MT2 >, false > | |
►Cblaze::Expression< SparseMatrix< SMatDMatSchurExpr< MT1, MT2 >, false > > | |
►Cblaze::SchurExpr< SparseMatrix< SMatDMatSchurExpr< MT1, MT2 >, false > > | |
Cblaze::SMatDMatSchurExpr< MT1, MT2 > | Expression object for sparse matrix-dense matrix Schur product.The SMatDMatSchurExpr class represents the compile time expression for Schur products between a row-major sparse matrix and a dense matrix |
►Cblaze::Matrix< SMatEvalExpr< MT, SO >, SO > | |
►Cblaze::SparseMatrix< SMatEvalExpr< MT, SO >, SO > | |
►Cblaze::Expression< SparseMatrix< SMatEvalExpr< MT, SO >, SO > > | |
►Cblaze::EvalExpr< SparseMatrix< SMatEvalExpr< MT, SO >, SO > > | |
►Cblaze::MatEvalExpr< SparseMatrix< SMatEvalExpr< MT, SO >, SO > > | |
Cblaze::SMatEvalExpr< MT, SO > | 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 |
►Cblaze::Matrix< SMatMapExpr< MT, OP, SO >, SO > | |
►Cblaze::SparseMatrix< SMatMapExpr< MT, OP, SO >, SO > | |
►Cblaze::Expression< SparseMatrix< SMatMapExpr< MT, OP, SO >, SO > > | |
►Cblaze::UnaryMapExpr< SparseMatrix< SMatMapExpr< MT, OP, SO >, SO > > | |
►Cblaze::MatMapExpr< SparseMatrix< SMatMapExpr< MT, OP, SO >, SO > > | |
Cblaze::SMatMapExpr< MT, OP, SO > | Expression object for the sparse matrix map() function.The SMatMapExpr class represents the compile time expression for the evaluation of a custom operation on each element of a sparse matrix via the map() function |
►Cblaze::Matrix< SMatScalarDivExpr< MT, ST, SO >, SO > | |
►Cblaze::SparseMatrix< SMatScalarDivExpr< MT, ST, SO >, SO > | |
►Cblaze::Expression< SparseMatrix< SMatScalarDivExpr< MT, ST, SO >, SO > > | |
►Cblaze::DivExpr< SparseMatrix< SMatScalarDivExpr< MT, ST, SO >, SO > > | |
►Cblaze::MatScalarDivExpr< SparseMatrix< SMatScalarDivExpr< MT, ST, SO >, SO > > | |
Cblaze::SMatScalarDivExpr< MT, ST, SO > | 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 |
►Cblaze::Matrix< SMatScalarMultExpr< MT, ST, SO >, SO > | |
►Cblaze::SparseMatrix< SMatScalarMultExpr< MT, ST, SO >, SO > | |
►Cblaze::Expression< SparseMatrix< SMatScalarMultExpr< MT, ST, SO >, SO > > | |
►Cblaze::MultExpr< SparseMatrix< SMatScalarMultExpr< MT, ST, SO >, SO > > | |
►Cblaze::MatScalarMultExpr< SparseMatrix< SMatScalarMultExpr< MT, ST, SO >, SO > > | |
Cblaze::SMatScalarMultExpr< MT, ST, SO > | 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 |
►Cblaze::Matrix< SMatSerialExpr< MT, SO >, SO > | |
►Cblaze::SparseMatrix< SMatSerialExpr< MT, SO >, SO > | |
►Cblaze::Expression< SparseMatrix< SMatSerialExpr< MT, SO >, SO > > | |
►Cblaze::SerialExpr< SparseMatrix< SMatSerialExpr< MT, SO >, SO > > | |
►Cblaze::MatSerialExpr< SparseMatrix< SMatSerialExpr< MT, SO >, SO > > | |
Cblaze::SMatSerialExpr< MT, SO > | 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 |
►Cblaze::Matrix< SMatSMatAddExpr< MT1, MT2 >, SO > | |
►Cblaze::SparseMatrix< SMatSMatAddExpr< MT1, MT2 >, false > | |
►Cblaze::Expression< SparseMatrix< SMatSMatAddExpr< MT1, MT2 >, false > > | |
►Cblaze::AddExpr< SparseMatrix< SMatSMatAddExpr< MT1, MT2 >, false > > | |
►Cblaze::MatMatAddExpr< SparseMatrix< SMatSMatAddExpr< MT1, MT2 >, false > > | |
Cblaze::SMatSMatAddExpr< MT1, MT2 > | Expression object for sparse matrix-sparse matrix additions.The SMatSMatAddExpr class represents the compile time expression for additions between two row-major sparse matrices |
►Cblaze::Matrix< SMatSMatKronExpr< MT1, MT2 >, SO > | |
►Cblaze::SparseMatrix< SMatSMatKronExpr< MT1, MT2 >, false > | |
►Cblaze::Expression< SparseMatrix< SMatSMatKronExpr< MT1, MT2 >, false > > | |
►Cblaze::KronExpr< SparseMatrix< SMatSMatKronExpr< MT1, MT2 >, false > > | |
►Cblaze::MatMatKronExpr< SparseMatrix< SMatSMatKronExpr< MT1, MT2 >, false > > | |
Cblaze::SMatSMatKronExpr< MT1, MT2 > | Expression object for sparse matrix-sparse matrix Kronecker product.The SMatSMatKronExpr class represents the compile time expression for Kronecker products between sparse matrices of any storage order |
►Cblaze::Matrix< SMatSMatMultExpr< MT1, MT2 >, SO > | |
►Cblaze::SparseMatrix< SMatSMatMultExpr< MT1, MT2 >, false > | |
►Cblaze::Expression< SparseMatrix< SMatSMatMultExpr< MT1, MT2 >, false > > | |
►Cblaze::MultExpr< SparseMatrix< SMatSMatMultExpr< MT1, MT2 >, false > > | |
►Cblaze::MatMatMultExpr< SparseMatrix< SMatSMatMultExpr< MT1, MT2 >, false > > | |
Cblaze::SMatSMatMultExpr< MT1, MT2 > | Expression object for sparse matrix-sparse matrix multiplications.The SMatSMatMultExpr class represents the compile time expression for multiplications between row-major sparse matrices |
►Cblaze::Matrix< SMatSMatSchurExpr< MT1, MT2 >, SO > | |
►Cblaze::SparseMatrix< SMatSMatSchurExpr< MT1, MT2 >, false > | |
►Cblaze::Expression< SparseMatrix< SMatSMatSchurExpr< MT1, MT2 >, false > > | |
►Cblaze::SchurExpr< SparseMatrix< SMatSMatSchurExpr< MT1, MT2 >, false > > | |
Cblaze::SMatSMatSchurExpr< MT1, MT2 > | Expression object for sparse matrix-sparse matrix Schur product.The SMatSMatSchurExpr class represents the compile time expression for Schur products between sparse matrices |
►Cblaze::Matrix< SMatSMatSubExpr< MT1, MT2 >, SO > | |
►Cblaze::SparseMatrix< SMatSMatSubExpr< MT1, MT2 >, false > | |
►Cblaze::Expression< SparseMatrix< SMatSMatSubExpr< MT1, MT2 >, false > > | |
►Cblaze::SubExpr< SparseMatrix< SMatSMatSubExpr< MT1, MT2 >, false > > | |
►Cblaze::MatMatSubExpr< SparseMatrix< SMatSMatSubExpr< MT1, MT2 >, false > > | |
Cblaze::SMatSMatSubExpr< MT1, MT2 > | Expression object for sparse matrix-sparse matrix subtractions.The SMatSMatSubExpr class represents the compile time expression for subtractions between sparse matrices |
►Cblaze::Matrix< SMatTransExpr< MT, SO >, SO > | |
►Cblaze::SparseMatrix< SMatTransExpr< MT, SO >, SO > | |
►Cblaze::Expression< SparseMatrix< SMatTransExpr< MT, SO >, SO > > | |
►Cblaze::TransExpr< SparseMatrix< SMatTransExpr< MT, SO >, SO > > | |
►Cblaze::MatTransExpr< SparseMatrix< SMatTransExpr< MT, SO >, SO > > | |
Cblaze::SMatTransExpr< MT, SO > | Expression object for sparse matrix transpositions.The SMatTransExpr class represents the compile time expression for transpositions of sparse matrices |
►Cblaze::Matrix< SMatTransposer< MT, SO >, SO > | |
►Cblaze::SparseMatrix< SMatTransposer< MT, SO >, SO > | |
Cblaze::SMatTransposer< MT, SO > | Expression object for the transposition of a sparse matrix.The SMatTransposer class is a wrapper object for the temporary transposition of a sparse matrix |
►Cblaze::Matrix< SMatTSMatAddExpr< MT1, MT2 >, SO > | |
►Cblaze::SparseMatrix< SMatTSMatAddExpr< MT1, MT2 >, IsZero_v< MT1 > > | |
►Cblaze::Expression< SparseMatrix< SMatTSMatAddExpr< MT1, MT2 >, IsZero_v< MT1 > > > | |
►Cblaze::AddExpr< SparseMatrix< SMatTSMatAddExpr< MT1, MT2 >, IsZero_v< MT1 > > > | |
►Cblaze::MatMatAddExpr< SparseMatrix< SMatTSMatAddExpr< MT1, MT2 >, IsZero_v< MT1 > > > | |
Cblaze::SMatTSMatAddExpr< MT1, MT2 > | 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 |
►Cblaze::Matrix< SMatTSMatKronExpr< MT1, MT2 >, SO > | |
►Cblaze::SparseMatrix< SMatTSMatKronExpr< MT1, MT2 >, true > | |
►Cblaze::Expression< SparseMatrix< SMatTSMatKronExpr< MT1, MT2 >, true > > | |
►Cblaze::KronExpr< SparseMatrix< SMatTSMatKronExpr< MT1, MT2 >, true > > | |
►Cblaze::MatMatKronExpr< SparseMatrix< SMatTSMatKronExpr< MT1, MT2 >, true > > | |
Cblaze::SMatTSMatKronExpr< MT1, MT2 > | Expression object for sparse matrix-transpose sparse matrix Kronecker product.The SMatTSMatKronExpr class represents the compile time expression for Schur products between a row-major sparse matrix and a column-major sparse matrix |
►Cblaze::Matrix< SMatTSMatMultExpr< MT1, MT2 >, SO > | |
►Cblaze::SparseMatrix< SMatTSMatMultExpr< MT1, MT2 >, IsIdentity_v< MT1 > > | |
►Cblaze::Expression< SparseMatrix< SMatTSMatMultExpr< MT1, MT2 >, IsIdentity_v< MT1 > > > | |
►Cblaze::MultExpr< SparseMatrix< SMatTSMatMultExpr< MT1, MT2 >, IsIdentity_v< MT1 > > > | |
►Cblaze::MatMatMultExpr< SparseMatrix< SMatTSMatMultExpr< MT1, MT2 >, IsIdentity_v< MT1 > > > | |
Cblaze::SMatTSMatMultExpr< MT1, MT2 > | 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 |
►Cblaze::Matrix< SMatTSMatSchurExpr< MT1, MT2 >, SO > | |
►Cblaze::SparseMatrix< SMatTSMatSchurExpr< MT1, MT2 >, false > | |
►Cblaze::Expression< SparseMatrix< SMatTSMatSchurExpr< MT1, MT2 >, false > > | |
►Cblaze::SchurExpr< SparseMatrix< SMatTSMatSchurExpr< MT1, MT2 >, false > > | |
Cblaze::SMatTSMatSchurExpr< MT1, MT2 > | Expression object for sparse matrix-transpose sparse matrix Schur product.The SMatTSMatSchurExpr class represents the compile time expression for Schur products between a row-major sparse matrix and a column-major sparse matrix |
►Cblaze::Matrix< SMatTSMatSubExpr< MT1, MT2 >, SO > | |
►Cblaze::SparseMatrix< SMatTSMatSubExpr< MT1, MT2 >, IsZero_v< MT1 > > | |
►Cblaze::Expression< SparseMatrix< SMatTSMatSubExpr< MT1, MT2 >, IsZero_v< MT1 > > > | |
►Cblaze::SubExpr< SparseMatrix< SMatTSMatSubExpr< MT1, MT2 >, IsZero_v< MT1 > > > | |
►Cblaze::MatMatSubExpr< SparseMatrix< SMatTSMatSubExpr< MT1, MT2 >, IsZero_v< MT1 > > > | |
Cblaze::SMatTSMatSubExpr< MT1, MT2 > | 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 |
►Cblaze::Matrix< SVecDVecOuterExpr< VT1, VT2 >, SO > | |
►Cblaze::SparseMatrix< SVecDVecOuterExpr< VT1, VT2 >, true > | |
►Cblaze::Expression< SparseMatrix< SVecDVecOuterExpr< VT1, VT2 >, true > > | |
►Cblaze::MultExpr< SparseMatrix< SVecDVecOuterExpr< VT1, VT2 >, true > > | |
►Cblaze::VecTVecMultExpr< SparseMatrix< SVecDVecOuterExpr< VT1, VT2 >, true > > | |
Cblaze::SVecDVecOuterExpr< VT1, VT2 > | Expression object for sparse vector-dense vector outer products.The SVecDVecOuterExpr class represents the compile time expression for sparse vector-dense vector outer products |
►Cblaze::Matrix< SVecExpandExpr< VT, TF, CEAs... >, SO > | |
►Cblaze::SparseMatrix< SVecExpandExpr< VT, TF, CEAs... >, !TF > | |
►Cblaze::Expression< SparseMatrix< SVecExpandExpr< VT, TF, CEAs... >, !TF > > | |
►Cblaze::ExpandExpr< SparseMatrix< SVecExpandExpr< VT, TF, CEAs... >, !TF > > | |
►Cblaze::VecExpandExpr< SparseMatrix< SVecExpandExpr< VT, TF, CEAs... >, !TF >, CEAs... > | |
Cblaze::SVecExpandExpr< VT, TF, CEAs > | Expression object for sparse vector expansion.The SVecExpandExpr class represents the compile time expression for expansions of sparse vectors |
►Cblaze::Matrix< SVecSVecOuterExpr< VT1, VT2 >, SO > | |
►Cblaze::SparseMatrix< SVecSVecOuterExpr< VT1, VT2 >, false > | |
►Cblaze::Expression< SparseMatrix< SVecSVecOuterExpr< VT1, VT2 >, false > > | |
►Cblaze::MultExpr< SparseMatrix< SVecSVecOuterExpr< VT1, VT2 >, false > > | |
►Cblaze::VecTVecMultExpr< SparseMatrix< SVecSVecOuterExpr< VT1, VT2 >, false > > | |
Cblaze::SVecSVecOuterExpr< VT1, VT2 > | Expression object for sparse vector-sparse vector outer products.The SVecSVecOuterExpr class represents the compile time expression for sparse vector-sparse vector outer products |
►Cblaze::Matrix< TSMatDMatSchurExpr< MT1, MT2 >, SO > | |
►Cblaze::SparseMatrix< TSMatDMatSchurExpr< MT1, MT2 >, true > | |
►Cblaze::Expression< SparseMatrix< TSMatDMatSchurExpr< MT1, MT2 >, true > > | |
►Cblaze::SchurExpr< SparseMatrix< TSMatDMatSchurExpr< MT1, MT2 >, true > > | |
Cblaze::TSMatDMatSchurExpr< MT1, MT2 > | Expression object for transpose sparse matrix-dense matrix Schur product.The TSMatDMatSchurExpr class represents the compile time expression for Schur products between a transpose sparse matrix and a dense matrix |
►Cblaze::Matrix< TSMatSMatKronExpr< MT1, MT2 >, SO > | |
►Cblaze::SparseMatrix< TSMatSMatKronExpr< MT1, MT2 >, false > | |
►Cblaze::Expression< SparseMatrix< TSMatSMatKronExpr< MT1, MT2 >, false > > | |
►Cblaze::KronExpr< SparseMatrix< TSMatSMatKronExpr< MT1, MT2 >, false > > | |
►Cblaze::MatMatKronExpr< SparseMatrix< TSMatSMatKronExpr< MT1, MT2 >, false > > | |
Cblaze::TSMatSMatKronExpr< MT1, MT2 > | Expression object for sparse matrix-sparse matrix Kronecker product.The TSMatSMatKronExpr class represents the compile time expression for Kronecker products between a column-major sparse matrix and a row-major sparse matrix |
►Cblaze::Matrix< TSMatSMatMultExpr< MT1, MT2 >, SO > | |
►Cblaze::SparseMatrix< TSMatSMatMultExpr< MT1, MT2 >, !IsIdentity_v< MT1 > > | |
►Cblaze::Expression< SparseMatrix< TSMatSMatMultExpr< MT1, MT2 >, !IsIdentity_v< MT1 > > > | |
►Cblaze::MultExpr< SparseMatrix< TSMatSMatMultExpr< MT1, MT2 >, !IsIdentity_v< MT1 > > > | |
►Cblaze::MatMatMultExpr< SparseMatrix< TSMatSMatMultExpr< MT1, MT2 >, !IsIdentity_v< MT1 > > > | |
Cblaze::TSMatSMatMultExpr< MT1, MT2 > | 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 |
►Cblaze::Matrix< TSMatSMatSchurExpr< MT1, MT2 >, SO > | |
►Cblaze::SparseMatrix< TSMatSMatSchurExpr< MT1, MT2 >, false > | |
►Cblaze::Expression< SparseMatrix< TSMatSMatSchurExpr< MT1, MT2 >, false > > | |
►Cblaze::SchurExpr< SparseMatrix< TSMatSMatSchurExpr< MT1, MT2 >, false > > | |
Cblaze::TSMatSMatSchurExpr< MT1, MT2 > | Expression object for transpose sparse matrix-sparse matrix Schur products.The TSMatSMatSchurExpr class represents the compile time expression for Schur products between a column-major sparse matrix and a row-major sparse matrix |
►Cblaze::Matrix< TSMatSMatSubExpr< MT1, MT2 >, SO > | |
►Cblaze::SparseMatrix< TSMatSMatSubExpr< MT1, MT2 >, IsZero_v< MT2 > > | |
►Cblaze::Expression< SparseMatrix< TSMatSMatSubExpr< MT1, MT2 >, IsZero_v< MT2 > > > | |
►Cblaze::SubExpr< SparseMatrix< TSMatSMatSubExpr< MT1, MT2 >, IsZero_v< MT2 > > > | |
►Cblaze::MatMatSubExpr< SparseMatrix< TSMatSMatSubExpr< MT1, MT2 >, IsZero_v< MT2 > > > | |
Cblaze::TSMatSMatSubExpr< MT1, MT2 > | 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 |
►Cblaze::Matrix< TSMatTSMatAddExpr< MT1, MT2 >, SO > | |
►Cblaze::SparseMatrix< TSMatTSMatAddExpr< MT1, MT2 >, true > | |
►Cblaze::Expression< SparseMatrix< TSMatTSMatAddExpr< MT1, MT2 >, true > > | |
►Cblaze::AddExpr< SparseMatrix< TSMatTSMatAddExpr< MT1, MT2 >, true > > | |
►Cblaze::MatMatAddExpr< SparseMatrix< TSMatTSMatAddExpr< MT1, MT2 >, true > > | |
Cblaze::TSMatTSMatAddExpr< MT1, MT2 > | 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 |
►Cblaze::Matrix< TSMatTSMatKronExpr< MT1, MT2 >, SO > | |
►Cblaze::SparseMatrix< TSMatTSMatKronExpr< MT1, MT2 >, true > | |
►Cblaze::Expression< SparseMatrix< TSMatTSMatKronExpr< MT1, MT2 >, true > > | |
►Cblaze::KronExpr< SparseMatrix< TSMatTSMatKronExpr< MT1, MT2 >, true > > | |
►Cblaze::MatMatKronExpr< SparseMatrix< TSMatTSMatKronExpr< MT1, MT2 >, true > > | |
Cblaze::TSMatTSMatKronExpr< MT1, MT2 > | Expression object for transpose sparse matrix-transpose sparse matrix Kronecker product.The TSMatTSMatKronExpr class represents the compile time expression for Kronecker products between two column-major sparse matrices |
►Cblaze::Matrix< TSMatTSMatMultExpr< MT1, MT2 >, SO > | |
►Cblaze::SparseMatrix< TSMatTSMatMultExpr< MT1, MT2 >, true > | |
►Cblaze::Expression< SparseMatrix< TSMatTSMatMultExpr< MT1, MT2 >, true > > | |
►Cblaze::MultExpr< SparseMatrix< TSMatTSMatMultExpr< MT1, MT2 >, true > > | |
►Cblaze::MatMatMultExpr< SparseMatrix< TSMatTSMatMultExpr< MT1, MT2 >, true > > | |
Cblaze::TSMatTSMatMultExpr< MT1, MT2 > | 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 |
►Cblaze::Matrix< TSMatTSMatSchurExpr< MT1, MT2 >, SO > | |
►Cblaze::SparseMatrix< TSMatTSMatSchurExpr< MT1, MT2 >, true > | |
►Cblaze::Expression< SparseMatrix< TSMatTSMatSchurExpr< MT1, MT2 >, true > > | |
►Cblaze::SchurExpr< SparseMatrix< TSMatTSMatSchurExpr< MT1, MT2 >, true > > | |
Cblaze::TSMatTSMatSchurExpr< MT1, MT2 > | Expression object for transpose sparse matrix-transpose sparse matrix Schur product.The TSMatTSMatSchurExpr class represents the compile time expression for Schur products between two column-major sparse matrices |
►Cblaze::Matrix< TSMatTSMatSubExpr< MT1, MT2 >, SO > | |
►Cblaze::SparseMatrix< TSMatTSMatSubExpr< MT1, MT2 >, true > | |
►Cblaze::Expression< SparseMatrix< TSMatTSMatSubExpr< MT1, MT2 >, true > > | |
►Cblaze::SubExpr< SparseMatrix< TSMatTSMatSubExpr< MT1, MT2 >, true > > | |
►Cblaze::MatMatSubExpr< SparseMatrix< TSMatTSMatSubExpr< MT1, MT2 >, true > > | |
Cblaze::TSMatTSMatSubExpr< MT1, MT2 > | 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 |
►Cblaze::Matrix< ZeroMatrix< Type, SO >, SO > | |
►Cblaze::SparseMatrix< ZeroMatrix< Type, SO >, SO > | |
►Cblaze::Expression< SparseMatrix< ZeroMatrix< Type, SO >, SO > > | |
Cblaze::ZeroMatrix< Type, SO > | Efficient implementation of an zero matrix.The ZeroMatrix class template is the representation of an immutable, arbitrary sized zero matrix with elements of arbitrary type. The type of the elements and the storage order of the matrix can be specified via the two template parameters: |
Cblaze::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: |
Cblaze::Max | Generic wrapper for the max() function |
Cblaze::MaxSizeHelper1< typename, size_t, typename > | |
►Cblaze::MaxSizeHelper1< T, N > | |
Cblaze::MaxSize< T, N > | Compile time evaluation of the maximum size of vectors and matrices.The MaxSize type trait evaluates the maximum size of a particular dimension of the given vector or matrix type at compile time. In case the given type T is a vector or matrix type with a fixed maximum size (e.g. StaticVector, HybridVector, StaticMatrix, or HybridMatrix) and N is a valid dimension, the value member constant is set to the according size. In all other cases, value is set to -1 |
Cblaze::MaxSizeHelper2< typename, size_t, typename > | |
Cblaze::Min | Generic wrapper for the min() function |
Cblaze::ModuloAssign | Generic wrapper for modulo assignment |
►CMT | |
►Cblaze::Expression< MT > | |
►Cblaze::AddExpr< MT > | |
Cblaze::MatMatAddExpr< MT > | Base class for all matrix/matrix addition expression templates.The MatMatAddExpr class serves as a tag for all expression templates that implement a matrix/matrix addition. All classes, that represent a matrix addition and that are used within the expression template environment of the Blaze library have to derive publicly from this class in order to qualify as matrix addition expression template. Only in case a class is derived publicly from the MatMatAddExpr base class, the IsMatMatAddExpr type trait recognizes the class as valid matrix addition expression template |
►Cblaze::BinaryMapExpr< MT > | |
Cblaze::MatMatMapExpr< MT > | Base class for all binary matrix map expression templates.The MatMatMapExpr class serves as a tag for all expression templates that implement a binary matrix map operation. All classes, that represent a binary matrix map operation and that are used within the expression template environment of the Blaze library have to derive publicly from this class in order to qualify as binary matrix map expression template. Only in case a class is derived publicly from the MatMatMapExpr base class, the IsMatMatMapExpr type trait recognizes the class as valid binary matrix map expression template |
►Cblaze::KronExpr< MT > | Base class for all Kron product expression templates.The KronExpr class serves as a tag for all expression templates that implement mathematical Kronecker products. All classes, that represent a mathematical addition (Kronecker products between vectors or matrices) and that are used within the expression template environment of the Blaze library have to derive publicly from this class in order to qualify as Kronecker product expression template. Only in case a class is derived publicly from the KronExpr base class, the IsKronExpr type trait recognizes the class as valid Kronecker product expression template |
Cblaze::MatMatKronExpr< MT > | Base class for all matrix/matrix Kronecker expression templates.The MatMatKronExpr class serves as a tag for all expression templates that implement a matrix/matrix Kronecker product. All classes, that represent a matrix Kronecker product and that are used within the expression template environment of the Blaze library have to derive publicly from this class in order to qualify as matrix Kronecker product expression template. Only in case a class is derived publicly from the MatMatKronExpr base class, the IsMatMatKronExpr type trait recognizes the class as valid matrix Kronecker product expression template |
Cblaze::MatInvExpr< MT > | Base class for all matrix inversion expression templates.The MatInvExpr class serves as a tag for all expression templates that implement a matrix inversion operation. All classes, that represent a matrix inversion operation and that are used within the expression template environment of the Blaze library have to derive publicly from this class in order to qualify as matrix inversion expression template. Only in case a class is derived publicly from the MatInvExpr base class, the IsMatInvExpr type trait recognizes the class as valid matrix inversion expression template |
Cblaze::SchurExpr< MT > | Base class for all Schur product expression templates.The SchurExpr class serves as a tag for all expression templates that implement mathematical Schur products. All classes, that represent a mathematical Schur product and that are used within the expression template environment of the Blaze library have to derive publicly from this class in order to qualify as Schur product expression template. Only in case a class is derived publicly from the SchurExpr base class, the IsSchurExpr type trait recognizes the class as valid Schur product expression template |
►Cblaze::DeclExpr< MT > | |
Cblaze::DeclDiagExpr< MT > | Base class for all decldiag expression templates.The DeclDiagExpr class serves as a tag for all expression templates that represent an explicit diagonal declaration (decldiag) operation. All classes, that represent a decldiag operation and that are used within the expression template environment of the Blaze library have to derive publicly from this class in order to qualify as decldiag expression template. Only in case a class is derived publicly from the DeclDiagExpr base class, the IsDeclDiagExpr type trait recognizes the class as valid decldiag expression template |
Cblaze::DeclHermExpr< MT > | Base class for all declherm expression templates.The DeclHermExpr class serves as a tag for all expression templates that represent an explicit Hermitian declaration (declherm) operation. All classes, that represent a declherm operation and that are used within the expression template environment of the Blaze library have to derive publicly from this class in order to qualify as declherm expression template. Only in case a class is derived publicly from the DeclHermExpr base class, the IsDeclHermExpr type trait recognizes the class as valid declherm expression template |
Cblaze::DeclLowExpr< MT > | Base class for all decllow expression templates.The DeclLowExpr class serves as a tag for all expression templates that represent an explicit lower declaration (decllow) operation. All classes, that represent a decllow operation and that are used within the expression template environment of the Blaze library have to derive publicly from this class in order to qualify as decllow expression template. Only in case a class is derived publicly from the DeclLowExpr base class, the IsDeclLowExpr type trait recognizes the class as valid decllow expression template |
Cblaze::DeclSymExpr< MT > | Base class for all declsym expression templates.The DeclSymExpr class serves as a tag for all expression templates that represent an explicit symmetry declaration (declsym) operation. All classes, that represent a declsym operation and that are used within the expression template environment of the Blaze library have to derive publicly from this class in order to qualify as declsym expression template. Only in case a class is derived publicly from the DeclSymExpr base class, the IsDeclSymExpr type trait recognizes the class as valid declsym expression template |
Cblaze::DeclUppExpr< MT > | Base class for all declupp expression templates.The DeclUppExpr class serves as a tag for all expression templates that represent an explicit upper declaration (declupp) operation. All classes, that represent a declupp operation and that are used within the expression template environment of the Blaze library have to derive publicly from this class in order to qualify as declupp expression template. Only in case class is derived publicly from the DeclUppExpr base class, the IsDeclUppExpr type trait a recognizes the class as valid declupp expression template |
►Cblaze::DivExpr< MT > | |
Cblaze::MatScalarDivExpr< MT > | Base class for all matrix/scalar division expression templates.The MatScalarDivExpr class serves as a tag for all expression templates that implement a matrix/scalar division. All classes, that represent a matrix/scalar division and that are used within the expression template environment of the Blaze library have to derive publicly from this class in order to qualify as matrix/scalar division expression template. Only in case a class is derived publicly from the MatScalarDivExpr base class, the IsMatScalarDivExpr type trait recognizes the class as valid matrix/scalar division expression template |
►Cblaze::EvalExpr< MT > | |
Cblaze::MatEvalExpr< MT > | Base class for all matrix evaluation expression templates.The MatEvalExpr class serves as a tag for all expression templates that implement a matrix evaluation operation. All classes, that represent a matrix evaluation operation and that are used within the expression template environment of the Blaze library have to derive publicly from this class in order to qualify as matrix evaluation expression template. Only in case a class is derived publicly from the MatEvalExpr base class, the IsMatEvalExpr type trait recognizes the class as valid matrix evaluation expression template |
►Cblaze::ExpandExpr< MT > | |
Cblaze::VecExpandExpr< MT, CEAs > | Base class for all vector expansion expression templates.The VecExpandExpr class serves as a tag for all expression templates that implement a vector expansion. All classes, that represent a vector expansion and and that are used within the expression template environment of the Blaze library have to derive publicly from this class in order to qualify as vector expansion expression template. Only in case a class is derived publicly from the VecExpandExpr base class, the IsVecExpandExpr type trait recognizes the class as valid vector expansion expression template |
►Cblaze::MultExpr< MT > | |
Cblaze::MatMatMultExpr< MT > | Base class for all matrix/matrix multiplication expression templates.The MatMatMultExpr class serves as a tag for all expression templates that implement a matrix/matrix multiplication. All classes, that represent a matrix multiplication and that are used within the expression template environment of the Blaze library have to derive publicly from this class in order to qualify as matrix multiplication expression template. Only in case a class is derived publicly from the MatMatMultExpr base class, the IsMatMatMultExpr type trait recognizes the class as valid matrix multiplication expression template |
Cblaze::MatScalarMultExpr< MT > | Base class for all matrix/scalar multiplication expression templates.The MatScalarMultExpr class serves as a tag for all expression templates that implement a matrix/scalar multiplication. All classes, that represent a matrix/scalar multiplication and that are used within the expression template environment of the Blaze library have to derive publicly from this class in order to qualify as matrix/scalar multiplication expression template. Only in case a class is derived publicly from the MatScalarMultExpr base class, the IsMatScalarMultExpr type trait recognizes the class as valid matrix/scalar multiplication expression template |
Cblaze::VecTVecMultExpr< MT > | Base class for all outer product expression templates.The VecTVecMultExpr class serves as a tag for all expression templates that implement mathematical outer products (i.e. multiplications between a column vector and a row vector). All classes, that represent a mathematical outer product and that are used within the expression template environment of the Blaze library have to derive publicly from this class in order to qualify as outer product expression template. Only in case a class is derived publicly from the VecTVecMultExpr base class, the IsVecTVecMultExpr type trait recognizes the class as valid outer product expression template |
►Cblaze::SerialExpr< MT > | |
Cblaze::MatSerialExpr< MT > | Base class for all matrix serial evaluation expression templates.The MatSerialExpr class serves as a tag for all expression templates that enforce a serial evaluation of a matrix. All classes, that represent a matrix serialization operation and that are used within the expression template environment of the Blaze library have to derive publicly from this class in order to qualify as matrix serial evaluation expression template. Only in case a class is derived publicly from the MatSerialExpr base class, the IsMatSerialExpr type trait recognizes the class as valid matrix serial evaluation expression template |
►Cblaze::SubExpr< MT > | |
Cblaze::MatMatSubExpr< MT > | Base class for all matrix/matrix subtraction expression templates.The MatMatSubExpr class serves as a tag for all expression templates that implement a matrix/matrix subtraction. All classes, that represent a matrix subtraction and that are used within the expression template environment of the Blaze library have to derive publicly from this class in order to qualify as matrix subtraction expression template. Only in case a class is derived publicly from the MatMatSubExpr base class, the IsMatMatSubExpr type trait recognizes the class as valid matrix subtraction expression template |
►Cblaze::TransExpr< MT > | |
Cblaze::MatTransExpr< MT > | Base class for all matrix transposition expression templates.The MatTransExpr class serves as a tag for all expression templates that implement a matrix transposition operation. All classes, that represent a matrix transposition operation and that are used within the expression template environment of the Blaze library have to derive publicly from this class in order to qualify as matrix transposition expression template. Only in case a class is derived publicly from the MatTransExpr base class, the IsMatTransExpr type trait recognizes the class as valid matrix transposition expression template |
►Cblaze::UnaryMapExpr< MT > | |
Cblaze::MatMapExpr< MT > | Base class for all unary matrix map expression templates.The MatMapExpr class serves as a tag for all expression templates that represent a unary map operation on a matrix. All classes, that represent a unary matrix map operation and that are used within the expression template environment of the Blaze library have to derive publicly from this class in order to qualify as unary matrix map expression template. Only in case a class is derived publicly from the MatMapExpr base class, the IsMatMapExpr type trait recognizes the class as valid unary matrix map expression template |
Cblaze::Mult | Generic wrapper for the multiplication operator |
Cblaze::MultAssign | Generic wrapper for multiplication assignment |
Cblaze::MultTrait< T1, T2, typename > | Base template for the MultTrait class |
Cblaze::NegativeAccuracy< A > | Negative computation accuracy for floating point data types.The NegativeAccuracy class is a wrapper class around the functionality of the blaze::Limits class. It represents the negative computation accuracy of the Blaze library for any floating point data type. In order to assign a negative accuracy value, the NegativeAccuracy class can be implicitly converted to the three built-in floating point data types float, double and long double |
Cblaze::NegativeEpsilon< E > | Negative epsilon value for floating point data types.The NegativeEpsilon class is a wrapper class around the functionality of the blaze::Limits class. It represents the negative smallest difference between two values of any floating point data type. In order to assign a negative epsilon value, the Epsilon class can be implicitly converted to the three built-in floating point data types float, double and long double |
Cblaze::NegativeInfinity< I > | Negative infinity for built-in data types.The NegativeInfinity class is a wrapper class around the functionality of the blaze::Limits class to provide the possibility to assign negative infinity values to built-in data types. As negative infinity value, the largest possible negative value of the corresponding data type is used. In order to assign the negative infinity value, the NegativeInfinity class can be implicitly converted to all signed integral and floating point data types: |
Cblaze::NoDelete | No-delete policy class |
►Cblaze::NonCopyable | Base class for non-copyable class instances.The NonCopyable class is intended to work as a base class for non-copyable classes. Both the copy constructor and the copy assignment operator are explicitly deleted in order to prohibit copy operations of the derived classes.
|
Cblaze::MemoryPool< Type, Blocksize > | 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 |
Cblaze::Singleton< T, D1, D2, D3, D4, D5, D6, D7, D8 > | 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: |
Cblaze::Thread< TT, MT, LT, CT > | Implementation of a single thread of execution |
Cblaze::ThreadPool< TT, MT, LT, CT > | Implementation of a thread pool |
►Cblaze::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.
|
Cblaze::Random< Type > | Random number generator.The Random class encapsulates the initialization of the given random number generator with a pseudo-random seed obtained by the std::time() function. Currently, the mersenne-twister mt19937 as provided by the C++ standard library is used per default. For more information see the for instance the following documentation of the random number functionality of the C++11 standard library: |
Cblaze::Noop | Generic wrapper for the null function |
Cblaze::Not | Generic wrapper for the logical NOT operator |
Cblaze::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 |
►Cblaze::Operation | Base class for all operational expression templates.The Operation class serves as a tag for all operational expression templates. All classes that represent either a transformation (transpositions, ...) or a mathematical computation (addition, subtraction, multiplication, division, absolute value calculation, ...) and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as operational expression template. Only in case a class is derived from the Operation base class, the IsOperation type trait recognizes the class as valid operational expression template |
►Cblaze::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 |
Cblaze::DMatDMatAddExpr< MT1, MT2, SO > | 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 |
Cblaze::DMatDMatKronExpr< MT1, MT2, SO > | Expression object for dense matrix-dense matrix Kronecker products.The DMatDMatKronExpr class represents the compile time expression for Kronecker products between dense matrices of any storage order |
Cblaze::DMatDMatMapExpr< MT1, MT2, OP, SO > | Expression object for the dense matrix-dense matrix map() function.The DMatDMatMapExpr class represents the compile time expression for the pairwise evaluation of a binary custom operation on the elements of two dense matrices with identical storage order via the map() function |
Cblaze::DMatDMatMultExpr< MT1, MT2, SF, HF, LF, UF > | Expression object for dense matrix-dense matrix multiplications.The DMatDMatMultExpr class represents the compile time expression for multiplications between row-major dense matrices |
Cblaze::DMatDMatSchurExpr< MT1, MT2, SO > | Expression object for dense matrix-dense matrix Schur products.The DMatDMatSchurExpr class represents the compile time expression for Schur products between dense matrices with identical storage order |
Cblaze::DMatDMatSubExpr< MT1, MT2, SO > | 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 |
Cblaze::DMatDVecMultExpr< MT, VT > | 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 |
Cblaze::DMatEvalExpr< MT, SO > | 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 |
Cblaze::DMatInvExpr< MT, SO > | Expression object for dense matrix inversions.The DMatInvExpr class represents the compile time expression for inversions of dense matrices |
Cblaze::DMatMapExpr< MT, OP, SO > | Expression object for the dense matrix map() function.The DMatMapExpr class represents the compile time expression for the evaluation of a custom operation on each element of a dense matrix via the map() function |
Cblaze::DMatReduceExpr< MT, OP, columnwise > | Expression object for column-wise row-major dense matrix reduction operations.This specialization of the DMatReduceExpr class template represents the compile time expression for column-wise reduction operations of row-major dense matrices |
Cblaze::DMatReduceExpr< MT, OP, rowwise > | Expression object for row-wise row-major dense matrix reduction operations.This specialization of the DMatReduceExpr class template represents the compile time expression for row-wise reduction operations of row-major dense matrices |
Cblaze::DMatScalarDivExpr< MT, ST, SO > | 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 |
Cblaze::DMatScalarMultExpr< MT, ST, SO > | 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 |
Cblaze::DMatSerialExpr< MT, SO > | 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 |
Cblaze::DMatSMatAddExpr< MT1, MT2, SO > | 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 |
Cblaze::DMatSMatKronExpr< MT1, MT2, SO > | Expression object for dense matrix-sparse matrix Kronecker product.The DMatSMatKronExpr class represents the compile time expression for Kronecker products between a dense matrix and a sparse matrix |
Cblaze::DMatSMatMultExpr< MT1, MT2, SF, HF, LF, UF > | 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 |
Cblaze::DMatSMatSchurExpr< MT1, MT2 > | Expression object for dense matrix-sparse matrix Schur product.The DMatSMatSchurExpr class represents the compile time expression for Schur products between a dense matrix and a row-major sparse matrix |
Cblaze::DMatSMatSubExpr< MT1, MT2, SO > | 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 |
Cblaze::DMatSVecMultExpr< MT, VT > | 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 |
Cblaze::DMatTDMatAddExpr< MT1, MT2 > | 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 |
Cblaze::DMatTDMatMapExpr< MT1, MT2, OP > | Expression object for the dense matrix/tranpose dense matrix map() function.The DMatTDMatMapExpr class represents the compile time expression for the pairwise evaluation of a binary custom operation on the elements of a row-major dense matrix and a column-major matrix via the map() function |
Cblaze::DMatTDMatMultExpr< MT1, MT2, SF, HF, LF, UF > | 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 |
Cblaze::DMatTDMatSchurExpr< MT1, MT2 > | Expression object for dense matrix-transpose dense matrix Schur product.The DMatTDMatSchurExpr class represents the compile time expression for Schur product between a row-major dense matrix and a column-major dense matrix |
Cblaze::DMatTDMatSubExpr< MT1, MT2 > | 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 |
Cblaze::DMatTSMatAddExpr< MT1, MT2 > | 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 |
Cblaze::DMatTSMatMultExpr< MT1, MT2, SF, HF, LF, UF > | 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 |
Cblaze::DMatTSMatSchurExpr< MT1, MT2 > | Expression object for dense matrix-transpose sparse matrix Schur product.The DMatTSMatSchurExpr class represents the compile time expression for Schur products between a dense matrix and a column-major sparse matrix |
Cblaze::DMatTSMatSubExpr< MT1, MT2 > | 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 |
Cblaze::DVecDVecAddExpr< VT1, VT2, TF > | Expression object for dense vector-dense vector additions.The DVecDVecAddExpr class represents the compile time expression for additions between dense vectors |
Cblaze::DVecDVecCrossExpr< VT1, VT2, TF > | Expression object for dense vector-dense vector cross products.The DVecDVecCrossExpr class represents the compile time expression for cross products between dense vectors |
Cblaze::DVecDVecDivExpr< VT1, VT2, TF > | Expression object for dense vector-dense vector divisions.The DVecDVecDivExpr class represents the compile time expression for componentwise divisions between dense vectors |
Cblaze::DVecDVecKronExpr< VT1, VT2, TF > | Expression object for dense vector-dense vector Kronecker product.The DVecDVecKronExpr class represents the compile time expression for Kronecker products between dense vectors |
Cblaze::DVecDVecMapExpr< VT1, VT2, OP, TF > | Expression object for the dense vector-dense vector map() function.The DVecDVecMapExpr class represents the compile time expression for the pairwise evaluation of a binary custom operation on the elements of two dense vectors via the map() function |
Cblaze::DVecDVecMultExpr< VT1, VT2, TF > | Expression object for dense vector-dense vector multiplications.The DVecDVecMultExpr class represents the compile time expression for componentwise multiplications between dense vectors |
Cblaze::DVecDVecOuterExpr< VT1, VT2 > | Expression object for outer products between two dense vectors.The DVecDVecOuterExpr class represents the compile time expression for outer products between dense vectors |
Cblaze::DVecDVecSubExpr< VT1, VT2, TF > | Expression object for dense vector-dense vector subtractions.The DVecDVecSubExpr class represents the compile time expression for subtractions between dense vectors |
Cblaze::DVecEvalExpr< VT, TF > | 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 |
Cblaze::DVecMapExpr< VT, OP, TF > | Expression object for the dense vector map() function.The DVecMapExpr class represents the compile time expression for the evaluation of a custom operation on each element of a dense vector via the map() function |
Cblaze::DVecScalarDivExpr< VT, ST, TF > | 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 |
Cblaze::DVecScalarMultExpr< VT, ST, TF > | 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 |
Cblaze::DVecSerialExpr< VT, TF > | 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 |
Cblaze::DVecSVecAddExpr< VT1, VT2, TF > | 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 |
Cblaze::DVecSVecCrossExpr< VT1, VT2, TF > | 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 |
Cblaze::DVecSVecKronExpr< VT1, VT2, TF > | Expression object for dense vector-sparse vector Kronecker product.The DVecSVecKronExpr class represents the compile time expression for Kronecker products between a dense vector and a sparse vector |
Cblaze::DVecSVecMultExpr< VT1, VT2, TF > | 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 |
Cblaze::DVecSVecOuterExpr< VT1, VT2 > | Expression object for dense vector-sparse vector outer products.The DVecSVecOuterExpr class represents the compile time expression for dense vector-sparse vector outer products |
Cblaze::DVecSVecSubExpr< VT1, VT2, TF > | 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 |
Cblaze::SMatDMatKronExpr< MT1, MT2, SO > | Expression object for sparse matrix-dense matrix Kronecker product.The SMatDMatKronExpr class represents the compile time expression for Kronecker products between a sparse matrix and a dense matrix |
Cblaze::SMatDMatMultExpr< MT1, MT2, SF, HF, LF, UF > | 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 |
Cblaze::SMatDMatSchurExpr< MT1, MT2 > | Expression object for sparse matrix-dense matrix Schur product.The SMatDMatSchurExpr class represents the compile time expression for Schur products between a row-major sparse matrix and a dense matrix |
Cblaze::SMatDMatSubExpr< MT1, MT2, SO > | 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 |
Cblaze::SMatDVecMultExpr< MT, VT > | 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 |
Cblaze::SMatEvalExpr< MT, SO > | 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 |
Cblaze::SMatMapExpr< MT, OP, SO > | Expression object for the sparse matrix map() function.The SMatMapExpr class represents the compile time expression for the evaluation of a custom operation on each element of a sparse matrix via the map() function |
Cblaze::SMatReduceExpr< MT, OP, columnwise > | Expression object for column-wise row-major sparse matrix reduction operations.This specialization of the SMatReduceExpr class template represents the compile time expression for column-wise reduction operations of row-major sparse matrices |
Cblaze::SMatReduceExpr< MT, OP, rowwise > | Expression object for row-wise row-major sparse matrix reduction operations.This specialization of the SMatReduceExpr class template represents the compile time expression for row-wise reduction operations of row-major sparse matrices |
Cblaze::SMatScalarDivExpr< MT, ST, SO > | 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 |
Cblaze::SMatScalarMultExpr< MT, ST, SO > | 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 |
Cblaze::SMatSerialExpr< MT, SO > | 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 |
Cblaze::SMatSMatAddExpr< MT1, MT2 > | Expression object for sparse matrix-sparse matrix additions.The SMatSMatAddExpr class represents the compile time expression for additions between two row-major sparse matrices |
Cblaze::SMatSMatKronExpr< MT1, MT2 > | Expression object for sparse matrix-sparse matrix Kronecker product.The SMatSMatKronExpr class represents the compile time expression for Kronecker products between sparse matrices of any storage order |
Cblaze::SMatSMatMultExpr< MT1, MT2 > | Expression object for sparse matrix-sparse matrix multiplications.The SMatSMatMultExpr class represents the compile time expression for multiplications between row-major sparse matrices |
Cblaze::SMatSMatSchurExpr< MT1, MT2 > | Expression object for sparse matrix-sparse matrix Schur product.The SMatSMatSchurExpr class represents the compile time expression for Schur products between sparse matrices |
Cblaze::SMatSMatSubExpr< MT1, MT2 > | Expression object for sparse matrix-sparse matrix subtractions.The SMatSMatSubExpr class represents the compile time expression for subtractions between sparse matrices |
Cblaze::SMatSVecMultExpr< MT, VT > | 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 |
Cblaze::SMatTDMatMultExpr< MT1, MT2, SF, HF, LF, UF > | 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 |
Cblaze::SMatTDMatSubExpr< MT1, MT2 > | 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 |
Cblaze::SMatTSMatAddExpr< MT1, MT2 > | 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 |
Cblaze::SMatTSMatKronExpr< MT1, MT2 > | Expression object for sparse matrix-transpose sparse matrix Kronecker product.The SMatTSMatKronExpr class represents the compile time expression for Schur products between a row-major sparse matrix and a column-major sparse matrix |
Cblaze::SMatTSMatMultExpr< MT1, MT2 > | 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 |
Cblaze::SMatTSMatSchurExpr< MT1, MT2 > | Expression object for sparse matrix-transpose sparse matrix Schur product.The SMatTSMatSchurExpr class represents the compile time expression for Schur products between a row-major sparse matrix and a column-major sparse matrix |
Cblaze::SMatTSMatSubExpr< MT1, MT2 > | 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 |
Cblaze::SMatVarExpr< MT, columnwise > | Expression object for the column-wise variance function on row-major sparse matrices.This specialization of the SMatVarExpr class template represents the compile time expression for the column-wise variance function on row-major sparse matrices |
Cblaze::SMatVarExpr< MT, rowwise > | Expression object for the row-wise variance function on row-major sparse matrices.This specialization of the SMatVarExpr class template represents the compile time expression for the row-wise variance function on row-major sparse matrices |
Cblaze::SVecDVecCrossExpr< VT1, VT2, TF > | 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 |
Cblaze::SVecDVecDivExpr< VT1, VT2, TF > | Expression object for sparse vector-dense vector divisions.The SVecDVecDivExpr class represents the compile time expression for componentwise divisions between a sparse vector and a dense vector |
Cblaze::SVecDVecKronExpr< VT1, VT2, TF > | Expression object for sparse vector-dense vector Kronecker products.The SVecDVecKronExpr class represents the compile time expression for Kronecker products between a sparse vector and a dense vector |
Cblaze::SVecDVecMultExpr< VT1, VT2, TF > | 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 |
Cblaze::SVecDVecOuterExpr< VT1, VT2 > | Expression object for sparse vector-dense vector outer products.The SVecDVecOuterExpr class represents the compile time expression for sparse vector-dense vector outer products |
Cblaze::SVecDVecSubExpr< VT1, VT2, TF > | 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 |
Cblaze::SVecEvalExpr< VT, TF > | 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 |
Cblaze::SVecMapExpr< VT, OP, TF > | Expression object for the sparse vector map() function.The SVecMapExpr class represents the compile time expression for the evaluation of a custom operation on each element of a sparse vector via the map() function |
Cblaze::SVecScalarDivExpr< VT, ST, TF > | 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 |
Cblaze::SVecScalarMultExpr< VT, ST, TF > | 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 |
Cblaze::SVecSerialExpr< VT, TF > | 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 |
Cblaze::SVecSVecAddExpr< VT1, VT2, TF > | Expression object for sparse vector-sparse vector additions.The SVecSVecAddExpr class represents the compile time expression for additions between sparse vectors |
Cblaze::SVecSVecCrossExpr< VT1, VT2, TF > | Expression object for sparse vector-sparse vector cross products.The SVecSVecCrossExpr class represents the compile time expression for cross products between sparse vectors |
Cblaze::SVecSVecKronExpr< VT1, VT2, TF > | Expression object for sparse vector-sparse vector Kronecker products.The SVecSVecKronExpr class represents the compile time expression for Kronecker products between sparse vectors |
Cblaze::SVecSVecMultExpr< VT1, VT2, TF > | Expression object for sparse vector-sparse vector multiplications.The SVecSVecMultExpr class represents the compile time expression for componentwise multiplications between sparse vectors |
Cblaze::SVecSVecOuterExpr< VT1, VT2 > | Expression object for sparse vector-sparse vector outer products.The SVecSVecOuterExpr class represents the compile time expression for sparse vector-sparse vector outer products |
Cblaze::SVecSVecSubExpr< VT1, VT2, TF > | Expression object for sparse vector-sparse vector subtractions.The SVecSVecSubExpr class represents the compile time expression for subtractions between sparse vectors |
Cblaze::TDMatDMatMultExpr< MT1, MT2, SF, HF, LF, UF > | 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 |
Cblaze::TDMatDVecMultExpr< MT, VT > | 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 |
Cblaze::TDMatSMatAddExpr< MT1, MT2 > | 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 |
Cblaze::TDMatSMatMultExpr< MT1, MT2, SF, HF, LF, UF > | 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 |
Cblaze::TDMatSMatSubExpr< MT1, MT2 > | 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 |
Cblaze::TDMatSVecMultExpr< MT, VT > | 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 |
Cblaze::TDMatTDMatMultExpr< MT1, MT2, SF, HF, LF, UF > | 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 |
Cblaze::TDMatTSMatMultExpr< MT1, MT2, SF, HF, LF, UF > | 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 |
Cblaze::TDVecDMatMultExpr< VT, MT > | 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 |
Cblaze::TDVecSMatMultExpr< VT, MT > | 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 |
Cblaze::TDVecTDMatMultExpr< VT, MT > | 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 |
Cblaze::TDVecTSMatMultExpr< VT, MT > | 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 |
Cblaze::TSMatDMatMultExpr< MT1, MT2, SF, HF, LF, UF > | 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 |
Cblaze::TSMatDMatSchurExpr< MT1, MT2 > | Expression object for transpose sparse matrix-dense matrix Schur product.The TSMatDMatSchurExpr class represents the compile time expression for Schur products between a transpose sparse matrix and a dense matrix |
Cblaze::TSMatDMatSubExpr< MT1, MT2 > | 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 |
Cblaze::TSMatDVecMultExpr< MT, VT > | 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 |
Cblaze::TSMatSMatKronExpr< MT1, MT2 > | Expression object for sparse matrix-sparse matrix Kronecker product.The TSMatSMatKronExpr class represents the compile time expression for Kronecker products between a column-major sparse matrix and a row-major sparse matrix |
Cblaze::TSMatSMatMultExpr< MT1, MT2 > | 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 |
Cblaze::TSMatSMatSchurExpr< MT1, MT2 > | Expression object for transpose sparse matrix-sparse matrix Schur products.The TSMatSMatSchurExpr class represents the compile time expression for Schur products between a column-major sparse matrix and a row-major sparse matrix |
Cblaze::TSMatSMatSubExpr< MT1, MT2 > | 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 |
Cblaze::TSMatSVecMultExpr< MT, VT > | 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 |
Cblaze::TSMatTDMatMultExpr< MT1, MT2, SF, HF, LF, UF > | 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 |
Cblaze::TSMatTSMatAddExpr< MT1, MT2 > | 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 |
Cblaze::TSMatTSMatKronExpr< MT1, MT2 > | Expression object for transpose sparse matrix-transpose sparse matrix Kronecker product.The TSMatTSMatKronExpr class represents the compile time expression for Kronecker products between two column-major sparse matrices |
Cblaze::TSMatTSMatMultExpr< MT1, MT2 > | 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 |
Cblaze::TSMatTSMatSchurExpr< MT1, MT2 > | Expression object for transpose sparse matrix-transpose sparse matrix Schur product.The TSMatTSMatSchurExpr class represents the compile time expression for Schur products between two column-major sparse matrices |
Cblaze::TSMatTSMatSubExpr< MT1, MT2 > | 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 |
Cblaze::TSVecDMatMultExpr< VT, MT > | 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 |
Cblaze::TSVecSMatMultExpr< VT, MT > | 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 |
Cblaze::TSVecTDMatMultExpr< VT, MT > | 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 |
Cblaze::TSVecTSMatMultExpr< VT, MT > | 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 |
►Cblaze::Transformation | Base class for all transform expression templates.The Transformation class serves as a tag for all transformation expression templates. All classes, that represent a transformation (e.g. transpositions) and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as transformation expression template. Only in case a class is derived from the Transformation base class, the IsTransformation type trait recognizes the class as valid transformation expression template |
Cblaze::DVecExpandExpr< VT, TF, CEAs > | Expression object for dense vector expansion.The DVecExpandExpr class represents the compile time expression for expansions of dense vectors |
Cblaze::SVecExpandExpr< VT, TF, CEAs > | Expression object for sparse vector expansion.The SVecExpandExpr class represents the compile time expression for expansions of sparse vectors |
Cblaze::Or | Generic wrapper for the logical OR operator |
Cblaze::OrAssign | Generic wrapper for bitwise OR assignment |
Cblaze::ParallelSection< T > | 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 |
Cblaze::Pow | Generic wrapper for the pow() function |
Cblaze::Pow2 | Generic wrapper for the pow2() function |
Cblaze::Pow3 | Generic wrapper for the pow3() function |
Cblaze::Pow4 | Generic wrapper for the pow4() function |
Cblaze::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! |
Cblaze::ptrdiff_t | Pointer difference type of the Blaze library |
Cblaze::Qdrt | Generic wrapper for the qdrt() function |
Cblaze::Rand< T > | Default implementation of the Rand class for integral data types.This default implementation of the Rand class creates random, integral numbers in the range , where max is the maximal value of the given data type T |
Cblaze::Real | Generic wrapper for the real() function |
Cblaze::HybridMatrix< Type, M, N, SO >::Rebind< NewType > | Rebind mechanism to obtain a HybridMatrix with different data/element type |
Cblaze::InitializerMatrix< Type >::Rebind< NewType > | Rebind mechanism to obtain a InitializerMatrix with different data/element type |
Cblaze::CompressedMatrix< Type, SO >::Rebind< NewType > | Rebind mechanism to obtain a CompressedMatrix with different data/element type |
Cblaze::StaticVector< Type, N, TF >::Rebind< NewType > | Rebind mechanism to obtain a StaticVector with different data/element type |
Cblaze::ZeroVector< Type, TF >::Rebind< NewType > | Rebind mechanism to obtain a ZeroVector with different data/element type |
Cblaze::StaticMatrix< Type, M, N, SO >::Rebind< NewType > | Rebind mechanism to obtain a StaticMatrix with different data/element type |
Cblaze::ZeroMatrix< Type, SO >::Rebind< NewType > | Rebind mechanism to obtain a ZeroMatrix with different data/element type |
Cblaze::UniformVector< Type, TF >::Rebind< NewType > | Rebind mechanism to obtain a UniformVector with different data/element type |
Cblaze::IdentityMatrix< Type, SO >::Rebind< NewType > | Rebind mechanism to obtain an IdentityMatrix with different data/element type |
Cblaze::DynamicMatrix< Type, SO >::Rebind< NewType > | Rebind mechanism to obtain a DynamicMatrix with different data/element type |
Cblaze::CustomVector< Type, AF, PF, TF, RT >::Rebind< NewType > | Rebind mechanism to obtain a CustomVector with different data/element type |
Cblaze::DynamicVector< Type, TF >::Rebind< NewType > | Rebind mechanism to obtain a DynamicVector with different data/element type |
Cblaze::HybridVector< Type, N, TF >::Rebind< NewType > | Rebind mechanism to obtain a HybridVector with different data/element type |
Cblaze::CompressedVector< Type, TF >::Rebind< NewType > | Rebind mechanism to obtain a CompressedVector with different data/element type |
Cblaze::CustomMatrix< Type, AF, PF, SO, RT >::Rebind< NewType > | Rebind mechanism to obtain a CustomMatrix with different data/element type |
Cblaze::InitializerVector< Type, TF >::Rebind< NewType > | Rebind mechanism to obtain a InitializerVector with different data/element type |
Cblaze::UniformMatrix< Type, SO >::Rebind< NewType > | Rebind mechanism to obtain a UniformMatrix with different data/element type |
Cblaze::AlignedAllocator< Type >::rebind< Type2 > | Implementation of the AlignedAllocator rebind mechanism |
Cblaze::ReduceTrait< T, OP, RF > | Base template for the ReduceTrait class |
Cblaze::RemoveAdaptor< T > | 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 |
Cblaze::RemoveAllExtents< T > | Removal of all array extents.The RemoveAllExtents type trait removes all array extents from the given type T |
Cblaze::RemoveConst< T > | Removal of const-qualifiers.The RemoveConst type trait removes all top level 'const' qualifiers from the given type T |
Cblaze::RemoveCV< T > | Removal of top level cv-qualifiers.The RemoveCV type trait removes all top level cv-qualifiers from the given type T |
Cblaze::RemoveCVRef< T > | Removal of top level cv-qualifiers.The RemoveCVRef type trait removes any reference modifiers and all top level cv-qualifiers from the given type T |
Cblaze::RemoveExtent< T > | Removal of the top level array extent.The RemoveExtent type trait removes the top level array extent from the given type T |
Cblaze::RemovePointer< T > | Removal of pointer modifiers.The RemovePointer type trait removes any pointer modifiers from the given type T |
Cblaze::RemoveReference< T > | Removal of reference modifiers.The RemoveReference type trait removes any reference modifiers from the given type T |
Cblaze::RemoveVolatile< T > | Removal of volatile-qualifiers.The RemoveVolatile type trait removes all top level 'volatile' qualifiers from the given type T |
Cblaze::Reset | Generic wrapper for the reset() function |
Cblaze::UniformVector< Type, TF >::Resize< NewN > | Resize mechanism to obtain a UniformVector with a different fixed number of elements |
Cblaze::StaticVector< Type, N, TF >::Resize< NewN > | Resize mechanism to obtain a StaticVector with a different fixed number of elements |
Cblaze::StaticMatrix< Type, M, N, SO >::Resize< NewM, NewN > | Resize mechanism to obtain a StaticMatrix with different fixed dimensions |
Cblaze::CompressedMatrix< Type, SO >::Resize< NewM, NewN > | Resize mechanism to obtain a CompressedMatrix with different fixed dimensions |
Cblaze::CompressedVector< Type, TF >::Resize< NewN > | Resize mechanism to obtain a CompressedVector with a different fixed number of elements |
Cblaze::IdentityMatrix< Type, SO >::Resize< NewM, NewN > | Resize mechanism to obtain a IdentityMatrix with different fixed dimensions |
Cblaze::ZeroMatrix< Type, SO >::Resize< NewM, NewN > | Resize mechanism to obtain a ZeroMatrix with different fixed dimensions |
Cblaze::InitializerVector< Type, TF >::Resize< NewN > | Resize mechanism to obtain a InitializerVector with a different fixed number of elements |
Cblaze::InitializerMatrix< Type >::Resize< NewM, NewN > | Resize mechanism to obtain a InitializerMatrix with different fixed dimensions |
Cblaze::CustomMatrix< Type, AF, PF, SO, RT >::Resize< NewM, NewN > | Resize mechanism to obtain a CustomMatrix with different fixed dimensions |
Cblaze::ZeroVector< Type, TF >::Resize< NewN > | Resize mechanism to obtain a ZeroVector with a different fixed number of elements |
Cblaze::DynamicMatrix< Type, SO >::Resize< NewM, NewN > | Resize mechanism to obtain a DynamicMatrix with different fixed dimensions |
Cblaze::DynamicVector< Type, TF >::Resize< NewN > | Resize mechanism to obtain a DynamicVector with a different fixed number of elements |
Cblaze::HybridVector< Type, N, TF >::Resize< NewN > | Resize mechanism to obtain a HybridVector with a different fixed number of elements |
Cblaze::UniformMatrix< Type, SO >::Resize< NewM, NewN > | Resize mechanism to obtain a UniformMatrix with different fixed dimensions |
Cblaze::HybridMatrix< Type, M, N, SO >::Resize< NewM, NewN > | Resize mechanism to obtain a HybridMatrix with different fixed dimensions |
Cblaze::CustomVector< Type, AF, PF, TF, RT >::Resize< NewN > | Resize mechanism to obtain a CustomVector with a different fixed number of elements |
Cblaze::RightShiftAssign | Generic wrapper for bitwise right-shift assignment |
Cblaze::Round | Generic wrapper for the round() function |
Cblaze::RowData< CRAs > | Auxiliary class template for the data members of the Row class.The auxiliary RowData class template represents an abstraction of the data members of the Row class template. The necessary set of data members is selected depending on the number of compile time row arguments |
Cblaze::RowsTrait< MT, M > | Base template for the RowsTrait class |
Cblaze::RowTrait< MT, CRAs > | Base template for the RowTrait class |
Cblaze::Schur | Generic wrapper for the Schur product |
Cblaze::SchurTrait< T1, T2, typename > | Base template for the SchurTrait class |
Cblaze::Serial | Generic wrapper for the Serial() function |
Cblaze::SerialSection< T > | 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 |
Cblaze::SharedValue< Type > | 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 |
Cblaze::ShiftLI | Generic wrapper for the uniform left-shift operation |
Cblaze::ShiftLV | Generic wrapper for the elementwise left-shift operation |
Cblaze::ShiftRI | Generic wrapper for the uniform right-shift operation |
Cblaze::ShiftRV | Generic wrapper for the elementwise right-shift operation |
Cblaze::Sign | Generic wrapper for the sign() function |
Cblaze::SIMDcdouble | SIMD type for 64-bit double precision complex values |
Cblaze::SIMDcfloat | SIMD type for 32-bit single precision complex values |
Cblaze::SIMDcint16 | SIMD type for 16-bit signed integral complex values |
Cblaze::SIMDcint32 | SIMD type for 32-bit signed integral complex values |
Cblaze::SIMDcint64 | SIMD type for 64-bit signed integral complex values |
Cblaze::SIMDcint8 | SIMD type for 8-bit signed integral complex values |
Cblaze::SIMDcuint16 | SIMD type for 16-bit unsigned integral complex values |
Cblaze::SIMDcuint32 | SIMD type for 32-bit unsigned integral complex values |
Cblaze::SIMDcuint64 | SIMD type for 64-bit unsigned integral complex values |
Cblaze::SIMDcuint8 | SIMD type for 8-bit unsigned integral complex values |
Cblaze::SIMDdouble | SIMD type for 64-bit double precision floating point data values |
►CSIMDf32 | |
Cblaze::SIMDf32FmaddExpr< T1, T2, T3 > | Expression object for 32-bit floating point fused multiply-add operations.The SIMDf32FmaddExpr class represents the compile time expression for 32-bit floating point fused multiply-add operations |
Cblaze::SIMDf32FmsubExpr< T1, T2, T3 > | Expression object for 32-bit floating point fused multiply-subtract operations.The SIMDf32FmsubExpr class represents the compile time expression for 32-bit floating point fused multiply-subtract operations |
Cblaze::SIMDf32MultExpr< T1, T2 > | Expression object for 32-bit floating point multiplication operations.The SIMDf32MultExpr class represents the compile time expression for 32-bit floating point multiplication operations |
►CSIMDf64 | |
Cblaze::SIMDf64FmaddExpr< T1, T2, T3 > | Addition operator for fusing a 32-bit floating point multiplication and addition |
Cblaze::SIMDf64FmsubExpr< T1, T2, T3 > | Expression object for 64-bit floating point fused multiply-subtract operations.The SIMDf64FmsubExpr class represents the compile time expression for 64-bit floating point fused multiply-subtract operations |
Cblaze::SIMDf64MultExpr< T1, T2 > | Expression object for 64-bit floating point multiplication operations.The SIMDf64MultExpr class represents the compile time expression for 64-bit floating point multiplication operations |
Cblaze::SIMDfloat | SIMD type for 32-bit single precision floating point data values |
Cblaze::SIMDint16 | SIMD type for 16-bit signed integral data values |
Cblaze::SIMDint32 | SIMD type for 32-bit signed integral data values |
Cblaze::SIMDint64 | SIMD type for 64-bit integral data values |
Cblaze::SIMDint8 | SIMD type for 8-bit signed integral data values |
Cblaze::SIMDPack< T > | Base class for all SIMD data types.The SIMDPack class template is a base class for all SIMD data types within the Blaze library. It provides an abstraction from the actual type of the SIMD pack, but enables a conversion back to this type via the 'Curiously Recurring Template Pattern' (CRTP) |
►CSIMDTraitBase | |
Cblaze::SIMDTrait< T > | SIMD characteristics of data types.The SIMDTrait class template provides the SIMD characteristics of a specific data type: |
Cblaze::SIMDuint16 | SIMD type for 16-bit unsigned integral data values |
Cblaze::SIMDuint32 | SIMD type for 32-bit unsigned integral data values |
Cblaze::SIMDuint64 | SIMD type for 64-bit unsigned integral data values |
Cblaze::SIMDuint8 | SIMD type for 8-bit unsigned integral data values |
Cblaze::Sin | Generic wrapper for the sin() function |
Cblaze::Sinh | Generic wrapper for the sinh() function |
Cblaze::size_t | Size type of the Blaze library |
Cblaze::SizeHelper1< typename, size_t, typename > | |
►Cblaze::SizeHelper1< T, N > | |
Cblaze::Size< T, N > | Compile time evaluation of the size of vectors and matrices.The Size type trait evaluates the size of a particular dimension of the given vector or matrix type at compile time. In case the given type T is a vector or matrix type with a fixed size (e.g. StaticVector or StaticMatrix) and N is a valid dimension, the value member constant is set to the according size. In all other cases, value is set to -1 |
Cblaze::SizeHelper2< typename, size_t, typename > | |
►CSmallArrayData | |
Cblaze::SmallArray< T, N, A > | Implementation of a dynamic array with small array optimization.The SmallArray class template is a hybrid data structure between a static array and a dynamic array. It provides static, in-place memory for up to N elements of type T, but can grow beyond this size by allocating dynamic memory via its allocator of type A |
Cblaze::SMatReduceExpr< MT, OP, RF > | Base template for row-major sparse matrix partial reduction operations.The SMatReduceExpr class represents the compile time expression for partial reduction operations of row-major sparse matrices |
Cblaze::SMatVarExpr< MT, RF > | Base template for the row-/column-wise variance computations on row-major sparse matrices.The SMatVarExpr class represents the compile time expression for the computation of the row-/column-wise variance function on row-major sparse matrices |
►Cblaze::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 |
Cblaze::HermitianElement< MT > | Representation of two synchronized elements within the sparse Hermitian matrix.The HermitianElement class represents two synchronized elements (i.e. two value/index pairs) within a sparse Hermitian matrix. It guarantees that a modification of element via iterator is also applied to element . The following example illustrates this by means of a dense Hermitian matrix: |
Cblaze::SymmetricElement< MT > | Representation of two synchronized elements within the sparse symmetric matrix.The SymmetricElement class represents two synchronized elements (i.e. two value/index pairs) within a sparse symmetric matrix. It guarantees that a modification of element via iterator is also applied to element . The following example illustrates this by means of a dense Hermitian matrix: |
Cblaze::UniLowerElement< MT > | Representation of an element within a sparse lower unitriangular matrix.The UniLowerElement class represents an element (i.e. value/index pair) within a sparse lower unitriangular matrix. It guarantees that the unilower matrix invariant is not violated, i.e. that elements in the upper part of the matrix remain 0 and the diagonal elements remain 1. The following example illustrates this by means of a sparse lower unitriangular matrix: |
Cblaze::UniUpperElement< MT > | Representation of an element within a sparse upper unitriangular matrix.The UniUpperElement class represents an element (i.e. value/index pair) within a sparse upper unitriangular matrix. It guarantees that the uniupper matrix invariant is not violated, i.e. that elements in the lower part of the matrix remain 0 and the diagonal elements remain 1. The following example illustrates this by means of a sparse upper unitriangular matrix: |
Cblaze::ValueIndexPair< Type > | Index-value-pair for sparse vectors and matrices.The ValueIndexPair class represents a single index-value-pair of a sparse vector or sparse matrix |
Cblaze::SqrAbs | Generic wrapper for the squared abs() function |
Cblaze::Sqrt | Generic wrapper for the sqrt() function |
Cblaze::StrictlyLowerMatrix< MT, SO, DF > | Matrix adapter for strictly lower triangular matrices |
Cblaze::StrictlyUpperMatrix< MT, SO, DF > | Matrix adapter for strictly upper triangular matrices |
Cblaze::Sub | Generic wrapper for the subtraction operator |
Cblaze::SubAssign | Generic wrapper for subtraction assignment |
Cblaze::SubmatrixData< CSAs > | Auxiliary class template for the data members of the Submatrix class.The auxiliary SubmatrixData class template represents an abstraction of the data members of the Submatrix class template. The necessary set of data members is selected depending on the number of compile time submatrix arguments |
Cblaze::SubmatrixTrait< MT, CSAs > | Base template for the SubmatrixTrait class |
Cblaze::SubTrait< T1, T2, typename > | Base template for the SubTrait class |
Cblaze::SubvectorData< CSAs > | Auxiliary class template for the data members of the Subvector class.The auxiliary SubvectorData class template represents an abstraction of the data members of the Subvector class template. The necessary set of data members is selected depending on the number of compile time subvector arguments |
Cblaze::SubvectorTrait< VT, CSAs > | Base template for the SubvectorTrait class |
Cblaze::SymmetricMatrix< MT, SO, DF, NF > | Matrix adapter for symmetric matrices |
Cblaze::Tan | Generic wrapper for the tan() function |
Cblaze::Tanh | Generic wrapper for the tanh() function |
Cblaze::threadpool::TaskQueue | Task queue for the thread pool.The TaskQueue class represents the internal task container of a thread pool. It uses a FIFO (first in, first out) strategy to store and remove the assigned tasks |
Cblaze::timing::Timer< TP > | Progress timer for time and performance measurements.The Timer class offers timing & benchmarking functionality for all kinds of applications. The following example code demonstrates the use of the WcTimer class, which combines the Timer class template with the WcPolicy for wall clock time measurements, for a single time measurement: |
Cblaze::Trans | Generic wrapper for the trans() function |
Cblaze::Trunc | Generic wrapper for the trunc() function |
►CType | |
Cblaze::IsMatInvExpr< T > | Compile time check whether the given type is a matrix inversion expression template.This type trait class tests whether or not the given type Type is a matrix inversion expression template. In order to qualify as a valid matrix inversion expression template, the given type has to derive publicly from the MatInvExpr base class. In case the given type is a valid matrix inversion expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CType | |
Cblaze::IsTransExpr< T > | Compile time check whether the given type is a transposition expression template.This type trait class tests whether or not the given type Type is a transposition expression template (i.e. an expression representing a vector transposition or a matrix transposition). In order to qualify as a valid transposition expression template, the given type has to derive publicly from the TransExpr base class. In case the given type is a valid transposition expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CType | |
Cblaze::IsDenseMatrix< T > | Compile time check for dense matrix types.This type trait tests whether or not the given template parameter is a dense, N-dimensional matrix type. In case the type is a dense matrix type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise yes is set to false, Type is FalseType, and the class derives from FalseType |
►CType | |
Cblaze::IsSerialExpr< T > | Compile time check whether the given type is a serial evaluation expression template.This type trait class tests whether or not the given type Type is a serial evaluation expression template. In order to qualify as a valid serial evaluation expression template, the given type has to derive publicly from the SerialExpr base class. In case the given type is a valid serial evaluation expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CType | |
Cblaze::IsDeclDiagExpr< T > | Compile time check whether the given type is a decldiag expression template.This type trait class tests whether or not the given type Type is a decldiag expression template. In order to qualify as a valid decldiag expression template, the given type has to derive publicly from the DeclDiagExpr base class. In case the given type is a valid decldiag expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CType | |
Cblaze::IsVecVecDivExpr< T > | Compile time check whether the given type is a vector/vector division expression template.This type trait class tests whether or not the given type Type is a vector/vector division expression template. In order to qualify as a valid vector division expression template, the given type has to derive publicly from the VecVecDivExpr base class. In case the given type is a valid vector division expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CType | |
Cblaze::IsVecVecAddExpr< T > | Compile time check whether the given type is a vector/vector addition expression template.This type trait class tests whether or not the given type Type is a vector/vector addition expression template. In order to qualify as a valid vector addition expression template, the given type has to derive publicly from the VecVecAddExpr base class. In case the given type is a valid vector addition expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CType | |
Cblaze::IsMatrix< T > | Compile time check for matrix types.This type trait tests whether or not the given template parameter is a N-dimensional dense or sparse matrix type. In case the type is a matrix type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise yes is set to false, Type is FalseType, and the class derives from FalseType |
►CType | |
Cblaze::IsVector< T > | Compile time check for vector types.This type trait tests whether or not the given template parameter is a N-dimensional dense or sparse vector type (i.e. whether T is derived from the Vector base class). In case the type is a vector type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CType | |
Cblaze::IsMatTransExpr< T > | Compile time check whether the given type is a matrix transposition expression template.This type trait class tests whether or not the given type Type is a matrix transposition expression template. In order to qualify as a valid matrix transposition expression template, the given type has to derive publicly from the MatTransExpr base class. In case the given type is a valid matrix transposition expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CType | |
Cblaze::IsDivExpr< T > | Compile time check whether the given type is a division expression template.This type trait class tests whether or not the given type Type is a division expression template (i.e. an expression representing a vector/scalar division or a matrix/scalar division). In order to qualify as a valid division expression template, the given type has to derive publicly from the DivExpr base class. In case the given type is a valid division expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CType | |
Cblaze::IsDeclSymExpr< T > | Compile time check whether the given type is a declsym expression template.This type trait class tests whether or not the given type Type is a declsym expression template. In order to qualify as a valid declsym expression template, the given type has to derive publicly from the DeclSymExpr base class. In case the given type is a valid declsym expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CType | |
Cblaze::IsVecExpandExpr< T > | Compile time check whether the given type is a vector expansion expression template.This type trait class tests whether or not the given type Type is a vector expansion expression template. In order to qualify as a valid vector expansion expression template, the given type has to derive publicly from the VecExpandExpr base class. In case the given type is a valid expansion expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CType | |
Cblaze::IsBinaryMapExpr< T > | Compile time check whether the given type is a binary map expression template.This type trait class tests whether or not the given type Type is a binary map expression template. In order to qualify as a valid binary map expression template, the given type has to derive publicly from the BinaryMapExpr base class. In case the given type is a valid binary map expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CType | |
Cblaze::IsMatMatKronExpr< T > | Compile time check whether the given type is a matrix/matrix Kronecker product expression template.This type trait class tests whether or not the given type Type is a matrix/matrix Kronecker product expression template. In order to qualify as a valid matrix Kronecker product expression template, the given type has to derive publicly from the MatMatKronExpr base class. In case the given type is a valid matrix Kronecker product expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CType | |
Cblaze::IsAddExpr< T > | Compile time check whether the given type is an addition expression template.This type trait class tests whether or not the given type Type is an addition expression template (i.e. an expression representing a vector addition or a matrix addition). In order to qualify as a valid addition expression template, the given type has to derive publicly from the AddExpr base class. In case the given type is a valid addition expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CType | |
Cblaze::IsColumnVector< T > | Compile time check for column vector types.This type trait tests whether or not the given template argument is a column dense or sparse vector type (i.e. a vector whose transposition flag is set to blaze::columnVector). In case the type is a column vector type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CType | |
Cblaze::IsSchurExpr< T > | Compile time check whether the given type is a Schur product expression template.This type trait class tests whether or not the given type Type is a Schur product expression template. In order to qualify as a valid Schur product expression template, the given type has to derive publicly from the SchurExpr base class. In case the given type is a valid Schur product expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CType | |
Cblaze::IsMatEvalExpr< T > | Compile time check whether the given type is a matrix evaluation expression template.This type trait class tests whether or not the given type Type is a matrix evaluation expression template. In order to qualify as a valid matrix evaluation expression template, the given type has to derive publicly from the MatEvalExpr base class. In case the given type is a valid matrix evaluation expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CType | |
Cblaze::IsSparseVector< T > | Compile time check for sparse vector types.This type trait tests whether or not the given template parameter is a sparse, N-dimensional vector type. In case the type is a sparse vector type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CType | |
Cblaze::IsDeclLowExpr< T > | Compile time check whether the given type is a decllow expression template.This type trait class tests whether or not the given type Type is a decllow expression template. In order to qualify as a valid decllow expression template, the given type has to derive publicly from the DeclLowExpr base class. In case the given type is a valid decllow expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CType | |
Cblaze::IsDenseVector< T > | Compile time check for dense vector types.This type trait tests whether or not the given template parameter is a dense, N-dimensional vector type. In case the type is a dense vector type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CType | |
Cblaze::IsMatScalarDivExpr< T > | Compile time check whether the given type is a matrix/scalar division expression template.This type trait class tests whether or not the given type Type is a matrix/scalar division expression template. In order to qualify as a valid matrix/scalar division expression template, the given type has to derive publicly from the MatScalarDivExpr base class. In case the given type is a valid matrix/scalar division expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CType | |
Cblaze::IsMatMatAddExpr< T > | Compile time check whether the given type is a matrix/matrix addition expression template.This type trait class tests whether or not the given type Type is a matrix/matrix addition expression template. In order to qualify as a valid matrix addition expression template, the given type has to derive publicly from the MatMatAddExpr base class. In case the given type is a valid matrix addition expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CType | |
Cblaze::DMatTransExpr< MT, SO > | Expression object for dense matrix transpositions.The DMatTransExpr class represents the compile time expression for transpositions of dense matrices |
Cblaze::DVecTransExpr< VT, TF > | Expression object for dense vector transpositions.The DVecTransExpr class represents the compile time expression for transpositions of dense vectors |
Cblaze::SMatTransExpr< MT, SO > | Expression object for sparse matrix transpositions.The SMatTransExpr class represents the compile time expression for transpositions of sparse matrices |
Cblaze::SVecTransExpr< VT, TF > | Expression object for sparse vector transpositions.The SVecTransExpr class represents the compile time expression for transpositions of sparse vectors |
►CType | |
Cblaze::IsVecEvalExpr< T > | Compile time check whether the given type is a vector evaluation expression template.This type trait class tests whether or not the given type Type is a vector evaluation expression template. In order to qualify as a valid vector evaluation expression template, the given type has to derive publicly from the VecEvalExpr base class. In case the given type is a valid vector evaluation expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CType | |
Cblaze::IsSparseMatrix< T > | Compile time check for sparse matrix types.This type trait tests whether or not the given template parameter is a sparse, N-dimensional matrix type. In case the type is a sparse matrix type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CType | |
Cblaze::IsMatScalarMultExpr< T > | Compile time check whether the given type is a matrix/scalar multiplication expression template.This type trait class tests whether or not the given type Type is a matrix/scalar multiplication expression template. In order to qualify as a valid matrix/scalar multiplication expression template, the given type has to derive publicly from the MatScalarMultExpr base class. In case the given type is a valid matrix/scalar multiplication expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CType | |
Cblaze::IsVecVecKronExpr< T > | Compile time check whether the given type is a vector/vector Kronecker product expression template.This type trait class tests whether or not the given type Type is a vector/vector Kronecker product expression template. In order to qualify as a valid vector Kronecker product expression template, the given type has to derive publicly from the VecVecKronExpr base class. In case the given type is a valid vector Kronecker product expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CType | |
Cblaze::IsRowVector< T > | Compile time check for row vector types.This type trait tests whether or not the given template argument is a row dense or sparse vector type (i.e. a vector whose transposition flag is set to blaze::rowVector). In case the type is a row vector type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CType | |
Cblaze::IsSIMDPack< T > | Compile time check for SIMD data types.This type trait tests whether the given data type is a Blaze SIMD packed data type. The following types are considered valid SIMD packed types: |
►CType | |
Cblaze::IsMatMatMapExpr< T > | Compile time check whether the given type is a binary matrix map expression template.This type trait class tests whether or not the given type Type is a binary matrix map expression template. In order to qualify as a valid binary matrix map expression template, the given type has to derive publicly from the MatMatMapExpr base class. In case the given type is a valid binary matrix map expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CType | |
Cblaze::IsDeclExpr< T > | Compile time check whether the given type is a declaration expression template.This type trait class tests whether or not the given type Type is a declaration expression template. In order to qualify as a valid declaration expression template, the given type has to derive publicly from the DeclExpr base class. In case the given type is a valid declaration expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CType | |
Cblaze::IsMultExpr< T > | Compile time check whether the given type is a multiplication expression template.This type trait class tests whether or not the given type Type is a multiplication expression template (i.e. an expression representing an element-wise vector multiplication, a matrix/vector multiplication, a vector/matrix multiplication, or a matrix multiplication). In order to qualify as a valid multiplication expression template, the given type has to derive publicly from the MultExpr base class. In case the given type is a valid multiplication expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CType | |
Cblaze::IsExpression< T > | Compile time check whether the given type is an expression template.This type trait class tests whether or not the given type Type is a Blaze expression template. In order to qualify as a valid expression template, the given type has to derive publicly from the Expression base class. In case the given type is a valid expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CType | |
Cblaze::IsDeclUppExpr< T > | Compile time check whether the given type is a declupp expression template.This type trait class tests whether or not the given type Type is a declupp expression template. In order to qualify as a valid declupp expression template, the given type has to derive publicly from the DeclUppExpr base class. In case the given type is a valid declupp expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CType | |
Cblaze::IsMatMatMultExpr< T > | Compile time check whether the given type is a matrix/matrix multiplication expression template.This type trait class tests whether or not the given type Type is a matrix/matrix multiplication expression template. In order to qualify as a valid matrix multiplication expression template, the given type has to derive publicly from the MatMatMultExpr base class. In case the given type is a valid matrix multiplication expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CType | |
Cblaze::IsMatVecMultExpr< T > | Compile time check whether the given type is a matrix/vector multiplication expression template.This type trait class tests whether or not the given type Type is a matrix/vector multiplication expression template. In order to qualify as a valid matrix/vector multiplication expression template, the given type has to derive publicly from the MatVecMultExpr base class. In case the given type is a valid matrix/vector multiplication expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CType | |
Cblaze::IsColumnMajorMatrix< T > | Compile time check for column-major matrix types.This type trait tests whether or not the given template argument is a column-major dense or sparse matrix type (i.e., a matrix whose storage order is set to true). In case the type is a column-major matrix type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CType | |
Cblaze::IsMatSerialExpr< T > | Compile time check whether the given type is a matrix serial evaluation expression template.This type trait class tests whether or not the given type Type is a matrix serial evaluation expression template. In order to qualify as a valid matrix serial evaluation expression template, the given type has to derive publicly from the MatSerialExpr base class. In case the given type is a valid matrix serial evaluation expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CType | |
Cblaze::IsCrossExpr< T > | Compile time check whether the given type is a cross product expression template.This type trait class tests whether or not the given type Type is a cross product expression template. In order to qualify as a valid cross product expression template, the given type has to derive publicly from the CrossExpr base class. In case the given type is a valid cross product expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CType | |
Cblaze::IsSubExpr< T > | Compile time check whether the given type is a subtraction expression template.This type trait class tests whether or not the given type Type is a subtraction expression template (i.e. an expression representing a vector subtraction or a matrix subtraction). In order to qualify as a valid subtraction expression template, the given type has to derive publicly from the SubExpr base class. In case the given type is a valid subtraction expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CType | |
Cblaze::IsRowMajorMatrix< T > | Compile time check for row-major matrix types.This type trait tests whether or not the given template argument is a row-major dense or sparse matrix type (i.e., a matrix whose storage order is set to true). In case the type is a row-major matrix type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CType | |
Cblaze::IsDeclaration< T > | Compile time check whether the given type is a declaration expression template.This type trait class tests whether the given type Type is a declaration expression template. In order to qualify as a valid declaration expression template, the given type has to derive publicly from the Declaration base class. In case the given type is a valid declaration expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CType | |
Cblaze::IsProxy< T > | Compile time check for proxy types.This type trait tests whether or not the given template parameter is a proxy type (i.e. publicly derived from the blaze::Proxy class template). In case the type is a proxy, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CType | |
Cblaze::IsMatMapExpr< T > | Compile time check whether the given type is a unary matrix map expression template.This type trait class tests whether or not the given type Type is a unary matrix map expression template. In order to qualify as a valid unary matrix map expression template, the given type has to derive publicly from the MatMapExpr base class. In case the given type is a valid unary matrix map expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CType | |
Cblaze::IsUnaryMapExpr< T > | Compile time check whether the given type is a unary map expression template.This type trait class tests whether or not the given type Type is a unary map expression template. In order to qualify as a valid unary map expression template, the given type has to derive publicly from the UnaryMapExpr base class. In case the given type is a valid unary map expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CType | |
Cblaze::IsMatMatSubExpr< T > | Compile time check whether the given type is a matrix/matrix subtraction expression template.This type trait class tests whether or not the given type Type is a matrix/matrix subtraction expression template. In order to qualify as a valid matrix subtraction expression template, the given type has to derive publicly from the MatMatSubExpr base class. In case the given type is a valid matrix subtraction expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CType | |
Cblaze::IsTVecMatMultExpr< T > | Compile time check whether the given type is a vector/matrix multiplication expression template.This type trait class tests whether or not the given type Type is a vector/matrix multiplication expression template. In order to qualify as a valid vector/matrix multiplication expression template, the given type has to derive publicly from the TVecMatMultExpr base class. In case the given type is a valid vector/matrix multiplication expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CType | |
Cblaze::IsKronExpr< T > | Compile time check whether the given type is a Kronecker product expression template.This type trait class tests whether or not the given type Type is a Kronecker product expression template. In order to qualify as a valid Kronecker product expression template, the given type has to derive publicly from the KronExpr base class. In case the given type is a valid Kronecker product expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CType | |
Cblaze::IsVecScalarDivExpr< T > | Compile time check whether the given type is a vector/scalar division expression template.This type trait class tests whether or not the given type Type is a vector/scalar division expression template. In order to qualify as a valid vector/scalar division expression template, the given type has to derive publicly from the VecScalarDivExpr base class. In case the given type is a valid vector/scalar division expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CType | |
Cblaze::IsVecMapExpr< T > | Compile time check whether the given type is a unary vector map expression template.This type trait class tests whether or not the given type Type is a unary vector map expression template. In order to qualify as a valid unary vector map expression template, the given type has to derive publicly from the VecMapExpr base class. In case the given type is a valid unary vector map expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CType | |
Cblaze::IsDeclHermExpr< T > | Compile time check whether the given type is a declherm expression template.This type trait class tests whether or not the given type Type is a declherm expression template. In order to qualify as a valid declherm expression template, the given type has to derive publicly from the DeclHermExpr base class. In case the given type is a valid declherm expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CType | |
Cblaze::IsExpandExpr< T > | Compile time check whether the given type is an expansion expression template.This type trait class tests whether or not the given type Type is an expansion expression template. In order to qualify as a valid expansion expression template, the given type has to derive publicly from the ExpandExpr base class. In case the given type is a valid expansion expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CType | |
Cblaze::IsVecVecMapExpr< T > | Compile time check whether the given type is a binary vector map expression template.This type trait class tests whether or not the given type Type is a binary vector map expression template. In order to qualify as a valid binary vector map expression template, the given type has to derive publicly from the VecVecMapExpr base class. In case the given type is a valid binary vector map expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CType | |
Cblaze::IsVecSerialExpr< T > | Compile time check whether the given type is a vector serial evaluation expression template.This type trait class tests whether or not the given type Type is a vector serial evaluation expression template. In order to qualify as a valid vector serial evaluation expression template, the given type has to derive publicly from the VecSerialExpr base class. In case the given type is a valid vector serial evaluation expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CType | |
Cblaze::IsVecScalarMultExpr< T > | Compile time check whether the given type is a vector/scalar multiplication expression template.This type trait class tests whether or not the given type Type is a vector/scalar multiplication expression template. In order to qualify as a valid vector/scalar multiplication expression template, the given type has to derive publicly from the VecScalarMultExpr base class. In case the given type is a valid vector/scalar multiplication expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CType | |
Cblaze::IsMatReduceExpr< T > | Compile time check whether the given type is a reduction expression template.This type trait class tests whether or not the given type Type is a matrix reduction expression template. In order to qualify as a valid matrix reduction expression template, the given type has to derive publicly from the MatReduceExpr base class. In case the given type is a valid reduction expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CType | |
Cblaze::IsView< T > | Compile time check for views.This type trait tests whether or not the given template parameter is a view (i.e. subvector, submatrix, row, column, ...). In case the type is a view, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CType | |
Cblaze::IsVecTVecMultExpr< T > | Compile time check whether the given type is an outer product expression template.This type trait class tests whether or not the given type Type is an outer product expression template (i.e. an expression representing the multiplication between a column vector and a row vector). In order to qualify as a valid outer product expression template, the given type has to derive publicly from the VecTVecMultExpr base class. In case the given type is a valid outer product expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CType | |
Cblaze::IsVecVecMultExpr< T > | Compile time check whether the given type is a vector/vector multiplication expression template.This type trait class tests whether or not the given type Type is a vector/vector multiplication expression template. In order to qualify as a valid vector multiplication expression template, the given type has to derive publicly from the VecVecMultExpr base class. In case the given type is a valid vector multiplication expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CType | |
Cblaze::IsVecTransExpr< T > | Compile time check whether the given type is a vector transposition expression template.This type trait class tests whether or not the given type Type is a vector transposition expression template. In order to qualify as a valid vector transposition expression template, the given type has to derive publicly from the VecTransExpr base class. In case the given type is a valid vector transposition expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CType | |
Cblaze::IsEvalExpr< T > | Compile time check whether the given type is an evaluation expression template.This type trait class tests whether or not the given type Type is an evaluation expression template. In order to qualify as a valid evaluation expression template, the given type has to derive publicly from the EvalExpr base class. In case the given type is a valid evaluation expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CType | |
Cblaze::IsReduceExpr< T > | Compile time check whether the given type is a reduction expression template.This type trait class tests whether or not the given type Type is a reduction expression template. In order to qualify as a valid reduction expression template, the given type has to derive publicly from the ReduceExpr base class. In case the given type is a valid reduction expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
►CType | |
Cblaze::IsVecVecSubExpr< T > | Compile time check whether the given type is a vector/vector subtraction expression template.This type trait class tests whether or not the given type Type is a vector/vector subtraction expression template. In order to qualify as a valid vector subtraction expression template, the given type has to derive publicly from the VecVecSubExpr base class. In case the given type is a valid vector subtraction expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType |
Cblaze::TypeAt< TL, Index > | Indexing a type list.The TypeAt class can be used to access a type list at a specified position to query the according type. In order to index a type list, the TypeAt class has to be instantiated for a particular type list and an index value. The indexed type is available via the member type definition Type. The following example gives an impression of the use of the TypeAt class: |
Cblaze::TypeList< Ts > | Implementation of a type list.The TypeList class template represents a list of data types of arbitrary size. The following example gives an impression how type lists are used and manipulated: |
Cblaze::TypeValueMapping< T > | 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 |
Cblaze::uint16_t | 16-bit unsigned integer type of the Blaze library |
Cblaze::uint32_t | 32-bit unsigned integer type of the Blaze library |
Cblaze::uint64_t | 64-bit unsigned integer type of the Blaze library |
Cblaze::uint8_t | 8-bit unsigned integer type of the Blaze library |
Cblaze::UnderlyingBuiltin< T > | Evaluation of the underlying builtin element type of a given data type.This type trait evaluates the underlying fundamental element type at the heart of the given data type T. For this purpose either a nested ElementType or a nested value_type will be used. Examples: |
Cblaze::UnderlyingElement< T > | Evaluation of the element type of a given data type.This type trait evaluates the underlying element type of the given data type T. If the given type provides a nested type ElementType, this type is reported as underlying element type type via the nested type Type. Else if the type provides a nested value_type, this type is reported as underlying element type. Else the given type itself reported as the underlying element type. Examples: |
Cblaze::UnderlyingNumeric< T > | Evaluation of the underlying numeric element type of a given data type.This type trait evaluates the underlying numeric (fundamental or complex) element type at the heart of the given data type T. For this purpose either a nested ElementType or a nested value_type will be used. Examples: |
Cblaze::UniformIterator< Type, AF > | Implementation of a generic iterator for uniform vectors and matrices.The UniformIterator represents a generic random-access iterator that can be used for uniform vectors and specific rows/columns of uniform matrices |
Cblaze::UniLowerMatrix< MT, SO, DF > | Matrix adapter for lower unitriangular matrices |
Cblaze::SmallArray< T, N, A >::Uninitialized | Definition of the nested auxiliary struct Uninitialized |
Cblaze::Unique< TL > | Erasing all duplicates from a type list.The Unique class can be used to erase all duplicates from a type list TList. In order to erase all duplicates, the Unique class has to be instantiated for a particular type list. The following example gives an impression of the use of the Unique class: |
Cblaze::UniUpperMatrix< MT, SO, DF > | Matrix adapter for upper unitriangular matrices |
Cblaze::UnsignedValue< T > | 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 |
Cblaze::UpperMatrix< MT, SO, DF > | Matrix adapter for upper triangular matrices |
►Cblaze::Vector< VT, TF > | 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) |
Cblaze::DenseVector< VT, TF > | 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 |
Cblaze::SparseVector< VT, TF > | 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 |
►Cblaze::DenseVector< CustomVector< Type, AF, PF, TF, RT >, TF > | |
Cblaze::CustomVector< Type, AF, PF, TF, RT > | Efficient implementation of a customizable vector |
►Cblaze::DenseVector< DMatDVecMultExpr< MT, VT >, false > | |
►Cblaze::Expression< DenseVector< DMatDVecMultExpr< MT, VT >, false > > | |
►Cblaze::MultExpr< DenseVector< DMatDVecMultExpr< MT, VT >, false > > | |
►Cblaze::MatVecMultExpr< DenseVector< DMatDVecMultExpr< MT, VT >, false > > | |
Cblaze::DMatDVecMultExpr< MT, VT > | 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 |
►Cblaze::DenseVector< DMatReduceExpr< MT, OP, columnwise >, true > | |
►Cblaze::Expression< DenseVector< DMatReduceExpr< MT, OP, columnwise >, true > > | |
►Cblaze::ReduceExpr< DenseVector< DMatReduceExpr< MT, OP, columnwise >, true > > | |
►Cblaze::MatReduceExpr< DenseVector< DMatReduceExpr< MT, OP, columnwise >, true >, columnwise > | |
Cblaze::DMatReduceExpr< MT, OP, columnwise > | Expression object for column-wise row-major dense matrix reduction operations.This specialization of the DMatReduceExpr class template represents the compile time expression for column-wise reduction operations of row-major dense matrices |
►Cblaze::DenseVector< DMatReduceExpr< MT, OP, rowwise >, false > | |
►Cblaze::Expression< DenseVector< DMatReduceExpr< MT, OP, rowwise >, false > > | |
►Cblaze::ReduceExpr< DenseVector< DMatReduceExpr< MT, OP, rowwise >, false > > | |
►Cblaze::MatReduceExpr< DenseVector< DMatReduceExpr< MT, OP, rowwise >, false >, rowwise > | |
Cblaze::DMatReduceExpr< MT, OP, rowwise > | Expression object for row-wise row-major dense matrix reduction operations.This specialization of the DMatReduceExpr class template represents the compile time expression for row-wise reduction operations of row-major dense matrices |
►Cblaze::DenseVector< DMatSVecMultExpr< MT, VT >, false > | |
►Cblaze::Expression< DenseVector< DMatSVecMultExpr< MT, VT >, false > > | |
►Cblaze::MultExpr< DenseVector< DMatSVecMultExpr< MT, VT >, false > > | |
►Cblaze::MatVecMultExpr< DenseVector< DMatSVecMultExpr< MT, VT >, false > > | |
Cblaze::DMatSVecMultExpr< MT, VT > | 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 |
►Cblaze::DenseVector< DVecDVecAddExpr< VT1, VT2, TF >, TF > | |
►Cblaze::Expression< DenseVector< DVecDVecAddExpr< VT1, VT2, TF >, TF > > | |
►Cblaze::AddExpr< DenseVector< DVecDVecAddExpr< VT1, VT2, TF >, TF > > | |
►Cblaze::VecVecAddExpr< DenseVector< DVecDVecAddExpr< VT1, VT2, TF >, TF > > | |
Cblaze::DVecDVecAddExpr< VT1, VT2, TF > | Expression object for dense vector-dense vector additions.The DVecDVecAddExpr class represents the compile time expression for additions between dense vectors |
►Cblaze::DenseVector< DVecDVecCrossExpr< VT1, VT2, TF >, TF > | |
►Cblaze::Expression< DenseVector< DVecDVecCrossExpr< VT1, VT2, TF >, TF > > | |
►Cblaze::CrossExpr< DenseVector< DVecDVecCrossExpr< VT1, VT2, TF >, TF > > | |
Cblaze::DVecDVecCrossExpr< VT1, VT2, TF > | Expression object for dense vector-dense vector cross products.The DVecDVecCrossExpr class represents the compile time expression for cross products between dense vectors |
►Cblaze::DenseVector< DVecDVecDivExpr< VT1, VT2, TF >, TF > | |
►Cblaze::Expression< DenseVector< DVecDVecDivExpr< VT1, VT2, TF >, TF > > | |
►Cblaze::DivExpr< DenseVector< DVecDVecDivExpr< VT1, VT2, TF >, TF > > | |
►Cblaze::VecVecDivExpr< DenseVector< DVecDVecDivExpr< VT1, VT2, TF >, TF > > | |
Cblaze::DVecDVecDivExpr< VT1, VT2, TF > | Expression object for dense vector-dense vector divisions.The DVecDVecDivExpr class represents the compile time expression for componentwise divisions between dense vectors |
►Cblaze::DenseVector< DVecDVecKronExpr< VT1, VT2, TF >, TF > | |
►Cblaze::Expression< DenseVector< DVecDVecKronExpr< VT1, VT2, TF >, TF > > | |
►Cblaze::KronExpr< DenseVector< DVecDVecKronExpr< VT1, VT2, TF >, TF > > | |
►Cblaze::VecVecKronExpr< DenseVector< DVecDVecKronExpr< VT1, VT2, TF >, TF > > | |
Cblaze::DVecDVecKronExpr< VT1, VT2, TF > | Expression object for dense vector-dense vector Kronecker product.The DVecDVecKronExpr class represents the compile time expression for Kronecker products between dense vectors |
►Cblaze::DenseVector< DVecDVecMapExpr< VT1, VT2, OP, TF >, TF > | |
►Cblaze::Expression< DenseVector< DVecDVecMapExpr< VT1, VT2, OP, TF >, TF > > | |
►Cblaze::BinaryMapExpr< DenseVector< DVecDVecMapExpr< VT1, VT2, OP, TF >, TF > > | |
►Cblaze::VecVecMapExpr< DenseVector< DVecDVecMapExpr< VT1, VT2, OP, TF >, TF > > | |
Cblaze::DVecDVecMapExpr< VT1, VT2, OP, TF > | Expression object for the dense vector-dense vector map() function.The DVecDVecMapExpr class represents the compile time expression for the pairwise evaluation of a binary custom operation on the elements of two dense vectors via the map() function |
►Cblaze::DenseVector< DVecDVecMultExpr< VT1, VT2, TF >, TF > | |
►Cblaze::Expression< DenseVector< DVecDVecMultExpr< VT1, VT2, TF >, TF > > | |
►Cblaze::MultExpr< DenseVector< DVecDVecMultExpr< VT1, VT2, TF >, TF > > | |
►Cblaze::VecVecMultExpr< DenseVector< DVecDVecMultExpr< VT1, VT2, TF >, TF > > | |
Cblaze::DVecDVecMultExpr< VT1, VT2, TF > | Expression object for dense vector-dense vector multiplications.The DVecDVecMultExpr class represents the compile time expression for componentwise multiplications between dense vectors |
►Cblaze::DenseVector< DVecDVecSubExpr< VT1, VT2, TF >, TF > | |
►Cblaze::Expression< DenseVector< DVecDVecSubExpr< VT1, VT2, TF >, TF > > | |
►Cblaze::SubExpr< DenseVector< DVecDVecSubExpr< VT1, VT2, TF >, TF > > | |
►Cblaze::VecVecSubExpr< DenseVector< DVecDVecSubExpr< VT1, VT2, TF >, TF > > | |
Cblaze::DVecDVecSubExpr< VT1, VT2, TF > | Expression object for dense vector-dense vector subtractions.The DVecDVecSubExpr class represents the compile time expression for subtractions between dense vectors |
►Cblaze::DenseVector< DVecEvalExpr< VT, TF >, TF > | |
►Cblaze::Expression< DenseVector< DVecEvalExpr< VT, TF >, TF > > | |
►Cblaze::EvalExpr< DenseVector< DVecEvalExpr< VT, TF >, TF > > | |
►Cblaze::VecEvalExpr< DenseVector< DVecEvalExpr< VT, TF >, TF > > | |
Cblaze::DVecEvalExpr< VT, TF > | 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 |
►Cblaze::DenseVector< DVecMapExpr< VT, OP, TF >, TF > | |
►Cblaze::Expression< DenseVector< DVecMapExpr< VT, OP, TF >, TF > > | |
►Cblaze::UnaryMapExpr< DenseVector< DVecMapExpr< VT, OP, TF >, TF > > | |
►Cblaze::VecMapExpr< DenseVector< DVecMapExpr< VT, OP, TF >, TF > > | |
Cblaze::DVecMapExpr< VT, OP, TF > | Expression object for the dense vector map() function.The DVecMapExpr class represents the compile time expression for the evaluation of a custom operation on each element of a dense vector via the map() function |
►Cblaze::DenseVector< DVecScalarDivExpr< VT, ST, TF >, TF > | |
►Cblaze::Expression< DenseVector< DVecScalarDivExpr< VT, ST, TF >, TF > > | |
►Cblaze::DivExpr< DenseVector< DVecScalarDivExpr< VT, ST, TF >, TF > > | |
►Cblaze::VecScalarDivExpr< DenseVector< DVecScalarDivExpr< VT, ST, TF >, TF > > | |
Cblaze::DVecScalarDivExpr< VT, ST, TF > | 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 |
►Cblaze::DenseVector< DVecScalarMultExpr< VT, ST, TF >, TF > | |
►Cblaze::Expression< DenseVector< DVecScalarMultExpr< VT, ST, TF >, TF > > | |
►Cblaze::MultExpr< DenseVector< DVecScalarMultExpr< VT, ST, TF >, TF > > | |
►Cblaze::VecScalarMultExpr< DenseVector< DVecScalarMultExpr< VT, ST, TF >, TF > > | |
Cblaze::DVecScalarMultExpr< VT, ST, TF > | 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 |
►Cblaze::DenseVector< DVecSerialExpr< VT, TF >, TF > | |
►Cblaze::Expression< DenseVector< DVecSerialExpr< VT, TF >, TF > > | |
►Cblaze::SerialExpr< DenseVector< DVecSerialExpr< VT, TF >, TF > > | |
►Cblaze::VecSerialExpr< DenseVector< DVecSerialExpr< VT, TF >, TF > > | |
Cblaze::DVecSerialExpr< VT, TF > | 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 |
►Cblaze::DenseVector< DVecSVecAddExpr< VT1, VT2, TF >, TF > | |
►Cblaze::Expression< DenseVector< DVecSVecAddExpr< VT1, VT2, TF >, TF > > | |
►Cblaze::AddExpr< DenseVector< DVecSVecAddExpr< VT1, VT2, TF >, TF > > | |
►Cblaze::VecVecAddExpr< DenseVector< DVecSVecAddExpr< VT1, VT2, TF >, TF > > | |
Cblaze::DVecSVecAddExpr< VT1, VT2, TF > | 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 |
►Cblaze::DenseVector< DVecSVecCrossExpr< VT1, VT2, TF >, TF > | |
►Cblaze::Expression< DenseVector< DVecSVecCrossExpr< VT1, VT2, TF >, TF > > | |
►Cblaze::CrossExpr< DenseVector< DVecSVecCrossExpr< VT1, VT2, TF >, TF > > | |
Cblaze::DVecSVecCrossExpr< VT1, VT2, TF > | 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 |
►Cblaze::DenseVector< DVecSVecSubExpr< VT1, VT2, TF >, TF > | |
►Cblaze::Expression< DenseVector< DVecSVecSubExpr< VT1, VT2, TF >, TF > > | |
►Cblaze::SubExpr< DenseVector< DVecSVecSubExpr< VT1, VT2, TF >, TF > > | |
►Cblaze::VecVecSubExpr< DenseVector< DVecSVecSubExpr< VT1, VT2, TF >, TF > > | |
Cblaze::DVecSVecSubExpr< VT1, VT2, TF > | 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 |
►Cblaze::DenseVector< DVecTransExpr< VT, TF >, TF > | |
►Cblaze::Expression< DenseVector< DVecTransExpr< VT, TF >, TF > > | |
►Cblaze::TransExpr< DenseVector< DVecTransExpr< VT, TF >, TF > > | |
►Cblaze::VecTransExpr< DenseVector< DVecTransExpr< VT, TF >, TF > > | |
Cblaze::DVecTransExpr< VT, TF > | Expression object for dense vector transpositions.The DVecTransExpr class represents the compile time expression for transpositions of dense vectors |
►Cblaze::DenseVector< DVecTransposer< VT, TF >, TF > | |
Cblaze::DVecTransposer< VT, TF > | Expression object for the transposition of a dense vector.The DVecTransposer class is a wrapper object for the temporary transposition of a dense vector |
►Cblaze::DenseVector< DynamicVector< Type, TF >, TF > | |
Cblaze::DynamicVector< Type, TF > | 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: |
►Cblaze::DenseVector< HybridVector< Type, N, TF >, TF > | |
Cblaze::HybridVector< Type, N, TF > | 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: |
►Cblaze::DenseVector< InitializerVector< Type, TF >, TF > | |
Cblaze::InitializerVector< Type, TF > | Dense vector representation of an initializer list.The InitializerVector class template is a dense vector representation of an (extended) initializer list of arbitrary type. The type of the elements and the transpose flag of the vector can be specified via the two template parameters: |
►Cblaze::DenseVector< SMatDVecMultExpr< MT, VT >, false > | |
►Cblaze::Expression< DenseVector< SMatDVecMultExpr< MT, VT >, false > > | |
►Cblaze::MultExpr< DenseVector< SMatDVecMultExpr< MT, VT >, false > > | |
►Cblaze::MatVecMultExpr< DenseVector< SMatDVecMultExpr< MT, VT >, false > > | |
Cblaze::SMatDVecMultExpr< MT, VT > | 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 |
►Cblaze::DenseVector< SMatReduceExpr< MT, OP, columnwise >, true > | |
►Cblaze::Expression< DenseVector< SMatReduceExpr< MT, OP, columnwise >, true > > | |
►Cblaze::ReduceExpr< DenseVector< SMatReduceExpr< MT, OP, columnwise >, true > > | |
►Cblaze::MatReduceExpr< DenseVector< SMatReduceExpr< MT, OP, columnwise >, true >, columnwise > | |
Cblaze::SMatReduceExpr< MT, OP, columnwise > | Expression object for column-wise row-major sparse matrix reduction operations.This specialization of the SMatReduceExpr class template represents the compile time expression for column-wise reduction operations of row-major sparse matrices |
►Cblaze::DenseVector< SMatReduceExpr< MT, OP, rowwise >, false > | |
►Cblaze::Expression< DenseVector< SMatReduceExpr< MT, OP, rowwise >, false > > | |
►Cblaze::ReduceExpr< DenseVector< SMatReduceExpr< MT, OP, rowwise >, false > > | |
►Cblaze::MatReduceExpr< DenseVector< SMatReduceExpr< MT, OP, rowwise >, false >, rowwise > | |
Cblaze::SMatReduceExpr< MT, OP, rowwise > | Expression object for row-wise row-major sparse matrix reduction operations.This specialization of the SMatReduceExpr class template represents the compile time expression for row-wise reduction operations of row-major sparse matrices |
►Cblaze::DenseVector< SMatVarExpr< MT, columnwise >, true > | |
►Cblaze::Expression< DenseVector< SMatVarExpr< MT, columnwise >, true > > | |
►Cblaze::ReduceExpr< DenseVector< SMatVarExpr< MT, columnwise >, true > > | |
►Cblaze::MatReduceExpr< DenseVector< SMatVarExpr< MT, columnwise >, true >, columnwise > | |
Cblaze::SMatVarExpr< MT, columnwise > | Expression object for the column-wise variance function on row-major sparse matrices.This specialization of the SMatVarExpr class template represents the compile time expression for the column-wise variance function on row-major sparse matrices |
►Cblaze::DenseVector< SMatVarExpr< MT, rowwise >, false > | |
►Cblaze::Expression< DenseVector< SMatVarExpr< MT, rowwise >, false > > | |
►Cblaze::ReduceExpr< DenseVector< SMatVarExpr< MT, rowwise >, false > > | |
►Cblaze::MatReduceExpr< DenseVector< SMatVarExpr< MT, rowwise >, false >, rowwise > | |
Cblaze::SMatVarExpr< MT, rowwise > | Expression object for the row-wise variance function on row-major sparse matrices.This specialization of the SMatVarExpr class template represents the compile time expression for the row-wise variance function on row-major sparse matrices |
►Cblaze::DenseVector< StaticVector< Type, N, TF >, TF > | |
Cblaze::StaticVector< Type, N, TF > | 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: |
►Cblaze::DenseVector< SVecDVecCrossExpr< VT1, VT2, TF >, TF > | |
►Cblaze::Expression< DenseVector< SVecDVecCrossExpr< VT1, VT2, TF >, TF > > | |
►Cblaze::CrossExpr< DenseVector< SVecDVecCrossExpr< VT1, VT2, TF >, TF > > | |
Cblaze::SVecDVecCrossExpr< VT1, VT2, TF > | 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 |
►Cblaze::DenseVector< SVecDVecSubExpr< VT1, VT2, TF >, TF > | |
►Cblaze::Expression< DenseVector< SVecDVecSubExpr< VT1, VT2, TF >, TF > > | |
►Cblaze::SubExpr< DenseVector< SVecDVecSubExpr< VT1, VT2, TF >, TF > > | |
►Cblaze::VecVecSubExpr< DenseVector< SVecDVecSubExpr< VT1, VT2, TF >, TF > > | |
Cblaze::SVecDVecSubExpr< VT1, VT2, TF > | 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 |
►Cblaze::DenseVector< SVecSVecCrossExpr< VT1, VT2, TF >, TF > | |
►Cblaze::Expression< DenseVector< SVecSVecCrossExpr< VT1, VT2, TF >, TF > > | |
►Cblaze::CrossExpr< DenseVector< SVecSVecCrossExpr< VT1, VT2, TF >, TF > > | |
Cblaze::SVecSVecCrossExpr< VT1, VT2, TF > | Expression object for sparse vector-sparse vector cross products.The SVecSVecCrossExpr class represents the compile time expression for cross products between sparse vectors |
►Cblaze::DenseVector< TDMatDVecMultExpr< MT, VT >, false > | |
►Cblaze::Expression< DenseVector< TDMatDVecMultExpr< MT, VT >, false > > | |
►Cblaze::MultExpr< DenseVector< TDMatDVecMultExpr< MT, VT >, false > > | |
►Cblaze::MatVecMultExpr< DenseVector< TDMatDVecMultExpr< MT, VT >, false > > | |
Cblaze::TDMatDVecMultExpr< MT, VT > | 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 |
►Cblaze::DenseVector< TDMatSVecMultExpr< MT, VT >, false > | |
►Cblaze::Expression< DenseVector< TDMatSVecMultExpr< MT, VT >, false > > | |
►Cblaze::MultExpr< DenseVector< TDMatSVecMultExpr< MT, VT >, false > > | |
►Cblaze::MatVecMultExpr< DenseVector< TDMatSVecMultExpr< MT, VT >, false > > | |
Cblaze::TDMatSVecMultExpr< MT, VT > | 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 |
►Cblaze::DenseVector< TDVecDMatMultExpr< VT, MT >, true > | |
►Cblaze::Expression< DenseVector< TDVecDMatMultExpr< VT, MT >, true > > | |
►Cblaze::MultExpr< DenseVector< TDVecDMatMultExpr< VT, MT >, true > > | |
►Cblaze::TVecMatMultExpr< DenseVector< TDVecDMatMultExpr< VT, MT >, true > > | |
Cblaze::TDVecDMatMultExpr< VT, MT > | 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 |
►Cblaze::DenseVector< TDVecSMatMultExpr< VT, MT >, true > | |
►Cblaze::Expression< DenseVector< TDVecSMatMultExpr< VT, MT >, true > > | |
►Cblaze::MultExpr< DenseVector< TDVecSMatMultExpr< VT, MT >, true > > | |
►Cblaze::TVecMatMultExpr< DenseVector< TDVecSMatMultExpr< VT, MT >, true > > | |
Cblaze::TDVecSMatMultExpr< VT, MT > | 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 |
►Cblaze::DenseVector< TDVecTDMatMultExpr< VT, MT >, true > | |
►Cblaze::Expression< DenseVector< TDVecTDMatMultExpr< VT, MT >, true > > | |
►Cblaze::MultExpr< DenseVector< TDVecTDMatMultExpr< VT, MT >, true > > | |
►Cblaze::TVecMatMultExpr< DenseVector< TDVecTDMatMultExpr< VT, MT >, true > > | |
Cblaze::TDVecTDMatMultExpr< VT, MT > | 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 |
►Cblaze::DenseVector< TDVecTSMatMultExpr< VT, MT >, true > | |
►Cblaze::Expression< DenseVector< TDVecTSMatMultExpr< VT, MT >, true > > | |
►Cblaze::MultExpr< DenseVector< TDVecTSMatMultExpr< VT, MT >, true > > | |
►Cblaze::TVecMatMultExpr< DenseVector< TDVecTSMatMultExpr< VT, MT >, true > > | |
Cblaze::TDVecTSMatMultExpr< VT, MT > | 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 |
►Cblaze::DenseVector< TSMatDVecMultExpr< MT, VT >, false > | |
►Cblaze::Expression< DenseVector< TSMatDVecMultExpr< MT, VT >, false > > | |
►Cblaze::MultExpr< DenseVector< TSMatDVecMultExpr< MT, VT >, false > > | |
►Cblaze::MatVecMultExpr< DenseVector< TSMatDVecMultExpr< MT, VT >, false > > | |
Cblaze::TSMatDVecMultExpr< MT, VT > | 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 |
►Cblaze::DenseVector< TSVecDMatMultExpr< VT, MT >, true > | |
►Cblaze::Expression< DenseVector< TSVecDMatMultExpr< VT, MT >, true > > | |
►Cblaze::MultExpr< DenseVector< TSVecDMatMultExpr< VT, MT >, true > > | |
►Cblaze::TVecMatMultExpr< DenseVector< TSVecDMatMultExpr< VT, MT >, true > > | |
Cblaze::TSVecDMatMultExpr< VT, MT > | 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 |
►Cblaze::DenseVector< TSVecTDMatMultExpr< VT, MT >, true > | |
►Cblaze::Expression< DenseVector< TSVecTDMatMultExpr< VT, MT >, true > > | |
►Cblaze::MultExpr< DenseVector< TSVecTDMatMultExpr< VT, MT >, true > > | |
►Cblaze::TVecMatMultExpr< DenseVector< TSVecTDMatMultExpr< VT, MT >, true > > | |
Cblaze::TSVecTDMatMultExpr< VT, MT > | 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 |
►Cblaze::DenseVector< UniformVector< Type, TF >, TF > | |
►Cblaze::Expression< DenseVector< UniformVector< Type, TF >, TF > > | |
Cblaze::UniformVector< Type, TF > | Efficient implementation of a uniform vector.The UniformVector class template is the representation of an arbitrary sized uniform vector with elements of arbitrary type. The type of the elements and the transpose flag of the vector can be specified via the two template parameters: |
►Cblaze::Vector< CompressedVector< Type, TF >, TF > | |
►Cblaze::SparseVector< CompressedVector< Type, TF >, TF > | |
Cblaze::CompressedVector< Type, TF > | 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: |
►Cblaze::Vector< DVecSVecKronExpr< VT1, VT2, TF >, TF > | |
►Cblaze::SparseVector< DVecSVecKronExpr< VT1, VT2, TF >, TF > | |
►Cblaze::Expression< SparseVector< DVecSVecKronExpr< VT1, VT2, TF >, TF > > | |
►Cblaze::KronExpr< SparseVector< DVecSVecKronExpr< VT1, VT2, TF >, TF > > | |
►Cblaze::VecVecKronExpr< SparseVector< DVecSVecKronExpr< VT1, VT2, TF >, TF > > | |
Cblaze::DVecSVecKronExpr< VT1, VT2, TF > | Expression object for dense vector-sparse vector Kronecker product.The DVecSVecKronExpr class represents the compile time expression for Kronecker products between a dense vector and a sparse vector |
►Cblaze::Vector< DVecSVecMultExpr< VT1, VT2, TF >, TF > | |
►Cblaze::SparseVector< DVecSVecMultExpr< VT1, VT2, TF >, TF > | |
►Cblaze::Expression< SparseVector< DVecSVecMultExpr< VT1, VT2, TF >, TF > > | |
►Cblaze::MultExpr< SparseVector< DVecSVecMultExpr< VT1, VT2, TF >, TF > > | |
►Cblaze::VecVecMultExpr< SparseVector< DVecSVecMultExpr< VT1, VT2, TF >, TF > > | |
Cblaze::DVecSVecMultExpr< VT1, VT2, TF > | 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 |
►Cblaze::Vector< PT, TF > | |
►Cblaze::DenseVector< PT, IsRowVector_v< VT > > | |
Cblaze::DenseVectorProxy< PT, VT > | Proxy backend for dense vector types.The DenseVectorProxy class serves as a backend for the Proxy class. It is used in case the data type represented by the proxy is a dense vector and augments the Proxy interface by the complete interface required of dense vectors |
►Cblaze::SparseVector< PT, IsRowVector_v< VT > > | |
Cblaze::SparseVectorProxy< PT, VT > | Proxy backend for sparse vector types.The SparseVectorProxy class serves as a backend for the Proxy class. It is used in case the data type represented by the proxy is a sparse vector and augments the Proxy interface by the complete interface required of sparse vectors |
►Cblaze::Vector< SMatSVecMultExpr< MT, VT >, TF > | |
►Cblaze::SparseVector< SMatSVecMultExpr< MT, VT >, false > | |
►Cblaze::Expression< SparseVector< SMatSVecMultExpr< MT, VT >, false > > | |
►Cblaze::MultExpr< SparseVector< SMatSVecMultExpr< MT, VT >, false > > | |
►Cblaze::MatVecMultExpr< SparseVector< SMatSVecMultExpr< MT, VT >, false > > | |
Cblaze::SMatSVecMultExpr< MT, VT > | 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 |
►Cblaze::Vector< SVecDVecDivExpr< VT1, VT2, TF >, TF > | |
►Cblaze::SparseVector< SVecDVecDivExpr< VT1, VT2, TF >, TF > | |
►Cblaze::Expression< SparseVector< SVecDVecDivExpr< VT1, VT2, TF >, TF > > | |
►Cblaze::DivExpr< SparseVector< SVecDVecDivExpr< VT1, VT2, TF >, TF > > | |
►Cblaze::VecVecDivExpr< SparseVector< SVecDVecDivExpr< VT1, VT2, TF >, TF > > | |
Cblaze::SVecDVecDivExpr< VT1, VT2, TF > | Expression object for sparse vector-dense vector divisions.The SVecDVecDivExpr class represents the compile time expression for componentwise divisions between a sparse vector and a dense vector |
►Cblaze::Vector< SVecDVecKronExpr< VT1, VT2, TF >, TF > | |
►Cblaze::SparseVector< SVecDVecKronExpr< VT1, VT2, TF >, TF > | |
►Cblaze::Expression< SparseVector< SVecDVecKronExpr< VT1, VT2, TF >, TF > > | |
►Cblaze::KronExpr< SparseVector< SVecDVecKronExpr< VT1, VT2, TF >, TF > > | |
►Cblaze::VecVecKronExpr< SparseVector< SVecDVecKronExpr< VT1, VT2, TF >, TF > > | |
Cblaze::SVecDVecKronExpr< VT1, VT2, TF > | Expression object for sparse vector-dense vector Kronecker products.The SVecDVecKronExpr class represents the compile time expression for Kronecker products between a sparse vector and a dense vector |
►Cblaze::Vector< SVecDVecMultExpr< VT1, VT2, TF >, TF > | |
►Cblaze::SparseVector< SVecDVecMultExpr< VT1, VT2, TF >, TF > | |
►Cblaze::Expression< SparseVector< SVecDVecMultExpr< VT1, VT2, TF >, TF > > | |
►Cblaze::MultExpr< SparseVector< SVecDVecMultExpr< VT1, VT2, TF >, TF > > | |
►Cblaze::VecVecMultExpr< SparseVector< SVecDVecMultExpr< VT1, VT2, TF >, TF > > | |
Cblaze::SVecDVecMultExpr< VT1, VT2, TF > | 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 |
►Cblaze::Vector< SVecEvalExpr< VT, TF >, TF > | |
►Cblaze::SparseVector< SVecEvalExpr< VT, TF >, TF > | |
►Cblaze::Expression< SparseVector< SVecEvalExpr< VT, TF >, TF > > | |
►Cblaze::EvalExpr< SparseVector< SVecEvalExpr< VT, TF >, TF > > | |
►Cblaze::VecEvalExpr< SparseVector< SVecEvalExpr< VT, TF >, TF > > | |
Cblaze::SVecEvalExpr< VT, TF > | 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 |
►Cblaze::Vector< SVecMapExpr< VT, OP, TF >, TF > | |
►Cblaze::SparseVector< SVecMapExpr< VT, OP, TF >, TF > | |
►Cblaze::Expression< SparseVector< SVecMapExpr< VT, OP, TF >, TF > > | |
►Cblaze::UnaryMapExpr< SparseVector< SVecMapExpr< VT, OP, TF >, TF > > | |
►Cblaze::VecMapExpr< SparseVector< SVecMapExpr< VT, OP, TF >, TF > > | |
Cblaze::SVecMapExpr< VT, OP, TF > | Expression object for the sparse vector map() function.The SVecMapExpr class represents the compile time expression for the evaluation of a custom operation on each element of a sparse vector via the map() function |
►Cblaze::Vector< SVecScalarDivExpr< VT, ST, TF >, TF > | |
►Cblaze::SparseVector< SVecScalarDivExpr< VT, ST, TF >, TF > | |
►Cblaze::Expression< SparseVector< SVecScalarDivExpr< VT, ST, TF >, TF > > | |
►Cblaze::DivExpr< SparseVector< SVecScalarDivExpr< VT, ST, TF >, TF > > | |
►Cblaze::VecScalarDivExpr< SparseVector< SVecScalarDivExpr< VT, ST, TF >, TF > > | |
Cblaze::SVecScalarDivExpr< VT, ST, TF > | 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 |
►Cblaze::Vector< SVecScalarMultExpr< VT, ST, TF >, TF > | |
►Cblaze::SparseVector< SVecScalarMultExpr< VT, ST, TF >, TF > | |
►Cblaze::Expression< SparseVector< SVecScalarMultExpr< VT, ST, TF >, TF > > | |
►Cblaze::MultExpr< SparseVector< SVecScalarMultExpr< VT, ST, TF >, TF > > | |
►Cblaze::VecScalarMultExpr< SparseVector< SVecScalarMultExpr< VT, ST, TF >, TF > > | |
Cblaze::SVecScalarMultExpr< VT, ST, TF > | 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 |
►Cblaze::Vector< SVecSerialExpr< VT, TF >, TF > | |
►Cblaze::SparseVector< SVecSerialExpr< VT, TF >, TF > | |
►Cblaze::Expression< SparseVector< SVecSerialExpr< VT, TF >, TF > > | |
►Cblaze::SerialExpr< SparseVector< SVecSerialExpr< VT, TF >, TF > > | |
►Cblaze::VecSerialExpr< SparseVector< SVecSerialExpr< VT, TF >, TF > > | |
Cblaze::SVecSerialExpr< VT, TF > | 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 |
►Cblaze::Vector< SVecSVecAddExpr< VT1, VT2, TF >, TF > | |
►Cblaze::SparseVector< SVecSVecAddExpr< VT1, VT2, TF >, TF > | |
►Cblaze::Expression< SparseVector< SVecSVecAddExpr< VT1, VT2, TF >, TF > > | |
►Cblaze::AddExpr< SparseVector< SVecSVecAddExpr< VT1, VT2, TF >, TF > > | |
►Cblaze::VecVecAddExpr< SparseVector< SVecSVecAddExpr< VT1, VT2, TF >, TF > > | |
Cblaze::SVecSVecAddExpr< VT1, VT2, TF > | Expression object for sparse vector-sparse vector additions.The SVecSVecAddExpr class represents the compile time expression for additions between sparse vectors |
►Cblaze::Vector< SVecSVecKronExpr< VT1, VT2, TF >, TF > | |
►Cblaze::SparseVector< SVecSVecKronExpr< VT1, VT2, TF >, TF > | |
►Cblaze::Expression< SparseVector< SVecSVecKronExpr< VT1, VT2, TF >, TF > > | |
►Cblaze::KronExpr< SparseVector< SVecSVecKronExpr< VT1, VT2, TF >, TF > > | |
►Cblaze::VecVecKronExpr< SparseVector< SVecSVecKronExpr< VT1, VT2, TF >, TF > > | |
Cblaze::SVecSVecKronExpr< VT1, VT2, TF > | Expression object for sparse vector-sparse vector Kronecker products.The SVecSVecKronExpr class represents the compile time expression for Kronecker products between sparse vectors |
►Cblaze::Vector< SVecSVecMultExpr< VT1, VT2, TF >, TF > | |
►Cblaze::SparseVector< SVecSVecMultExpr< VT1, VT2, TF >, TF > | |
►Cblaze::Expression< SparseVector< SVecSVecMultExpr< VT1, VT2, TF >, TF > > | |
►Cblaze::MultExpr< SparseVector< SVecSVecMultExpr< VT1, VT2, TF >, TF > > | |
►Cblaze::VecVecMultExpr< SparseVector< SVecSVecMultExpr< VT1, VT2, TF >, TF > > | |
Cblaze::SVecSVecMultExpr< VT1, VT2, TF > | Expression object for sparse vector-sparse vector multiplications.The SVecSVecMultExpr class represents the compile time expression for componentwise multiplications between sparse vectors |
►Cblaze::Vector< SVecSVecSubExpr< VT1, VT2, TF >, TF > | |
►Cblaze::SparseVector< SVecSVecSubExpr< VT1, VT2, TF >, TF > | |
►Cblaze::Expression< SparseVector< SVecSVecSubExpr< VT1, VT2, TF >, TF > > | |
►Cblaze::SubExpr< SparseVector< SVecSVecSubExpr< VT1, VT2, TF >, TF > > | |
►Cblaze::VecVecSubExpr< SparseVector< SVecSVecSubExpr< VT1, VT2, TF >, TF > > | |
Cblaze::SVecSVecSubExpr< VT1, VT2, TF > | Expression object for sparse vector-sparse vector subtractions.The SVecSVecSubExpr class represents the compile time expression for subtractions between sparse vectors |
►Cblaze::Vector< SVecTransExpr< VT, TF >, TF > | |
►Cblaze::SparseVector< SVecTransExpr< VT, TF >, TF > | |
►Cblaze::Expression< SparseVector< SVecTransExpr< VT, TF >, TF > > | |
►Cblaze::TransExpr< SparseVector< SVecTransExpr< VT, TF >, TF > > | |
►Cblaze::VecTransExpr< SparseVector< SVecTransExpr< VT, TF >, TF > > | |
Cblaze::SVecTransExpr< VT, TF > | Expression object for sparse vector transpositions.The SVecTransExpr class represents the compile time expression for transpositions of sparse vectors |
►Cblaze::Vector< SVecTransposer< VT, TF >, TF > | |
►Cblaze::SparseVector< SVecTransposer< VT, TF >, TF > | |
Cblaze::SVecTransposer< VT, TF > | Expression object for the transposition of a sparse vector.The SVecTransposer class is a wrapper object for the temporary transposition of a sparse vector |
►Cblaze::Vector< TSMatSVecMultExpr< MT, VT >, TF > | |
►Cblaze::SparseVector< TSMatSVecMultExpr< MT, VT >, false > | |
►Cblaze::Expression< SparseVector< TSMatSVecMultExpr< MT, VT >, false > > | |
►Cblaze::MultExpr< SparseVector< TSMatSVecMultExpr< MT, VT >, false > > | |
►Cblaze::MatVecMultExpr< SparseVector< TSMatSVecMultExpr< MT, VT >, false > > | |
Cblaze::TSMatSVecMultExpr< MT, VT > | 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 |
►Cblaze::Vector< TSVecSMatMultExpr< VT, MT >, TF > | |
►Cblaze::SparseVector< TSVecSMatMultExpr< VT, MT >, true > | |
►Cblaze::Expression< SparseVector< TSVecSMatMultExpr< VT, MT >, true > > | |
►Cblaze::MultExpr< SparseVector< TSVecSMatMultExpr< VT, MT >, true > > | |
►Cblaze::TVecMatMultExpr< SparseVector< TSVecSMatMultExpr< VT, MT >, true > > | |
Cblaze::TSVecSMatMultExpr< VT, MT > | 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 |
►Cblaze::Vector< TSVecTSMatMultExpr< VT, MT >, TF > | |
►Cblaze::SparseVector< TSVecTSMatMultExpr< VT, MT >, true > | |
►Cblaze::Expression< SparseVector< TSVecTSMatMultExpr< VT, MT >, true > > | |
►Cblaze::MultExpr< SparseVector< TSVecTSMatMultExpr< VT, MT >, true > > | |
►Cblaze::TVecMatMultExpr< SparseVector< TSVecTSMatMultExpr< VT, MT >, true > > | |
Cblaze::TSVecTSMatMultExpr< VT, MT > | 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 |
►Cblaze::Vector< ZeroVector< Type, TF >, TF > | |
►Cblaze::SparseVector< ZeroVector< Type, TF >, TF > | |
►Cblaze::Expression< SparseVector< ZeroVector< Type, TF >, TF > > | |
Cblaze::ZeroVector< Type, TF > | Efficient implementation of an arbitrary sized zero vector.The ZeroVector class template is the representation of an immutable, arbitrary sized zero vector with N elements of arbitrary type. The type of the elements and the transpose flag of the vector can be specified via the two template parameters: |
Cblaze::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: |
►CVT | |
►Cblaze::Expression< VT > | |
►Cblaze::AddExpr< VT > | |
Cblaze::VecVecAddExpr< VT > | Base class for all vector/vector addition expression templates.The VecVecAddExpr class serves as a tag for all expression templates that implement a vector/vector addition. All classes, that represent a vector addition and that are used within the expression template environment of the Blaze library have to derive publicly from this class in order to qualify as vector addition expression template. Only in case a class is derived publicly from the VecVecAddExpr base class, the IsVecVecAddExpr type trait recognizes the class as valid vector addition expression template |
►Cblaze::BinaryMapExpr< VT > | |
Cblaze::VecVecMapExpr< VT > | Base class for all binary vector map expression templates.The VecVecMapExpr class serves as a tag for all expression templates that implement a binary vector map operation. All classes, that represent a binary vector map operation and that are used within the expression template environment of the Blaze library have to derive publicly from this class in order to qualify as binary vector map expression template. Only in case a class is derived publicly from the VecVecMapExpr base class, the IsVecVecMapExpr type trait recognizes the class as valid binary vector map expression template |
Cblaze::CrossExpr< VT > | Base class for all cross product expression templates.The CrossExpr class serves as a tag for all expression templates that implement mathematical cross products. All classes, that represent a mathematical cross product and that are used within the expression template environment of the Blaze library have to derive publicly from this class in order to qualify as cross product expression template. Only in case a class is derived publicly from the CrossExpr base class, the IsCrossExpr type trait recognizes the class as valid cross product expression template |
►Cblaze::DivExpr< VT > | |
Cblaze::VecScalarDivExpr< VT > | Base class for all vector/scalar division expression templates.The VecScalarDivExpr class serves as a tag for all expression templates that implement a vector/scalar division. All classes, that represent a vector/scalar division and that are used within the expression template environment of the Blaze library have to derive publicly from this class in order to qualify as vector/scalar division expression template. Only in case a class is derived publicly from the VecScalarDivExpr base class, the IsVecScalarDivExpr type trait recognizes the class as valid vector/scalar division expression template |
Cblaze::VecVecDivExpr< VT > | Base class for all vector/vector division expression templates.The VecVecDivExpr class serves as a tag for all expression templates that implement a vector/vector division. All classes, that represent a vector division and that are used within the expression template environment of the Blaze library have to derive publicly from this class in order to qualify as vector division expression template. Only in case a class is derived publicly from the VecVecDivExpr base class, the IsVecVecDivExpr type trait recognizes the class as valid vector division expression template |
►Cblaze::EvalExpr< VT > | |
Cblaze::VecEvalExpr< VT > | Base class for all vector evaluation expression templates.The VecEvalExpr class serves as a tag for all expression templates that implement a vector evaluation operation. All classes, that represent a vector evaluation operation and that are used within the expression template environment of the Blaze library have to derive publicly from this class in order to qualify as vector evaluation expression template. Only in case a class is derived publicly from the VecEvalExpr base class, the IsVecEvalExpr type trait recognizes the class as valid vector evaluation expression template |
►Cblaze::KronExpr< VT > | |
Cblaze::VecVecKronExpr< VT > | Base class for all vector/vector Kronecker expression templates.The VecVecKronExpr class serves as a tag for all expression templates that implement a vector/vector Kronecker product. All classes, that represent a vector Kronecker product and that are used within the expression template environment of the Blaze library have to derive publicly from this class in order to qualify as vector Kronecker product expression template. Only in case a class is derived publicly from the VecVecKronExpr base class, the IsVecVecKronExpr type trait recognizes the class as valid vector Kronecker product expression template |
►Cblaze::MultExpr< VT > | |
Cblaze::MatVecMultExpr< VT > | Base class for all matrix/vector multiplication expression templates.The MatVecMultExpr class serves as a tag for all expression templates that implement a matrix/vector multiplication. All classes, that represent a matrix/vector multiplication and that are used within the expression template environment of the Blaze library have to derive publicly from this class in order to qualify as matrix/vector multiplication expression template. Only in case a class is derived publicly from the MatVecMultExpr base class, the IsMatVecMultExpr type trait recognizes the class as valid matrix/vector multiplication expression template |
Cblaze::TVecMatMultExpr< VT > | Base class for all vector/matrix multiplication expression templates.The TVecMatMultExpr class serves as a tag for all expression templates that implement a vector/matrix multiplication. All classes, that represent a vector/matrix multiplication and that are used within the expression template environment of the Blaze library have to derive publicly from this class in order to qualify as vector/matrix multiplication expression template. Only in case a class is derived publicly from the TVecMatMultExpr base class, the IsTVecMatMultExpr type trait recognizes the class as valid vector/matrix multiplication expression template |
Cblaze::VecScalarMultExpr< VT > | Base class for all vector/scalar multiplication expression templates.The VecScalarMultExpr class serves as a tag for all expression templates that implement a vector/scalar multiplication. All classes, that represent a vector/scalar multiplication and that are used within the expression template environment of the Blaze library have to derive publicly from this class in order to qualify as vector/scalar multiplication expression template. Only in case a class is derived publicly from the VecScalarMultExpr base class, the IsVecScalarMultExpr type trait recognizes the class as valid vector/scalar multiplication expression template |
Cblaze::VecVecMultExpr< VT > | Base class for all vector/vector multiplication expression templates.The VecVecMultExpr class serves as a tag for all expression templates that implement a vector/vector multiplication. All classes, that represent a vector multiplication and that are used within the expression template environment of the Blaze library have to derive publicly from this class in order to qualify as vector multiplication expression template. Only in case a class is derived publicly from the VecVecMultExpr base class, the IsVecVecMultExpr type trait recognizes the class as valid vector multiplication expression template |
►Cblaze::ReduceExpr< VT > | |
Cblaze::MatReduceExpr< VT, RF > | Base class for all matrix reduction expression templates.The MatReduceExpr class serves as a tag for all expression templates that implement a matrix reduction. All classes, that represent a matrix reduction and and that are used within the expression template environment of the Blaze library have to derive publicly from this class in order to qualify as matrix reduction expression template. Only in case a class is derived publicly from the MatReduceExpr base class, the IsMatReduceExpr type trait recognizes the class as valid matrix reduction expression template |
►Cblaze::SerialExpr< VT > | |
Cblaze::VecSerialExpr< VT > | Base class for all vector serial evaluation expression templates.The VecSerialExpr class serves as a tag for all expression templates that enforce a serial evaluation of a vector. All classes, that represent a vector serialization operation and that are used within the expression template environment of the Blaze library have to derive publicly from this class in order to qualify as vector serial evaluation expression template. Only in case a class is derived publicly from the VecSerialExpr base class, the IsVecSerialExpr type trait recognizes the class as valid vector serial evaluation expression template |
►Cblaze::SubExpr< VT > | |
Cblaze::VecVecSubExpr< VT > | Base class for all vector/vector subtraction expression templates.The VecVecSubExpr class serves as a tag for all expression templates that implement a vector/vector subtraction. All classes, that represent a vector subtraction and that are used within the expression template environment of the Blaze library have to derive publicly from this class in order to qualify as vector subtraction expression template. Only in case a class is derived publicly from the VecVecSubExpr base class, the IsVecVecSubExpr type trait recognizes the class as valid vector subtraction expression template |
►Cblaze::TransExpr< VT > | |
Cblaze::VecTransExpr< VT > | Base class for all vector transposition expression templates.The VecTransExpr class serves as a tag for all expression templates that implement a vector transposition operation. All classes, that represent a vector transposition operation and that are used within the expression template environment of the Blaze library have to derive publicly from this class in order to qualify as vector transposition expression template. Only in case a class is derived publicly from the VecTransExpr base class, the IsVecTransExpr type trait recognizes the class as valid vector transposition expression template |
►Cblaze::UnaryMapExpr< VT > | |
Cblaze::VecMapExpr< VT > | Base class for all unary vector map expression templates.The VecMapExpr class serves as a tag for all expression templates that represent a unary map operation on a vector. All classes, that represent a unary vector map operation and that are used within the expression template environment of the Blaze library have to derive publicly from this class in order to qualify as unary vector map expression template. Only in case a class is derived publicly from the VecMapExpr base class, the IsVecMapExpr type trait recognizes the class as valid unary vector map expression template |
Cblaze::timing::WcPolicy | Timing policy for the measurement of the wall clock time.The WcPolicy class represents the timing policy for wall clock time measurements that can be used in combination with the Timer class template. This combination is realized with the WcTimer type definition |
Cblaze::XorAssign | Generic wrapper for bitwise XOR assignment |
►CT | |
►Cblaze::Expression< T > | Base class for all expression templates.The Expression class is the base class for all expression templates. All classes that represent an expression and that are used within the expression template environment of the Blaze library have to derive publicly from this class in order to qualify as expression template. Only in case a class is derived publicly from the Expression base class, the IsExpression type trait recognizes the class as valid expression template |
Cblaze::AddExpr< T > | Base class for all addition expression templates.The AddExpr class serves as a tag for all expression templates that implement mathematical additions. All classes, that represent a mathematical addition (vector additions and matrix additions) and that are used within the expression template environment of the Blaze library have to derive publicly from this class in order to qualify as addition expression template. Only in case a class is derived publicly from the AddExpr base class, the IsAddExpr type trait recognizes the class as valid addition expression template |
Cblaze::BinaryMapExpr< T > | Base class for all for-each expression templates.The BinaryMapExpr class serves as a tag for all expression templates that represent a binary map operation. All classes, that represent a binary map operation and that are used within the expression template environment of the Blaze library have to derive publicly from this class in order to qualify as binary map expression template. Only in case a class is derived publicly from the BinaryMapExpr base class, the IsBinaryMapExpr type trait recognizes the class as valid binary map expression template |
Cblaze::DeclExpr< T > | Base class for all matrix for-each expression templates.The DeclExpr class serves as a tag for all expression templates that represent an explicit declaration operation. All classes, that represent a declaration operation and that are used within the expression template environment of the Blaze library have to derive publicly from this class in order to qualify as declaration expression template. Only in case a class is derived publicly from the DeclExpr base class, the IsDeclExpr type trait recognizes the class as valid declaration expression template |
Cblaze::DivExpr< T > | Base class for all division expression templates.The DivExpr class serves as a tag for all expression templates that implement mathematical divisions. All classes, that represent a mathematical division (vector/vector divisions, vector/scalar divisions and matrix/scalar divisions) and that are used within the expression template environment of the Blaze library have to derive publicly from this class in order to qualify as division expression template. Only in case a class is derived publicly from the DivExpr base class, the IsDivExpr type trait recognizes the class as valid division expression template |
Cblaze::EvalExpr< T > | Base class for all evaluation expression templates.The EvalExpr class serves as a tag for all expression templates that implement an evaluation operation. All classes, that represent an evaluation operation and that are used within the expression template environment of the Blaze library have to derive publicly from this class in order to qualify as evaluation expression template. Only in case a class is derived publicly from the EvalExpr base class, the IsEvalExpr type trait recognizes the class as valid evaluation expression template |
Cblaze::ExpandExpr< T > | Base class for all expansion expression templates.The ExpandExpr class serves as a tag for all expression templates that implement expansion operations. All classes, that represent an expansion operation (e.g. vector expansions) and that are used within the expression template environment of the Blaze library have to derive publicly from this class in order to qualify as expansion expression template. Only in case a class is derived publicly from the ExpandExpr base class, the IsExpandExpr type trait recognizes the class as valid expansion expression template |
Cblaze::MultExpr< T > | Base class for all multiplication expression templates.The MultExpr class serves as a tag for all expression templates that implement mathematical multiplications. All classes, that represent a mathematical multiplication (element-wise vector multiplications, matrix/vector multiplications, vector/matrix multiplications and matrix/matrix multiplications) and that are used within the expression template environment of the Blaze library have to derive publicly from this class in order to qualify as multiplication expression template. Only in case a class is derived publicly from the MultExpr base class, the IsMultExpr type trait recognizes the class as valid multiplication expression template |
Cblaze::ReduceExpr< T > | Base class for all reduction expression templates.The ReduceExpr class serves as a tag for all expression templates that implement reduction operations. All classes, that represent a reduction operation (e.g. row-wise or column-wise matrix reductions) and that are used within the expression template environment of the Blaze library have to derive publicly from this class in order to qualify as reduction expression template. Only in case a class is derived publicly from the ReduceExpr base class, the IsReduceExpr type trait recognizes the class as valid reduction expression template |
Cblaze::SerialExpr< T > | Base class for all serial evaluation expression templates.The SerialExpr class serves as a tag for all expression templates that enforce a serial evaluation. All classes, that represent a serialization operation and that are used within the expression template environment of the Blaze library have to derive publicly from this class in order to qualify as serial evaluation expression template. Only in case a class is derived publicly from the SerialExpr base class, the IsSerialExpr type trait recognizes the class as valid serial evaluation expression template |
Cblaze::SubExpr< T > | Base class for all subtraction expression templates.The SubExpr class serves as a tag for all expression templates that implement mathematical subtractions. All classes, that represent a mathematical subtraction (vector subtractions and matrix subtractions) and that are used within the expression template environment of the Blaze library have to derive publicly from this class in order to qualify as subtraction expression template. Only in case a class is derived publicly from the SubExpr base class, the IsSubExpr type trait recognizes the class as valid subtraction expression template |
Cblaze::TransExpr< T > | Base class for all transposition expression templates.The TransExpr class serves as a tag for all expression templates that implement mathematical transpositions. All classes, that represent a mathematical transposition (vector transpositions and matrix transpositions) and that are used within the expression template environment of the Blaze library have to derive publicly from this class in order to qualify as transposition expression template. Only in case a class is derived publicly from the TransExpr base class, the IsTransExpr type trait recognizes the class as valid transposition expression template |
Cblaze::UnaryMapExpr< T > | Base class for all for-each expression templates.The UnaryMapExpr class serves as a tag for all expression templates that represent a unary map operation. All classes, that represent a unary map operation and that are used within the expression template environment of the Blaze library have to derive publicly from this class in order to qualify as unary map expression template. Only in case a class is derived publicly from the UnaryMapExpr base class, the IsUnaryMapExpr type trait recognizes the class as valid unary map expression template |
Cblaze::View< T > | Base class for all views.The View class serves as a tag for all views (subvectors, submatrices, rows, columns, ...). All classes that represent a view and that are used within the expression template environment of the Blaze library have to derive publicly from this class in order to qualify as a view. Only in case a class is derived publicly from the View base class, the IsView type trait recognizes the class as valid view |