Class Hierarchy
This inheritance list is sorted roughly, but not completely, alphabetically:
[detail level 123456]
 CA
 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::AddGeneric wrapper for the addition operator
 Cblaze::AddAssignGeneric wrapper for the addAssign() 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::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::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::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::AssignGeneric wrapper for the assign() function
 Cblaze::AtanGeneric wrapper for the atan() function
 Cblaze::Atan2Generic wrapper for the atan2() function
 Cblaze::AtanhGeneric 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::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::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::ClearGeneric 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::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::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::IdentityMatrix< Type, SO >::ConstIteratorIterator over the elements of the identity matrix
 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::SMatMapExpr< MT, OP, SO >::ConstIteratorIterator over the elements of the sparse matrix map expression
 Cblaze::SMatReduceExpr< MT, OP, rowwise >::ConstIteratorIterator over the elements of the dense vector
 Cblaze::SMatScalarDivExpr< MT, ST, SO >::ConstIteratorIterator over the elements of the sparse matrix/scalar division 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::DMatReduceExpr< MT, OP, rowwise >::ConstIteratorIterator over the elements of the dense vector
 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::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::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::CrossTrait< T1, T2, typename >Base template for the CrossTrait class
 Cblaze::CTransGeneric wrapper for the ctrans() function
 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::DeclDiagTrait< MT >Base template for the DeclDiagTrait class
 Cblaze::DeclHermGeneric wrapper for the declherm() function
 Cblaze::DeclHermTrait< MT >Base template for the DeclHermTrait class
 Cblaze::DeclIdGeneric wrapper for the declid() function
 Cblaze::DeclIdTrait< MT >Base template for the DeclIdTrait class
 Cblaze::DeclLowGeneric wrapper for the decllow() function
 Cblaze::DeclLowTrait< MT >Base template for the DeclLowTrait class
 Cblaze::DeclSymGeneric wrapper for the declsym() function
 Cblaze::DeclSymTrait< MT >Base template for the DeclSymTrait class
 Cblaze::DeclUppGeneric wrapper for the declupp() function
 Cblaze::DeclUppTrait< MT >Base template for the DeclUppTrait class
 Cblaze::DeclZeroGeneric 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 $ N \times N $ 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::DivGeneric wrapper for the division operator
 Cblaze::DivAssignGeneric wrapper for the divAssign() function
 Cblaze::DivTrait< T1, T2, typename >Base template for the DivTrait class
 Cblaze::DMatReduceExpr< MT, OP, RF >Base template for row-major dense matrix 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::EmptyTypeEmpty 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::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< 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::ErfGeneric wrapper for the erf() function
 Cblaze::ErfcGeneric wrapper for the erfc() function
 Cblaze::EvalGeneric wrapper for the eval() function
 Cblaze::ExpGeneric wrapper for the exp() function
 Cblaze::Exp10Generic wrapper for the exp10() function
 Cblaze::Exp2Generic 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::ExpandTrait< T, CEAs >Base template for the ExpandTrait class
 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
 CHasAbsHelper
 CHasAcosHelper
 CHasAcoshHelper
 CHasAddHelper
 CHasAsinHelper
 CHasAsinhHelper
 CHasAtan2Helper
 CHasAtanHelper
 CHasAtanhHelper
 CHasCbrtHelper
 CHasCeilHelper
 CHasClampHelper
 CHasConjHelper
 CHasCosHelper
 CHasCoshHelper
 Cblaze::HasCyclicDependency< T, TL, C >
 CHasDivHelper
 CHasErfcHelper
 CHasErfHelper
 CHasExp10Helper
 CHasExp2Helper
 CHasExpHelper
 CHasFloorHelper
 CHasHypotHelper
 CHasImagHelper
 CHasInvCbrtHelper
 CHasInvSqrtHelper
 CHasLog10Helper
 CHasLog2Helper
 CHasLogHelper
 CHasMaxHelper
 CHasMinHelper
 CHasMultHelper
 CHasPowHelper
 CHasRealHelper
 CHasRoundHelper
 CHasSignHelper
 CHasSinHelper
 CHasSinhHelper
 CHasSqrtHelper
 CHasSubHelper
 CHasTanHelper
 CHasTanhHelper
 CHasTruncHelper
 Cblaze::HermitianMatrix< MT, SO, DF >Matrix adapter for Hermitian $ N \times N $ matrices
 Cblaze::HighType< T1, T2, typename >Base template for the HighType type trait
 Cblaze::HypotGeneric 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::ImagGeneric wrapper for the imag() function
 Cblaze::index_sequenceIndex 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::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::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_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
 Cblaze::integer_sequenceInteger sequence type of the Blaze library
 Cintegral_constant
 Cblaze::InvGeneric wrapper for the inv() function
 Cblaze::InvCbrtGeneric wrapper for the invcbrt() function
 Cblaze::InvSqrtGeneric wrapper for the invsqrt() function
 CIsHermitianHelper
 CIsLowerHelper
 CIsStrictlyLowerHelper
 CIsStrictlyUpperHelper
 CIsSymmetricHelper
 CIsUniformHelper
 CIsUniLowerHelper
 CIsUniUpperHelper
 CIsUpperHelper
 CIsZeroHelper
 Cblaze::L1NormGeneric wrapper for the l1Norm() function
 Cblaze::L2NormGeneric wrapper for the l2Norm() function
 Cblaze::L3NormGeneric wrapper for the l3Norm() function
 Cblaze::L4NormGeneric wrapper for the l4Norm() function
 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::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, typename >Base template for the LowType type trait
 Cblaze::LpNorm< P >Generic wrapper for the lpNorm() function
 Cblaze::make_index_sequenceImport of the std::make_index_sequence alias template into the Blaze namespace
 Cblaze::make_integer_sequenceImport 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::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< SVecExpandExpr< VT, TF, CEAs... >, 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::Matrix< ZeroMatrix< Type, SO >, 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::MaxSizeHelper1< typename, size_t, typename >
 Cblaze::MaxSizeHelper1< T, N >
 Cblaze::MaxSizeHelper2< typename, size_t, typename >
 Cblaze::MinGeneric wrapper for the min() function
 CMT
 Cblaze::MultGeneric wrapper for the multiplication operator
 Cblaze::MultAssignGeneric wrapper for the multAssign() function
 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::PowGeneric wrapper for the pow() function
 Cblaze::Pow2Generic wrapper for the pow2() function
 Cblaze::Pow3Generic wrapper for the pow3() function
 Cblaze::Pow4Generic wrapper for the pow4() 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::QdrtGeneric 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 $ [0..max] $, where max is the maximal value of the given data type T
 Cblaze::RealGeneric wrapper for the real() function
 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::ZeroMatrix< Type, SO >::Rebind< NewType >Rebind mechanism to obtain a ZeroMatrix with different data/element type
 Cblaze::ZeroVector< Type, TF >::Rebind< NewType >Rebind mechanism to obtain a ZeroVector with different data/element type
 Cblaze::HybridVector< Type, N, TF >::Rebind< NewType >Rebind mechanism to obtain a HybridVector with different data/element type
 Cblaze::InitializerVector< Type, TF >::Rebind< NewType >Rebind mechanism to obtain a InitializerVector 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::CustomVector< Type, AF, PF, TF, RT >::Rebind< NewType >Rebind mechanism to obtain a CustomVector with different data/element type
 Cblaze::UniformVector< Type, TF >::Rebind< NewType >Rebind mechanism to obtain a UniformVector 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::CustomMatrix< Type, AF, PF, SO, RT >::Rebind< NewType >Rebind mechanism to obtain a CustomMatrix with different data/element type
 Cblaze::DynamicVector< Type, TF >::Rebind< NewType >Rebind mechanism to obtain a DynamicVector with different data/element type
 Cblaze::StaticVector< Type, N, TF >::Rebind< NewType >Rebind mechanism to obtain a StaticVector with different data/element type
 Cblaze::UniformMatrix< Type, SO >::Rebind< NewType >Rebind mechanism to obtain a UniformMatrix with different data/element type
 Cblaze::InitializerMatrix< Type >::Rebind< NewType >Rebind mechanism to obtain a InitializerMatrix with different data/element type
 Cblaze::DynamicMatrix< Type, SO >::Rebind< NewType >Rebind mechanism to obtain a DynamicMatrix 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::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::ResetGeneric wrapper for the reset() function
 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::CompressedVector< Type, TF >::Resize< NewN >Resize mechanism to obtain a CompressedVector with a different fixed number of elements
 Cblaze::ZeroMatrix< Type, SO >::Resize< NewM, NewN >Resize mechanism to obtain a ZeroMatrix with different fixed dimensions
 Cblaze::ZeroVector< Type, TF >::Resize< NewN >Resize mechanism to obtain a ZeroVector with a different fixed number of elements
 Cblaze::InitializerMatrix< Type >::Resize< NewM, NewN >Resize mechanism to obtain a InitializerMatrix with different fixed dimensions
 Cblaze::InitializerVector< Type, TF >::Resize< NewN >Resize mechanism to obtain a InitializerVector 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::CustomMatrix< Type, AF, PF, SO, RT >::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::HybridVector< Type, N, TF >::Resize< NewN >Resize mechanism to obtain a HybridVector 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::CustomVector< Type, AF, PF, TF, RT >::Resize< NewN >Resize mechanism to obtain a CustomVector 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::DynamicVector< Type, TF >::Resize< NewN >Resize mechanism to obtain a DynamicVector 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::UniformVector< Type, TF >::Resize< NewN >Resize mechanism to obtain a UniformVector 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::RoundGeneric 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::SchurGeneric wrapper for the Schur product
 Cblaze::SchurAssignGeneric wrapper for the schurAssign() function
 Cblaze::SchurTrait< T1, T2, typename >Base template for the SchurTrait class
 Cblaze::SerialGeneric 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::SignGeneric wrapper for the sign() function
 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::SizeHelper1< typename, size_t, typename >
 Cblaze::SizeHelper1< T, N >
 Cblaze::SizeHelper2< typename, size_t, typename >
 CSmallArrayData
 Cblaze::SMatReduceExpr< MT, OP, RF >Base template for row-major sparse matrix reduction operations.The SMatReduceExpr class represents the compile time expression for partial reduction operations of row-major sparse matrices
 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::SqrAbsGeneric wrapper for the squared abs() function
 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::SubGeneric wrapper for the subtraction operator
 Cblaze::SubAssignGeneric wrapper for the subAssign() function
 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 $ 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::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
 CType
 CType
 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_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::UnaryPow< ET >Generic wrapper for the pow() function with fixed exponent
 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::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 $ N \times N $ matrices
 Cblaze::SmallArray< T, N, A >::UninitializedDefinition 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 $ 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::Vector< ZeroVector< Type, TF >, 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