Class Hierarchy
This inheritance list is sorted roughly, but not completely, alphabetically:
[detail level 123456]
 Cblaze::AbsGeneric wrapper for the abs() function
 Cblaze::AccuracyComputation 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::AcosGeneric wrapper for the acos() function
 Cblaze::AcoshGeneric wrapper for the acosh() function
 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::AddExprTrait< T1, T2 >Evaluation of the return type of an addition expression.Via this type trait it is possible to evaluate the return type of an addition expression between scalars, vectors, and matrices. Given the two types T1 and T2, which must either be scalar, vector, or matrix types, the nested type Type corresponds to the resulting return type. In case the types of T1 or T2 don't fit or if the two types cannot be added, the resulting data type Type is set to INVALID_TYPE
 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 >
 Cblaze::AlignedArray< Type, NN >
 Cblaze::Append< TList, Type >Appending a type to a type list.The Append class can be used to append the data type Type to a type list TList. In order to append a data type, the Append class has to be instantiated for a particular type list and another type. The following example gives an impression of the use of the Append class:
 Cblaze::ArrayDeleteArray-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::AsinGeneric wrapper for the asin() function
 Cblaze::AsinhGeneric wrapper for the asinh() function
 Cblaze::AtanGeneric wrapper for the atan() function
 Cblaze::AtanhGeneric wrapper for the atanh() function
 Cblaze::BinaryMapExprTrait< T1, T2, OP >Evaluation of the return type of a binary map expression.Via this type trait it is possible to evaluate the return type of a binary map expression. Given the two types T1 and T2, which must either be vector or matrix types, and the custom operation type OP, the nested type Type corresponds to the resulting return type. In case the types of T1 or T2 don't fit or if no binary map operation exists for the types, the resulting data type Type is set to INVALID_TYPE
 Cblaze::BinaryMapTrait< T1, T2, OP >Base template for the BinaryMapTrait class
 Cblaze::MemoryPool< Type, Blocksize >::BlockMemory 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::CbrtGeneric wrapper for the cbrt() function
 Cblaze::CeilGeneric wrapper for the ceil() function
 Cblaze::Clamp< DT >Generic wrapper for the clamp() function
 Cblaze::Column< MT, SO, DF, SF >Reference to a specific column of a dense or sparse matrix.The Column template represents a reference to a specific column of a dense or sparse matrix primitive. The type of the matrix is specified via the first template parameter:
 Cblaze::ColumnExprTrait< MT >Evaluation of the expression type type of a column operation.Via this type trait it is possible to evaluate the return type of a column operation. Given the dense or sparse matrix type MT, the nested type Type corresponds to the resulting return type. In case the given type is neither a dense nor a sparse matrix type, the resulting data type Type is set to INVALID_TYPE
 Cblaze::ColumnTrait< MT >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::complexComplex 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::ConjGeneric wrapper for the conj() function
 Cblaze::DVecDVecMapExpr< VT1, VT2, OP, TF >::ConstIteratorIterator over the elements of the dense vector map expression
 Cblaze::DVecDVecMultExpr< VT1, VT2, TF >::ConstIteratorIterator over the elements of the dense vector
 Cblaze::DVecDVecOuterExpr< VT1, VT2 >::ConstIteratorIterator over the elements of the dense matrix
 Cblaze::DVecDVecSubExpr< VT1, VT2, TF >::ConstIteratorIterator over the elements of the dense vector
 Cblaze::DVecMapExpr< VT, OP, TF >::ConstIteratorIterator over the elements of the dense vector map expression
 Cblaze::DVecScalarDivExpr< VT, ST, TF >::ConstIteratorIterator over the elements of the dense vector
 Cblaze::DVecScalarMultExpr< VT, ST, TF >::ConstIteratorIterator over the elements of the dense vector
 Cblaze::DVecSVecMultExpr< VT1, VT2, TF >::ConstIteratorIterator over the elements of the dense vector-sparse vector multiplication expression
 Cblaze::DVecSVecOuterExpr< VT1, VT2 >::ConstIteratorIterator over the elements of the dense vector-sparse vector outer product expression
 Cblaze::SMatDMatSchurExpr< MT1, MT2 >::ConstIteratorIterator over the elements of the sparse matrix/dense matrix Schur product expression
 Cblaze::SMatScalarDivExpr< MT, ST, SO >::ConstIteratorIterator over the elements of the sparse matrix/scalar division expression
 Cblaze::SMatMapExpr< MT, OP, SO >::ConstIteratorIterator over the elements of the sparse matrix map expression
 Cblaze::SMatScalarMultExpr< MT, ST, SO >::ConstIteratorIterator over the elements of the sparse matrix/scalar multiplication expression
 Cblaze::SVecDVecMultExpr< VT1, VT2, TF >::ConstIteratorIterator over the elements of the sparse vector-dense vector multiplication expression
 Cblaze::SVecDVecDivExpr< VT1, VT2, TF >::ConstIteratorIterator over the elements of the sparse vector-dense vector division expression
 Cblaze::SVecDVecOuterExpr< VT1, VT2 >::ConstIteratorIterator over the elements of the sparse vector-dense vector outer product expression
 Cblaze::SVecMapExpr< VT, OP, TF >::ConstIteratorIterator over the elements of the sparse vector map expression
 Cblaze::SVecScalarDivExpr< VT, ST, TF >::ConstIteratorIterator over the elements of the sparse vector/scalar multiplication expression
 Cblaze::SVecScalarMultExpr< VT, ST, TF >::ConstIteratorIterator over the elements of the sparse vector/scalar multiplication expression
 Cblaze::TSMatDMatSchurExpr< MT1, MT2 >::ConstIteratorIterator over the elements of the sparse matrix/dense matrix Schur product expression
 Cblaze::DMatDMatAddExpr< MT1, MT2, SO >::ConstIteratorIterator over the elements of the dense matrix
 Cblaze::DMatDMatMapExpr< MT1, MT2, OP, SO >::ConstIteratorIterator over the elements of the dense matrix map expression
 Cblaze::DMatDMatSchurExpr< MT1, MT2, SO >::ConstIteratorIterator over the elements of the dense matrix
 Cblaze::DMatDMatSubExpr< MT1, MT2, SO >::ConstIteratorIterator over the elements of the dense matrix
 Cblaze::DMatMapExpr< MT, OP, SO >::ConstIteratorIterator over the elements of the dense matrix map expression
 Cblaze::DMatScalarDivExpr< MT, ST, SO >::ConstIteratorIterator over the elements of the dense matrix
 Cblaze::DMatScalarMultExpr< MT, ST, SO >::ConstIteratorIterator over the elements of the dense matrix
 Cblaze::DMatSMatSchurExpr< MT1, MT2 >::ConstIteratorIterator over the elements of the dense matrix/sparse matrix Schur product expression
 Cblaze::IdentityMatrix< Type, SO >::ConstIteratorIterator over the elements of the identity matrix
 Cblaze::DMatTSMatSchurExpr< MT1, MT2 >::ConstIteratorIterator over the elements of the dense matrix/sparse matrix Schur product expression
 Cblaze::DVecDVecAddExpr< VT1, VT2, TF >::ConstIteratorIterator over the elements of the dense vector
 Cblaze::DVecDVecDivExpr< VT1, VT2, TF >::ConstIteratorIterator over the elements of the dense vector
 Cblaze::Contains< TList, Type >Searching a type list.The Contains class can be used to search the type list for a particular type Type. In contrast to the IndexOf class, the Contains class does not evaluate the index of the type but only checks whether or not the type is contained in the type list. Additionally, in contrast to the ContainsRelated class, the Contains class strictly searches for the given type Type and not for a related data type. In case the type is contained in the type list, the value member enumeration is set to 1, else it is set to 0. In order to check whether a type is part of a type list, the Contains class has to be instantiated for a particular type list and another type. The following example gives an impression of the use of the Contains class:
 Cblaze::ContainsRelated< TList, Type >Searching a type list.The ContainsRelated class can be used to search the type list for a type related to Type. In contrast to the Contains class, the ContainsRelated class only searches for a type the given data type Type can be converted to. In case a related type is found in the type list, the value member enumeration is set to 1, else it is set to 0. In order to check whether a related type is contained in the type list, the ContainsRelated class has to be instantiated for a particular type list and another type. The following example gives an impression of the use of the ContainsRelated class:
 Cblaze::CosGeneric wrapper for the cos() function
 Cblaze::CoshGeneric wrapper for the cosh() function
 Cblaze::timing::CpuPolicyTiming 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::CrossExprTrait< T1, T2 >Evaluation of the return type of a cross product expression.Via this type trait it is possible to evaluate the return type of a cross product expression. Given the two types T1 and T2, which must be dense or sparse column vectors, the nested type Type corresponds to the resulting return type. In case the types of T1 or T2 don't fit or if the two types cannot be used in a cross product, the resulting data type Type is set to INVALID_TYPE
 Cblaze::CrossTrait< T1, T2 >Base template for the CrossTrait class
 Cblaze::CTransGeneric wrapper for the ctrans() function
 Cblaze::CTransExprTrait< T >Evaluation of the return type of a conjugate transpose expression.Via this type trait it is possible to evaluate the return type of a conjugate transpose expression. Given the type T, which must either be a vector or matrix type, the nested type Type corresponds to the resulting return type. In case the type of T doesn't fit or if no conjugate transpose operation exists for the type, the resulting data type Type is set to INVALID_TYPE
 Cblaze::DeallocateDeallocate 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::DeclDiagGeneric wrapper for the decldiag() function
 Cblaze::DeclDiagExprTrait< T >Evaluation of the return type of a diagonal declaration (decldiag) expression.Via this type trait it is possible to evaluate the return type of a diagonal declaration (decldiag) expression. Given the type T, which must be a matrix type, the nested type Type corresponds to the resulting return type. In case the type of T doesn't fit or if no decldiag operation exists for the type, the resulting data type Type is set to INVALID_TYPE
 Cblaze::DeclDiagTrait< MT >Base template for the DeclDiagTrait class
 Cblaze::DeclHermGeneric wrapper for the declherm() function
 Cblaze::DeclHermExprTrait< T >Evaluation of the return type of an Hermitian declaration (declherm) expression.Via this type trait it is possible to evaluate the return type of an Hermitian declaration (declherm) expression. Given the type T, which must be a matrix type, the nested type Type corresponds to the resulting return type. In case the type of T doesn't fit or if no declherm operation exists for the type, the resulting data type Type is set to INVALID_TYPE
 Cblaze::DeclHermTrait< MT >Base template for the DeclHermTrait class
 Cblaze::DeclIdGeneric wrapper for the declid() function
 Cblaze::DeclIdExprTrait< T >Evaluation of the return type of an identity declaration (declid) expression.Via this type trait it is possible to evaluate the return type of an identity declaration (declid) expression. Given the type T, which must be a matrix type, the nested type Type corresponds to the resulting return type. In case the type of T doesn't fit or if no declid operation exists for the type, the resulting data type Type is set to INVALID_TYPE
 Cblaze::DeclIdTrait< MT >Base template for the DeclIdTrait class
 Cblaze::DeclLowGeneric wrapper for the decllow() function
 Cblaze::DeclLowExprTrait< T >Evaluation of the return type of a lower declaration (decllow) expression.Via this type trait it is possible to evaluate the return type of a lower declaration (decllow) expression. Given the type T, which must be a matrix type, the nested type Type corresponds to the resulting return type. In case the type of T doesn't fit or if no decllow operation exists for the type, the resulting data type Type is set to INVALID_TYPE
 Cblaze::DeclLowTrait< MT >Base template for the DeclLowTrait class
 Cblaze::DeclSymGeneric wrapper for the declsym() function
 Cblaze::DeclSymExprTrait< T >Evaluation of the return type of a symmetry declaration (declsym) expression.Via this type trait it is possible to evaluate the return type of a symmetry declaration (declsym) expression. Given the type T, which must be a matrix type, the nested type Type corresponds to the resulting return type. In case the type of T doesn't fit or if no declsym operation exists for the type, the resulting data type Type is set to INVALID_TYPE
 Cblaze::DeclSymTrait< MT >Base template for the DeclSymTrait class
 Cblaze::DeclUppGeneric wrapper for the declupp() function
 Cblaze::DeclUppExprTrait< T >Evaluation of the return type of a upper declaration (declupp) expression.Via this type trait it is possible to evaluate the return type of a upper declaration (declupp) expression. Given the type T, which must be a matrix type, the nested type Type corresponds to the resulting return type. In case the type of T doesn't fit or if no declupp operation exists for the type, the resulting data type Type is set to INVALID_TYPE
 Cblaze::DeclUppTrait< MT >Base template for the DeclUppTrait 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 $ N \times N $ matrices
 Cblaze::DisableIfTrue< Condition, T >Substitution Failure Is Not An Error (SFINAE) class.The DisableIfTrue class template is an auxiliary tool for an intentional application of the Substitution Failure Is Not An Error (SFINAE) principle. It allows a function template or a class template specialization to include or exclude itself from a set of matching functions or specializations based on properties of its template arguments. For instance, it can be used to restrict the selection of a function template to specific data types. The following example illustrates this in more detail
 Cblaze::DisableIfTrue< Condition::value, T >
 Cblaze::DivExprTrait< T1, T2 >Evaluation of the resulting expression type of a division.Via this type trait it is possible to evaluate the return type of a division expression between scalars, vectors, and matrices. Given the two types T1 and T2, where T1 must either be a scalar, vector, or matrix type and T2 which must be a scalar type, the nested type Type corresponds to the resulting return type. In case T1 or T2 don't fit or if the two types cannot be divided, the resulting data type Type is set to INVALID_TYPE
 Cblaze::DivTrait< T1, T2, typename >Base template for the DivTrait class
 Cblaze::EmptyTypeEmpty data type for utility purposes
 Cblaze::EnableIfTrue< Condition, T >Substitution Failure Is Not An Error (SFINAE) class.The EnableIfTrue class template is an auxiliary tool for an intentional application of the Substitution Failure Is Not An Error (SFINAE) principle. It allows a function template or a class template specialization to include or exclude itself from a set of matching functions or specializations based on properties of its template arguments. For instance, it can be used to restrict the selection of a function template to specific data types. The following example illustrates this in more detail
 Cblaze::EnableIfTrue< Condition::value, T >
 Cblaze::EpsilonNumerical 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< TList, Type >Erasing the first occurrence of a type from a type list.The Erase class can be used to erase the first occurrence of data type Type from a type list TList. In order to erase the first occurrence of a data type, the Erase class has to be instantiated for a particular type list and another type. The following example gives an impression of the use of the Erase class:
 Cblaze::EraseAll< TList, Type >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::ErfGeneric wrapper for the erf() function
 Cblaze::ErfcGeneric wrapper for the erfc() function
 Cblaze::EvalGeneric wrapper for the eval() function
 Cblaze::EvalExprTrait< T >Evaluation of the return type of an evaluation expression.Via this type trait it is possible to evaluate the return type of an evaluation expression. Given the type T, which must either be a vector or matrix type, the nested type Type corresponds to the resulting return type. In case the type of T doesn't fit or if no evaluation operation exists for the type, the resulting data type Type is set to INVALID_TYPE
 Cblaze::ExpGeneric wrapper for the exp() function
 Cblaze::Exp10Generic wrapper for the exp10() function
 Cblaze::Exp2Generic wrapper for the exp2() function
 Cblaze::FloorGeneric wrapper for the floor() function
 Cblaze::MemoryPool< Type, Blocksize >::FreeObjectA single element of the free list of the memory pool
 Cblaze::FunctionTraceRAII 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
 CHasAddHelper
 Cblaze::HasCyclicDependency< T, TL, C >
 CHasDivHelper
 CHasMaxHelper
 CHasMinHelper
 CHasMultHelper
 CHasSubHelper
 Cblaze::HermitianMatrix< MT, SO, DF >Matrix adapter for Hermitian $ N \times N $ matrices
 Cblaze::HighType< T1, T2 >Base template for the HighType type trait
 CIf_
 Cblaze::IfTrue< Condition, T1, T2 >Compile time type selection.The IfTrue class template selects one of the two given types T1 and T2 depending on the Condition template argument. In case the Condition compile time constant expression evaluates to true, the member type definition Type is set to T1. In case Condition evaluates to false, Type is set to T2
 Cblaze::IfTrue< T1::value, T2, T3 >
 Cblaze::ImagGeneric wrapper for the imag() function
 Cblaze::ImagTrait< T >Base template for the ImagTrait class.The ImagTrait class template offers the possibility to select the resulting data type of a generic imag operation on the given type T. Given the type T, which must either be a scalar, vector, or matrix type, the nested type Type corresponds to the resulting data type of the operation. In case the type of T doesn't fit or if no imag operation exists for the type, the resulting data type Type is set to INVALID_TYPE. Note that const and volatile qualifiers and reference modifiers are generally ignored
 Cblaze::IndexOf< TList, Type >Searching a type list.The IndexOf class can be used to search the type list for a particular type Type. In contrast to the Contains and the ContainsRelated classes, the IndexOf class evaluates the index of the given type in the type list. In case the type is contained in the type list, the value member represents the index of the queried type. Otherwise the value member is set to -1. In order to search for a type, the IndexOf class has to be instantiated for a particular type list and a search type. The following example gives an impression of the use of the IndexOf class:
 Cblaze::IndicesAuxiliary class for the generation of random indices
 Cblaze::InfinityPositive 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_listInitializer list type of the Blaze library
 Cblaze::InputStringImplementation of a string wrapper.The InputString class is a wrapper class for the purpose to read input strings delimited by quotations from streams, like for instance "example input". All characters between the leading and the trailing quotation are extracted unchanged from the input stream, including whitespaces. The input string has to be in one single line. In case of input errors, the std::istream::failbit of the input stream is set
 Cblaze::int16_t16-bit signed integer type of the Blaze library
 Cblaze::int32_t32-bit signed integer type of the Blaze library
 Cblaze::int64_t64-bit signed integer type of the Blaze library
 Cblaze::int8_t8-bit signed integer type of the Blaze library
 Cintegral_constant
 Cblaze::InvGeneric wrapper for the inv() function
 Cblaze::InvCbrtGeneric wrapper for the invcbrt() function
 Cblaze::InvExprTrait< T >Evaluation of the return type of an inversion expression.Via this type trait it is possible to evaluate the return type of an inversion expression. Given the type T, which must either a (complex) floating point type or a dense matrix type, the nested type Type corresponds to the resulting return type. In case the type of T doesn't fit or if no inversion operation exists for the type, the resulting data type Type is set to INVALID_TYPE
 Cblaze::InvSqrtGeneric wrapper for the invsqrt() function
 Cblaze::Length< TList >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::Limits< Type >Numerical limits of built-in data types.The Limits class provides numerical limits for the following built-in data types:
 Cblaze::LogGeneric wrapper for the log() function
 Cblaze::Log10Generic wrapper for the log10() function
 Cblaze::Log2Generic wrapper for the log2() function
 Cblaze::LowerMatrix< MT, SO, DF >Matrix adapter for lower triangular $ N \times N $ matrices
 Cblaze::LowType< T1, T2 >Base template for the LowType type trait
 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::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::Matrix< CompressedMatrix< Type, SO >, SO >
 Cblaze::Matrix< DMatSMatSchurExpr< MT1, MT2 >, SO >
 Cblaze::Matrix< DMatTSMatSchurExpr< MT1, MT2 >, SO >
 Cblaze::Matrix< DVecSVecOuterExpr< VT1, VT2 >, SO >
 Cblaze::Matrix< IdentityMatrix< Type, SO >, SO >
 Cblaze::Matrix< PT, SO >
 Cblaze::Matrix< SMatDeclDiagExpr< MT, SO >, SO >
 Cblaze::Matrix< SMatDeclHermExpr< MT, SO >, SO >
 Cblaze::Matrix< SMatDeclLowExpr< MT, SO >, SO >
 Cblaze::Matrix< SMatDeclSymExpr< MT, SO >, SO >
 Cblaze::Matrix< SMatDeclUppExpr< MT, SO >, SO >
 Cblaze::Matrix< SMatDMatSchurExpr< MT1, MT2 >, SO >
 Cblaze::Matrix< SMatEvalExpr< MT, SO >, SO >
 Cblaze::Matrix< SMatMapExpr< MT, OP, SO >, SO >
 Cblaze::Matrix< SMatScalarDivExpr< MT, ST, SO >, SO >
 Cblaze::Matrix< SMatScalarMultExpr< MT, ST, SO >, SO >
 Cblaze::Matrix< SMatSerialExpr< MT, SO >, SO >
 Cblaze::Matrix< SMatSMatAddExpr< MT1, MT2 >, SO >
 Cblaze::Matrix< SMatSMatMultExpr< MT1, MT2 >, SO >
 Cblaze::Matrix< SMatSMatSchurExpr< MT1, MT2 >, SO >
 Cblaze::Matrix< SMatSMatSubExpr< MT1, MT2 >, SO >
 Cblaze::Matrix< SMatTransExpr< MT, SO >, SO >
 Cblaze::Matrix< SMatTransposer< MT, SO >, SO >
 Cblaze::Matrix< SMatTSMatAddExpr< MT1, MT2 >, SO >
 Cblaze::Matrix< SMatTSMatMultExpr< MT1, MT2 >, SO >
 Cblaze::Matrix< SMatTSMatSchurExpr< MT1, MT2 >, SO >
 Cblaze::Matrix< SMatTSMatSubExpr< MT1, MT2 >, SO >
 Cblaze::Matrix< SVecDVecOuterExpr< VT1, VT2 >, SO >
 Cblaze::Matrix< SVecSVecOuterExpr< VT1, VT2 >, SO >
 Cblaze::Matrix< TSMatDMatSchurExpr< MT1, MT2 >, SO >
 Cblaze::Matrix< TSMatSMatMultExpr< MT1, MT2 >, SO >
 Cblaze::Matrix< TSMatSMatSchurExpr< MT1, MT2 >, SO >
 Cblaze::Matrix< TSMatSMatSubExpr< MT1, MT2 >, SO >
 Cblaze::Matrix< TSMatTSMatAddExpr< MT1, MT2 >, SO >
 Cblaze::Matrix< TSMatTSMatMultExpr< MT1, MT2 >, SO >
 Cblaze::Matrix< TSMatTSMatSchurExpr< MT1, MT2 >, SO >
 Cblaze::Matrix< TSMatTSMatSubExpr< MT1, MT2 >, SO >
 Cblaze::MatrixSerializerSerializer 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::MaxGeneric wrapper for the max() function
 Cblaze::MinGeneric wrapper for the min() function
 CMT
 Cblaze::MultExprTrait< T1, T2 >Evaluation of the resulting expression type of a multiplication.Via this type trait it is possible to evaluate the return type of a multiplication expression between scalars, vectors, and matrices. Given the two types T1 and T2, which must be either scalar, vector, or matrix types, the nested type Type corresponds to the resulting return type. In case T1 or T2 don't fit or if the two types cannot be multiplied, the resulting data type Type is set to INVALID_TYPE
 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::NoDeleteNo-delete policy class
 Cblaze::NonCopyableBase 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::NonCreatableBase 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::NoopGeneric wrapper for the null function
 Cblaze::NullTypeUtility 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::OperationBase 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::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< ET >Generic wrapper for the pow() function
 Cblaze::PtrDeletePointer-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_tPointer difference type of the Blaze library
 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 $ [0..max] $, where max is the maximal value of the given data type T
 Cblaze::RealGeneric wrapper for the real() function
 Cblaze::RealTrait< T >Base template for the RealTrait class.The RealTrait class template offers the possibility to select the resulting data type of a generic real operation on the given type T. Given the type T, which must either be a scalar, vector, or matrix type, the nested type Type corresponds to the resulting data type of the operation. In case the type of T doesn't fit or if no real operation exists for the type, the resulting data type Type is set to INVALID_TYPE. Note that const and volatile qualifiers and reference modifiers are generally ignored
 Cblaze::StaticMatrix< Type, M, N, SO >::Rebind< NewType >Rebind mechanism to obtain a StaticMatrix with different data/element type
 Cblaze::HybridVector< Type, N, TF >::Rebind< NewType >Rebind mechanism to obtain a HybridVector with different data/element type
 Cblaze::CustomMatrix< Type, AF, PF, SO >::Rebind< NewType >Rebind mechanism to obtain a CustomMatrix with different data/element type
 Cblaze::CustomVector< Type, AF, PF, TF >::Rebind< NewType >Rebind mechanism to obtain a CustomVector with different data/element type
 Cblaze::AlignedAllocator< Type >::rebind< Type2 >Implementation of the AlignedAllocator rebind mechanism
 Cblaze::DynamicMatrix< Type, SO >::Rebind< NewType >Rebind mechanism to obtain a DynamicMatrix with different data/element type
 Cblaze::DynamicVector< Type, TF >::Rebind< NewType >Rebind mechanism to obtain a DynamicVector with different data/element type
 Cblaze::HybridMatrix< Type, M, N, SO >::Rebind< NewType >Rebind mechanism to obtain a HybridMatrix with different data/element type
 Cblaze::StaticVector< Type, N, TF >::Rebind< NewType >Rebind mechanism to obtain a StaticVector with different data/element type
 Cblaze::CompressedMatrix< Type, SO >::Rebind< NewType >Rebind mechanism to obtain a CompressedMatrix with different data/element type
 Cblaze::Rebind< NewType >Rebind mechanism to obtain a CompressedMatrix with different data/element type
 Cblaze::CompressedVector< Type, TF >::Rebind< NewType >Rebind mechanism to obtain a CompressedVector with different data/element type
 Cblaze::IdentityMatrix< Type, SO >::Rebind< NewType >Rebind mechanism to obtain an IdentityMatrix with different data/element type
 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::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::IdentityMatrix< Type, SO >::Resize< NewM, NewN >Resize mechanism to obtain a IdentityMatrix with different fixed dimensions
 Cblaze::CustomVector< Type, AF, PF, TF >::Resize< NewN >Resize mechanism to obtain a CustomVector 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::StaticMatrix< Type, M, N, SO >::Resize< NewM, NewN >Resize mechanism to obtain a StaticMatrix with different fixed dimensions
 Cblaze::HybridVector< Type, N, TF >::Resize< NewN >Resize mechanism to obtain a HybridVector with a different fixed number of elements
 Cblaze::DynamicVector< Type, TF >::Resize< NewN >Resize mechanism to obtain a DynamicVector with a different fixed number of elements
 Cblaze::CompressedVector< Type, TF >::Resize< NewN >Resize mechanism to obtain a CompressedVector 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::CustomMatrix< Type, AF, PF, SO >::Resize< NewM, NewN >Resize mechanism to obtain a CustomMatrix with different fixed dimensions
 Cblaze::HybridMatrix< Type, M, N, SO >::Resize< NewM, NewN >Resize mechanism to obtain a HybridMatrix with different fixed dimensions
 Cblaze::CompressedMatrix< Type, SO >::Resize< NewM, NewN >Resize mechanism to obtain a CompressedMatrix with different fixed dimensions
 Cblaze::Resize< NewM, NewN >Resize mechanism to obtain a CompressedMatrix with different fixed dimensions
 Cblaze::RoundGeneric wrapper for the round() function
 Cblaze::Row< MT, SO, DF, SF >Reference to a specific row of a dense or sparse matrix.The Row template represents a reference to a specific row of a dense or sparse matrix primitive. The type of the matrix is specified via the first template parameter:
 Cblaze::RowExprTrait< MT >Evaluation of the expression type type of a row operation.Via this type trait it is possible to evaluate the return type of a row operation. Given the dense or sparse matrix type MT, the nested type Type corresponds to the resulting return type. In case the given type is neither a dense nor a sparse matrix type, the resulting data type Type is set to INVALID_TYPE
 Cblaze::RowTrait< MT >Base template for the RowTrait class
 Cblaze::SchurExprTrait< T1, T2 >Evaluation of the return type of an Schur product expression.Via this type trait it is possible to evaluate the return type of a Schur product expression between matrices. Given the two types T1 and T2, which must be matrix types, the nested type Type corresponds to the resulting return type. In case the types of T1 or T2 don't fit or if the two types cannot be used in a Schur product, the resulting data type Type is set to INVALID_TYPE
 Cblaze::SchurTrait< T1, T2 >Base template for the SchurTrait class
 Cblaze::SerialGeneric wrapper for the Serial() function
 Cblaze::SerialExprTrait< T >Evaluation of the return type of a serial evaluation expression.Via this type trait it is possible to evaluate the return type of a serial evaluation expression. Given the type T, which must either be a vector or matrix type, the nested type Type corresponds to the resulting return type. In case the type of T doesn't fit or if no serial evaluation operation exists for the type, the resulting data type Type is set to INVALID_TYPE
 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::SIMDcdoubleSIMD type for 64-bit double precision complex values
 Cblaze::SIMDcfloatSIMD type for 32-bit single precision complex values
 Cblaze::SIMDcint16SIMD type for 16-bit signed integral complex values
 Cblaze::SIMDcint32SIMD type for 32-bit signed integral complex values
 Cblaze::SIMDcint64SIMD type for 64-bit signed integral complex values
 Cblaze::SIMDcint8SIMD type for 8-bit signed integral complex values
 Cblaze::SIMDcuint16SIMD type for 16-bit unsigned integral complex values
 Cblaze::SIMDcuint32SIMD type for 32-bit unsigned integral complex values
 Cblaze::SIMDcuint64SIMD type for 64-bit unsigned integral complex values
 Cblaze::SIMDcuint8SIMD type for 8-bit unsigned integral complex values
 Cblaze::SIMDdoubleSIMD type for 64-bit double precision floating point data values
 CSIMDf32
 CSIMDf64
 Cblaze::SIMDfloatSIMD type for 32-bit single precision floating point data values
 Cblaze::SIMDint16SIMD type for 16-bit signed integral data values
 Cblaze::SIMDint32SIMD type for 32-bit signed integral data values
 Cblaze::SIMDint64SIMD type for 64-bit integral data values
 Cblaze::SIMDint8SIMD 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::SIMDuint16SIMD type for 16-bit unsigned integral data values
 Cblaze::SIMDuint32SIMD type for 32-bit unsigned integral data values
 Cblaze::SIMDuint64SIMD type for 64-bit unsigned integral data values
 Cblaze::SIMDuint8SIMD type for 8-bit unsigned integral data values
 Cblaze::SinGeneric wrapper for the sin() function
 Cblaze::SinhGeneric wrapper for the sinh() function
 Cblaze::size_tSize type of the Blaze library
 Cblaze::SparseElementBase 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::SqrtGeneric wrapper for the sqrt() function
 Cblaze::StrictlyLowerMatrix< MT, SO, DF >Matrix adapter for strictly lower triangular $ N \times N $ matrices
 Cblaze::StrictlyUpperMatrix< MT, SO, DF >Matrix adapter for strictly upper triangular $ N \times N $ matrices
 Cblaze::SubExprTrait< T1, T2 >Evaluation of the return type of a subtraction expression.Via this type trait it is possible to evaluate the return type of a subtraction expression between scalar, vectors, and matrices. Given the two types T1 and T2, which must be either scalar, vector, or matrix types, the nested type Type corresponds to the resulting return type. In case T1 or T2 don't fit or if the two types cannot be subtracted, the resulting data type Type is set to INVALID_TYPE
 Cblaze::Submatrix< MT, AF, SO, DF >View on a specific submatrix of a dense or sparse matrix.The Submatrix class template represents a view on a specific submatrix of a dense or sparse matrix primitive. The type of the matrix is specified via the first template parameter:
 Cblaze::SubmatrixExprTrait< MT, AF >Evaluation of the expression type type of a submatrix operation.Via this type trait it is possible to evaluate the return type of a submatrix operation. Given the dense or sparse matrix type MT and the alignment flag AF, the nested type Type corresponds to the resulting return type. In case the given type is neither a dense nor a sparse matrix type, the resulting data type Type is set to INVALID_TYPE
 Cblaze::SubmatrixTrait< MT >Base template for the SubmatrixTrait class
 Cblaze::SubTrait< T1, T2, typename >Base template for the SubTrait class
 Cblaze::Subvector< VT, AF, TF, DF >View on a specific subvector of a dense or sparse vector.The Subvector class template represents a view on a specific subvector of a dense or sparse vector primitive. The type of the vector is specified via the first template parameter:
 Cblaze::SubvectorExprTrait< VT, AF >Evaluation of the expression type type of a subvector operation.Via this type trait it is possible to evaluate the return type of a subvector operation. Given the dense or sparse vector type VT and the alignment flag AF, the nested type Type corresponds to the resulting return type. In case the given type is neither a dense nor a sparse vector type, the resulting data type Type is set to INVALID_TYPE
 Cblaze::SubvectorTrait< VT >Base template for the SubvectorTrait class
 Cblaze::SymmetricMatrix< MT, SO, DF, NF >Matrix adapter for symmetric $ N \times N $ matrices
 Cblaze::TanGeneric wrapper for the tan() function
 Cblaze::TanhGeneric wrapper for the tanh() function
 Cblaze::threadpool::TaskQueueTask 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::TransGeneric wrapper for the trans() function
 Cblaze::TransExprTrait< T >Evaluation of the return type of a transpose expression.Via this type trait it is possible to evaluate the return type of a transpose expression. Given the type T, which must either be a vector or matrix type, the nested type Type corresponds to the resulting return type. In case the type of T doesn't fit or if no transpose operation exists for the type, the resulting data type Type is set to INVALID_TYPE
 Cblaze::TruncGeneric wrapper for the trunc() function
 CType
 CType
 CType
 CType
 CType
 CType
 CType
 CType
 CType
 CType
 CType
 CType
 CType
 CType
 CType
 CType
 CType
 CType
 CType
 CType
 CType
 CType
 CType
 CType
 CType
 CType
 CType
 CType
 CType
 CType
 CType
 CType
 CType
 CType
 CType
 CType
 CType
 CType
 CType
 CType
 CType
 CType
 CType
 CType
 CType
 CType
 CType
 CType
 CType
 CType
 CType
 CType
 CType
 CType
 CType
 CType
 CType
 CType
 CType
 CType
 Cblaze::TypeAt< TList, 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 Result. The following example gives an impression of the use of the TypeAt class:
 Cblaze::TypeList< H, T >Implementation of a type list.The TypeList class is an implementation of a type list according to the example of Andrei Alexandrescu. The type list merely consists of the two data types Head and Tail. In order to create type lists of more data types, the TypeList class is used recursively:
 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_t16-bit unsigned integer type of the Blaze library
 Cblaze::uint32_t32-bit unsigned integer type of the Blaze library
 Cblaze::uint64_t64-bit unsigned integer type of the Blaze library
 Cblaze::uint8_t8-bit unsigned integer type of the Blaze library
 Cblaze::UnaryMapExprTrait< T, OP >Evaluation of the return type of a unary map expression.Via this type trait it is possible to evaluate the return type of a unary map expression. Given the type T, which must either be a vector or matrix type, the nested type Type corresponds to the resulting return type. In case the type of T doesn't fit or if no unary map operation exists for the type, the resulting data type Type is set to INVALID_TYPE
 Cblaze::UnaryMapTrait< T, OP >Base template for the UnaryMapTrait class
 Cblaze::UnderlyingBuiltin< T >Evaluation of the underlying builtin element type of a given data type.Via this type trait it is possible to evaluate the underlying fundamental element type at the heart of a given data type. Examples:
 Cblaze::UnderlyingElement< T >Evaluation of the element type of a given data type.Via this type trait it is possible to evaluate the element type of a given data type. Examples:
 Cblaze::UnderlyingNumeric< T >Evaluation of the underlying numeric element type of a given data type.Via this type trait it is possible to evaluate the underlying numeric (fundamental or complex) element type at the heart of a given data type. Examples:
 Cblaze::UniLowerMatrix< MT, SO, DF >Matrix adapter for lower unitriangular $ N \times N $ matrices
 Cblaze::Unique< TList >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 $ N \times N $ 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 $ N \times N $ 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::Vector< CompressedVector< Type, TF >, TF >
 Cblaze::Vector< DVecSVecMultExpr< VT1, VT2, TF >, TF >
 Cblaze::Vector< PT, TF >
 Cblaze::Vector< SMatSVecMultExpr< MT, VT >, TF >
 Cblaze::Vector< SVecDVecDivExpr< VT1, VT2, TF >, TF >
 Cblaze::Vector< SVecDVecMultExpr< VT1, VT2, TF >, TF >
 Cblaze::Vector< SVecEvalExpr< VT, TF >, TF >
 Cblaze::Vector< SVecMapExpr< VT, OP, TF >, TF >
 Cblaze::Vector< SVecScalarDivExpr< VT, ST, TF >, TF >
 Cblaze::Vector< SVecScalarMultExpr< VT, ST, TF >, TF >
 Cblaze::Vector< SVecSerialExpr< VT, TF >, TF >
 Cblaze::Vector< SVecSVecAddExpr< VT1, VT2, TF >, TF >
 Cblaze::Vector< SVecSVecMultExpr< VT1, VT2, TF >, TF >
 Cblaze::Vector< SVecSVecSubExpr< VT1, VT2, TF >, TF >
 Cblaze::Vector< SVecTransExpr< VT, TF >, TF >
 Cblaze::Vector< SVecTransposer< VT, TF >, TF >
 Cblaze::Vector< TSMatSVecMultExpr< MT, VT >, TF >
 Cblaze::Vector< TSVecSMatMultExpr< VT, MT >, TF >
 Cblaze::Vector< TSVecTSMatMultExpr< VT, MT >, TF >
 Cblaze::VectorSerializerSerializer 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::timing::WcPolicyTiming 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
 CT