All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
Class Hierarchy
This inheritance list is sorted roughly, but not completely, alphabetically:
[detail level 1234]
 Cblaze::AbsExprTrait< T >Evaluation of the return type of an absolute value expression.Via this type trait it is possible to evaluate the return type of an absolute value expression. Given the type T, which must either be a scalar, vector, or matrix type, the nested type Type corresponds to the resulting return type. In case the type of T doesn't fit or if no absolute value operation exists for the type, the resulting data type Type is set to INVALID_TYPE
 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::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::RemoveReference<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 >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 >
 CAlignedStorageHelper
 Cblaze::AlignmentTrait< T >Evaluation of the required alignment of the given data type.The AlignmentTrait class template evaluates the required alignment for the given data type. For instance, for fundamental data types that can be vectorized via SSE or AVX instructions, the proper alignment is 16 or 32 bytes, respectively. For all other data types, a multiple of the alignment chosen by the compiler is returned. The evaluated alignment can be queried via the nested value member
 Cblaze::And< T1, T2, T3, T4, T5 >Compile time logical and evaluation.The And class template performs at compile time a logical and ('&&') evaluation of the up to five given compile time conditions:
 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::BaseElementType< T >Evaluation of the base element type of a given data type.Via this type trait it is possible to evaluate the base (fundamental) element type at the heart of a given data type. Examples:
 Cblaze::MemoryPool< Type, Blocksize >::BlockMemory block within the memory bool
 Cblaze::BoxLCPA box linear complementarity problem (BLCP) data structure.The BoxLCP class represent a box linear complementarity problem (BLCP) of the form $ A \cdot x + b \leq 0 \quad\perp\quad \underline{x} \leq x \leq \bar{x} $
 Cblaze::PtrVector< T, D, G >::CastIterator< C >Dynamic cast iterator for polymorphic pointer vectors.The CastIterator class is part of the PtrVector class and represent a forward iterator over all elements of type C contained in a range of elements of type T, where C is a type derived from T
 Cblaze::CMathTrait< T >Base template for the CMathTrait class.The CMathTrait template evaluates the return type of the mathematical functions defined in the C++ header <cmath> depending on the type of the template argument. In case of an integral data type or double precision argument, the return value of the functions is double, whereas the return type is float for single precision arguments and long double for long double precision arguments
 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::complexComplex data type of the Blaze library
 Cblaze::ComputationBase class for all compute expression templates.The Computation class serves as a tag for all computational expression templates. All classes, that represent a mathematical computation (addition, subtraction, multiplication, division, absolute value calculation, ...) and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as computational expression template. Only in case a class is derived from the Computation base class, the IsComputation type trait recognizes the class as valid computational expression template
 Cblaze::ConstantGrowth< Growth >Constant growth policy class.The ConstantGrowth policy class implements a constant growth strategy. It can be customized for any purpose: the Growth template argument specifies the constant increase of the given size
 Cblaze::PtrVector< T, D, G >::ConstCastIterator< C >Dynamic cast iterator for polymorphic pointer vectors.The ConstCastIterator class is part of the PtrVector class and represent a forward iterator over all elements of type C contained in a range of elements of type T, where C is a type derived from T. The ConstCastIterator is the counterpart of CastIterator for constant vectors
 Cblaze::SMatScalarDivExpr< typename, typename, bool >::ConstIteratorIterator over the elements of the sparse matrix/scalar division expression
 Cblaze::SMatAbsExpr< typename, bool >::ConstIteratorIterator over the elements of the sparse matrix absolute value expression
 Cblaze::SMatTransExpr< typename, bool >::ConstIteratorIterator over the elements of the sparse matrix transposition expression
 Cblaze::SMatScalarMultExpr< typename, typename, bool >::ConstIteratorIterator over the elements of the sparse matrix/scalar multiplication expression
 Cblaze::SVecAbsExpr< typename, bool >::ConstIteratorIterator over the elements of the sparse vector absolute value expression
 Cblaze::SVecDVecMultExpr< typename, typename, bool >::ConstIteratorIterator over the elements of the sparse vector-dense vector multiplication expression
 Cblaze::SVecScalarDivExpr< typename, typename, bool >::ConstIteratorIterator over the elements of the sparse vector/scalar multiplication expression
 Cblaze::SVecTDVecMultExpr< typename, typename >::ConstIteratorIterator over the elements of the sparse vector-dense vector outer product expression
 Cblaze::SVecScalarMultExpr< typename, typename, bool >::ConstIteratorIterator over the elements of the sparse vector/scalar multiplication expression
 Cblaze::SVecTransExpr< typename, bool >::ConstIteratorIterator over the elements of the sparse vector absolute value expression
 Cblaze::DMatAbsExpr< MT, SO >::ConstIteratorIterator over the elements of the dense matrix
 Cblaze::DMatDMatAddExpr< 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::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::DMatTransExpr< MT, SO >::ConstIteratorIterator over the elements of the dense matrix
 Cblaze::DVecAbsExpr< VT, TF >::ConstIteratorIterator over the elements of the dense vector
 Cblaze::DVecDVecAddExpr< VT1, VT2, TF >::ConstIteratorIterator over the elements of the dense vector
 Cblaze::DVecDVecMultExpr< VT1, VT2, TF >::ConstIteratorIterator over the elements of the dense vector
 Cblaze::DVecDVecSubExpr< VT1, VT2, TF >::ConstIteratorIterator over the elements of the dense vector
 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::DVecTDVecMultExpr< VT1, VT2 >::ConstIteratorIterator over the elements of the dense matrix
 Cblaze::DVecTransExpr< VT, TF >::ConstIteratorIterator over the elements of the dense vector
 Cblaze::DVecTSVecMultExpr< VT1, VT2 >::ConstIteratorIterator over the elements of the dense vector-sparse vector outer product expression
 Cblaze::ContactLCPA data structure for linear complementarity problems (LCPs) for contact mechanics.TODO
 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::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::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::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::DenseIterator< Type >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::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 >Base template for the DivTrait class
 Cblaze::DMatAbsExprTrait< MT >Evaluation of the expression type of a dense matrix absolute value operation.Via this type trait it is possible to evaluate the resulting expression type of a dense matrix absolute value operation. Given the row-major dense matrix type MT, the nested type Type corresponds to the resulting expression type. In case either MT is not a row-major dense matrix type, the resulting Type is set to INVALID_TYPE
 Cblaze::DMatDMatAddExprTrait< MT1, MT2 >Evaluation of the expression type of a dense matrix/dense matrix addition.Via this type trait it is possible to evaluate the resulting expression type of a dense matrix/dense matrix addition. Given the two row-major dense matrix types MT1 and MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 or MT2 is not a row-major dense matrix, the resulting data type Type is set to INVALID_TYPE
 Cblaze::DMatDMatMultExprTrait< MT1, MT2 >Evaluation of the expression type of a dense matrix/dense matrix multiplication.Via this type trait it is possible to evaluate the resulting expression type of a dense matrix/dense matrix multiplication. Given the two row-major dense matrix types MT1 and MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 or MT2 is not a row-major dense matrix, the resulting data type Type is set to INVALID_TYPE
 Cblaze::DMatDMatSubExprTrait< MT1, MT2 >Evaluation of the expression type of a dense matrix/dense matrix subtraction.Via this type trait it is possible to evaluate the resulting expression type of a dense matrix/dense matrix subtraction. Given the two row-major dense matrix types MT1 and MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 or MT2 is not a row-major dense matrix, the resulting data type Type is set to INVALID_TYPE
 Cblaze::DMatDVecMultExprTrait< MT, VT >Evaluation of the expression type of a dense matrix/dense vector multiplication.Via this type trait it is possible to evaluate the resulting expression type of a dense matrix/dense vector multiplication. Given the row-major dense matrix type MT and the non-transpose dense vector type VT, the nested type Type corresponds to the resulting expression type. In case either MT is not a row-major dense matrix type or VT is not a non-transpose dense vector type, the resulting data type Type is set to INVALID_TYPE
 Cblaze::DMatEvalExprTrait< MT >Evaluation of the expression type of a dense matrix evaluation operation.Via this type trait it is possible to evaluate the resulting expression type of a dense matrix evaluation operation. Given the row-major dense matrix type MT, the nested type Type corresponds to the resulting expression type. In case either MT is not a row-major dense matrix type, the resulting Type is set to INVALID_TYPE
 Cblaze::DMatScalarDivExprTrait< MT, ST >Evaluation of the expression type of a dense matrix/scalar division.Via this type trait it is possible to evaluate the resulting expression type of a dense matrix/scalar division. Given the row-major dense matrix type MT and the scalar type ST, the nested type Type corresponds to the resulting expression type. In case either MT is not a row-major dense matrix type or ST is not a scalar type, the resulting Type is set to INVALID_TYPE
 Cblaze::DMatScalarMultExprTrait< MT, ST >Evaluation of the expression type of a dense matrix/scalar multiplication.Via this type trait it is possible to evaluate the resulting expression type of a dense matrix/scalar multiplication. Given the row-major dense matrix type MT and the scalar type ST, the nested type Type corresponds to the resulting expression type. In case either MT is not a row-major dense matrix type or ST is not a scalar type, the resulting Type is set to INVALID_TYPE
 Cblaze::DMatSerialExprTrait< MT >Evaluation of the expression type of a dense matrix serial evaluation operation.Via this type trait it is possible to evaluate the resulting expression type of a dense matrix serial evaluation operation. Given the row-major dense matrix type MT, the nested type Type corresponds to the resulting expression type. In case either MT is not a row-major dense matrix type, the resulting Type is set to INVALID_TYPE
 Cblaze::DMatSMatAddExprTrait< MT1, MT2 >Evaluation of the expression type of a dense matrix/sparse matrix addition.Via this type trait it is possible to evaluate the resulting expression type of a dense matrix/sparse matrix addition. Given the row-major dense matrix type MT1 and the row-major sparse matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a row-major dense matrix type or MT2 is not a row-major sparse matrix type, the resulting data type Type is set to INVALID_TYPE
 Cblaze::DMatSMatMultExprTrait< MT1, MT2 >Evaluation of the expression type of a dense matrix/sparse matrix multiplication.Via this type trait it is possible to evaluate the resulting expression type of a dense matrix/sparse matrix multiplication. Given the row-major dense matrix type MT1 and the row-major sparse matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a row-major dense matrix type or MT2 is not a row-major sparse matrix type, the resulting data type Type is set to INVALID_TYPE
 Cblaze::DMatSMatSubExprTrait< MT1, MT2 >Evaluation of the expression type of a dense matrix/sparse matrix subtraction.Via this type trait it is possible to evaluate the resulting expression type of a dense matrix/sparse matrix subtraction. Given the row-major dense matrix type MT1 and the row-major sparse matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a row-major dense matrix type or MT2 is not a row-major sparse matrix type, the resulting data type Type is set to INVALID_TYPE
 Cblaze::DMatSVecMultExprTrait< MT, VT >Evaluation of the expression type of a dense matrix/sparse vector multiplication.Via this type trait it is possible to evaluate the resulting expression type of a dense matrix/sparse vector multiplication. Given the row-major dense matrix type MT and the non-transpose sparse vector type VT, the nested type Type corresponds to the resulting expression type. In case either MT is not a row-major dense matrix type or VT is not a non-transpose sparse vector type, the resulting data type Type is set to INVALID_TYPE
 Cblaze::DMatTDMatAddExprTrait< MT1, MT2 >Evaluation of the expression type of a dense matrix/transpose dense matrix addition.Via this type trait it is possible to evaluate the resulting expression type of a dense matrix/transpose dense matrix addition. Given the row-major dense matrix type MT1 and the column-major dense matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a row-major dense matrix type or MT2 is not a column-major dense matrix type, the resulting data type Type is set to INVALID_TYPE
 Cblaze::DMatTDMatMultExprTrait< MT1, MT2 >Evaluation of the expression type of a dense matrix/transpose dense matrix multiplication.Via this type trait it is possible to evaluate the resulting expression type of a dense matrix/transpose dense matrix multiplication. Given the row-major dense matrix type MT1 and the column-major dense matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a row-major dense matrix type or MT2 is not a column-major dense matrix type, the resulting data type Type is set to INVALID_TYPE
 Cblaze::DMatTDMatSubExprTrait< MT1, MT2 >Evaluation of the expression type of a dense matrix/transpose dense matrix subtraction.Via this type trait it is possible to evaluate the resulting expression type of a dense matrix/transpose dense matrix subtraction. Given the row-major dense matrix type MT1 and the column-major dense matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a row-major dense matrix type or MT2 is not a column-major dense matrix type, the resulting data type Type is set to INVALID_TYPE
 Cblaze::DMatTransExprTrait< MT >Evaluation of the expression type of a dense matrix transpose operation.Via this type trait it is possible to evaluate the resulting expression type of a dense matrix transpose operation. Given the row-major dense matrix type MT, the nested type Type corresponds to the resulting expression type. In case either MT is not a row-major dense matrix type, the resulting Type is set to INVALID_TYPE
 Cblaze::DMatTSMatAddExprTrait< MT1, MT2 >Evaluation of the expression type of a dense matrix/transpose sparse matrix addition.Via this type trait it is possible to evaluate the resulting expression type of a dense matrix/transpose sparse matrix addition. Given the row-major dense matrix type MT1 and the column-major sparse matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a row-major dense matrix type or MT2 is not a column-major sparse matrix type, the resulting data type Type is set to INVALID_TYPE
 Cblaze::DMatTSMatMultExprTrait< MT1, MT2 >Evaluation of the expression type of a dense matrix/transpose sparse matrix multiplication.Via this type trait it is possible to evaluate the resulting expression type of a dense matrix/ transpose sparse matrix multiplication. Given the row-major dense matrix type MT1 and the column-major sparse matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a row-major dense matrix type or MT2 is not a column-major sparse matrix type, the resulting data type Type is set to INVALID_TYPE
 Cblaze::DMatTSMatSubExprTrait< MT1, MT2 >Evaluation of the expression type of a dense matrix/transpose sparse matrix subtraction.Via this type trait it is possible to evaluate the resulting expression type of a dense matrix/ transpose sparse matrix subtraction. Given the row-major dense matrix type MT1 and the column-major sparse matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a row-major dense matrix type or MT2 is not a column-major sparse matrix type, the resulting data type Type is set to INVALID_TYPE
 Cblaze::DVecAbsExprTrait< VT >Evaluation of the expression type of a dense vector absolute value operation.Via this type trait it is possible to evaluate the resulting expression type of a dense vector absolute value operation. Given the non-transpose dense vector type VT, the nested type Type corresponds to the resulting expression type. In case either VT is not a non-transpose dense vector type, the resulting Type is set to INVALID_TYPE
 Cblaze::DVecDVecAddExprTrait< VT1, VT2 >Evaluation of the expression type of a dense vector/dense vector addition.Via this type trait it is possible to evaluate the resulting expression type of a dense vector/dense vector addition. Given the two non-transpose dense vector types VT1 and VT2, the nested type Type corresponds to the resulting expression type. In case either VT1 or VT2 is not a non-transpose dense vector type, the resulting Type is set to INVALID_TYPE
 Cblaze::DVecDVecCrossExprTrait< VT1, VT2 >Evaluation of the expression type of a dense vector/dense vector cross product.Via this type trait it is possible to evaluate the resulting expression type of a dense vector/dense vector cross product. Given the two non-transpose dense vector types VT1 and VT2, the nested type Type corresponds to the resulting expression type. In case either VT1 or VT2 is not a non-transpose dense vector type, the resulting Type is set to INVALID_TYPE
 Cblaze::DVecDVecMultExprTrait< VT1, VT2 >Evaluation of the expression type of a dense vector/dense vector multiplication.Via this type trait it is possible to evaluate the resulting expression type of a dense vector/dense vector multiplication. Given the two non-transpose dense vector types VT1 and VT2, the nested type Type corresponds to the resulting expression type. In case either VT1 or VT2 is not a non-transpose dense vector type, the resulting Type is set to INVALID_TYPE
 Cblaze::DVecDVecSubExprTrait< VT1, VT2 >Evaluation of the expression type of a dense vector/dense vector subtraction.Via this type trait it is possible to evaluate the resulting expression type of a dense vector/dense vector subtraction. Given the two non-transpose dense vector types VT1 and VT2, the nested type Type corresponds to the resulting expression type. In case either VT1 or VT2 is not a non-transpose dense vector type, the resulting Type is set to INVALID_TYPE
 Cblaze::DVecEvalExprTrait< VT >Evaluation of the expression type of a dense vector evaluation operation.Via this type trait it is possible to evaluate the resulting expression type of a dense vector evaluation operation. Given the non-transpose dense vector type VT, the nested type Type corresponds to the resulting expression type. In case either VT is not a non-transpose dense vector type, the resulting Type is set to INVALID_TYPE
 Cblaze::DVecScalarDivExprTrait< VT, ST >Evaluation of the expression type of a dense vector/scalar division.Via this type trait it is possible to evaluate the resulting expression type of a dense vector/scalar division. Given the non-transpose dense vector type VT and the scalar type ST, the nested type Type corresponds to the resulting expression type. In case either VT is not a non-transpose dense vector type or ST is not a scalar type, the resulting Type is set to INVALID_TYPE
 Cblaze::DVecScalarMultExprTrait< VT, ST >Evaluation of the expression type of a dense vector/scalar multiplication.Via this type trait it is possible to evaluate the resulting expression type of a dense vector/scalar multiplication. Given the non-transpose dense vector type VT and the scalar type ST, the nested type Type corresponds to the resulting expression type. In case either VT is not a non-transpose dense vector type or ST is not a scalar type, the resulting Type is set to INVALID_TYPE
 Cblaze::DVecSerialExprTrait< VT >Evaluation of the expression type of a dense vector serial evaluation operation.Via this type trait it is possible to evaluate the resulting expression type of a dense vector serial evaluation operation. Given the non-transpose dense vector type VT, the nested type Type corresponds to the resulting expression type. In case either VT is not a non-transpose dense vector type, the resulting Type is set to INVALID_TYPE
 Cblaze::DVecSVecAddExprTrait< VT1, VT2 >Evaluation of the expression type of a dense vector/sparse vector addition.Via this type trait it is possible to evaluate the resulting expression type of a dense vector/sparse vector addition. Given the non-transpose dense vector type VT1 and the non-transpose sparse vector typeVT2, the nested type Type corresponds to the resulting expression type. In case either VT1 is not a non-transpose dense vector type or VT2 is not a non-transpose sparse vector type, the resulting Type is set to INVALID_TYPE
 Cblaze::DVecSVecCrossExprTrait< VT1, VT2 >Evaluation of the expression type of a dense vector/sparse vector cross product.Via this type trait it is possible to evaluate the resulting expression type of a dense vector/sparse vector cross product. Given the non-transpose dense vector type VT1 and the non-transpose sparse vector typeVT2, the nested type Type corresponds to the resulting expression type. In case either VT1 is not a non-transpose dense vector type or VT2 is not a non-transpose sparse vector type, the resulting Type is set to INVALID_TYPE
 Cblaze::DVecSVecMultExprTrait< VT1, VT2 >Evaluation of the expression type of a dense vector/sparse vector multiplication.Via this type trait it is possible to evaluate the resulting expression type of a dense vector/sparse vector multiplication. Given the non-transpose dense vector type VT1 and the non-transpose sparse vector typeVT2, the nested type Type corresponds to the resulting expression type. In case either VT1 is not a non-transpose dense vector type or VT2 is not a non-transpose sparse vector type, the resulting Type is set to INVALID_TYPE
 Cblaze::DVecSVecSubExprTrait< VT1, VT2 >Evaluation of the expression type of a dense vector/sparse vector subtraction.Via this type trait it is possible to evaluate the resulting expression type of a dense vector/sparse vector subtraction. Given the non-transpose dense vector type VT1 and the non-transpose sparse vector typeVT2, the nested type Type corresponds to the resulting expression type. In case either VT1 is not a non-transpose dense vector type or VT2 is not a non-transpose sparse vector type, the resulting Type is set to INVALID_TYPE
 Cblaze::DVecTDVecMultExprTrait< VT1, VT2 >Evaluation of the expression type of a dense vector/transpose dense vector multiplication.Via this type trait it is possible to evaluate the resulting expression type of a dense vector/transpose dense vector multiplication (outer product). Given the non-transpose dense vector type VT1 and the transpose dense vector type VT2, the nested type Type corresponds to the resulting expression type. In case either VT1 is not a non-transpose dense vector type or VT2 is not a transpose dense vector type, the resulting Type is set to INVALID_TYPE
 Cblaze::DVecTransExprTrait< VT >Evaluation of the expression type of a dense vector transpose operation.Via this type trait it is possible to evaluate the resulting expression type of a dense vector transpose operation. Given the non-transpose dense vector type VT, the nested type Type corresponds to the resulting expression type. In case either VT is not a non-transpose dense vector type, the resulting Type is set to INVALID_TYPE
 Cblaze::DVecTSVecMultExprTrait< VT1, VT2 >Evaluation of the expression type of a dense vector/transpose sparse vector multiplication.Via this type trait it is possible to evaluate the resulting expression type of a dense vector/transpose sparse vector multiplication (outer product). Given the non-transpose dense vector type VT1 and the transpose sparse vector type VT2, the nested type Type corresponds to the resulting expression type. In case either VT1 is not a non-transpose dense vector type or VT2 is not a transpose sparse vector type, the resulting Type is set to INVALID_TYPE
 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::EqualTo< T1, T2 >Compile time type value comparison.The EqualTo class templates evaluates whether the two given conditions T1 and T2 are equal to each other. In case T1::value is equal to T2::value, the value member enumeration is set to 1, otherwise it is set to 0
 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::ExpressionBase class for all expression templates.The Expression class is the base class for all expression templates. All classes, that represent a mathematical operation and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as expression template. Only in case a class is derived from the Expression base class, the IsExpression type trait recognizes the class as valid expression template
 Cblaze::Extent< T, N >Compile time check for the size of array bounds.Via this type trait it is possible to query at compile time for the size of a particular array extent. In case the given template argument is an array type with a rank greater than N, the value member enumeration is set to the number of elements of the N'th array dimension. In all other cases, and especially in case the N'th array dimension is incomplete, value is set to 0
 CFalseType
 Cblaze::MemoryPool< Type, Blocksize >::FreeObjectA single element of the free list of the memory pool
 Cblaze::HasCyclicDependency< T, TL, C >
 Cblaze::If< T1, T2, T3 >Compile time type selection.The If class template selects one of the two given types T2 and T3 depending on T1. In case T1::value evaluates to true, the member type definition Type is set to T2. In case T1::value evaluates to false, Type is set to T3
 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::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::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::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
 CIntrinsicTraitBase
 Cblaze::LCPA linear complementarity problem (LCP) data structure.The LCP class represent a linear complementarity problem of the form $ A \cdot x + b \leq 0 \quad\perp\quad x \geq 0 $
 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::LinearGrowth< Growth >Linear growth policy class.The LinearGrowth policy class implements a linear growth strategy. It can be customized for any purpose: the Growth template argument specifies the factor of the size growth
 Cblaze::logging::LogSectionLogging section for (non-)MPI-parallel environments.The LogSection class is an auxiliary helper class for all logging section macros. It is implemented as a wrapper around the Logger class and is responsible for the atomicity of the logging operations and for formatting any message that is written into the log file(s)
 Cblaze::LSEA linear system of equations (LSE) data structure.The LSE class represent a linear system of equations of the form $ A \cdot x + b = 0 $
 Cblaze::MathTrait< T1, T2 >Base template for the MathTrait class
 Cblaze::Matrix< typename, bool >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< MT, SO >
 Cblaze::MatrixAccessProxy< MT >Access proxy for sparse, $ M \times N $ matrices.The MatrixAccessProxy provides safe access to the elements of a non-const sparse matrices.
The proxied access to the elements of a sparse matrix is necessary since it may be possible that several insertion operations happen in the same statement. The following code illustrates this with two examples by means of the CompressedMatrix class:
 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::MixedLCPA mixed linear complementarity problem (MLCP) data structure.The LCP class represent a mixed linear complementarity problem of the form
 Cblaze::ModifiedBoxLCPA modified box linear complementarity problem (MBLCP) data structure.The ModifiedBoxLCP class represent a modified box linear complementarity problem (MBLCP) of the form
 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 >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 declared private and left undefined 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::Not< C >Compile time type negation.The Not class template negates the given compile time condition. In case the given condition would evaluate to true, the nested member enumeration is set to false and vice versa:
 Cblaze::NullSafe C++ NULL pointer implementation.This implementation offers a remedy for the use of the NULL pointer in C++. For this, the NULL macro is replaced by an instance of the Null class, which can only be assigned and compared with pointers and pointers-to-member. Therefore the use of NULL regains the type safety it lost in C++ due to the strict C++ type system.
The NULL pointer is used exactly as before:
 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::NumericElementType< T >Evaluation of the numeric element type of a given data type.Via this type trait it is possible to evaluate the numeric (fundamental or complex) element type at the heart of a given data type. Examples:
 Cblaze::OptimalGrowthOptimal growth policy class.The OptimalGrowth policy class implements the optimal growth strategy suggested by Andrew Koenig for the std::vector class (see Andrew Koenig's column in the September 1998 issue of JOOP (Journal of Object-Oriented Programming), or the Dr. Dobb's article 'C++ Made Easier: How Vectors Grow', 2001). It applies an exponential growth strategy using a factor of 1.5 and additionally ensures that the sizes returns are always multiples of four
 Cblaze::Or< T1, T2, T3, T4, T5 >Compile time logical or evaluation.The Or class template performs at compile time a logical or ('&&') evaluation of the up to five given compile time conditions:
 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::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::PtrIterator< Type >Implementation of an iterator for pointer vectors.The PtrIterator class follows the example of the random-access iterator classes of the STL. However, the focus of this iterator implementation is the use with (polymorphic) pointers. The implementation of the Blaze library eases the use of iterators over a range of pointers and improves the semantics on these pointers.
 Cblaze::PtrVector< T, D, G >Implementation of a vector for (polymorphic) pointers
 Cblaze::PtrVector< ManagedThread >
 Cblaze::Quaternion< typename >Efficient implementation of a quaternion.Quaternions are a superior way to deal with rotations and orientations. This quaternion consists of 4 statically allocated elements, where the first element represents the real part and the three other elements represent the three imaginary parts. The naming convention of the elements is as following:
 Cblaze::Rand< typename >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::Rank< T >Compile time check for array ranks.This type trait determines the rank of the given template argument. In case the given type is an array type, the nested value member enumeration is set to the number of dimensions of T. Otherwise value is set to 0
 Cblaze::AlignedAllocator< Type >::rebind< Type2 >Implementation of the AlignedAllocator rebind mechanism
 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 RemoveCV type trait removes any pointer modifiers from the given type T
 Cblaze::RemoveReference< T >Removal of reference modifiers.The RemoveCV type trait removes any reference modifiers from the given type T
 Cblaze::RemoveReference< LeftOperand >
 Cblaze::RemoveReference< Operand >
 Cblaze::RemoveReference< RightOperand >
 Cblaze::RemoveReference< Stream >
 Cblaze::RemoveVolatile< T >Removal of volatile-qualifiers.The RemoveVolatile type trait removes all top level 'volatile' qualifiers from the given type T
 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::SelectType< Select, T1, T2 >Compile time type selection.The SelectType class template selects one of the two given types T1 and T2 depending on the Select template argument. In case the Select compile time constant expression evaluates to true, the member type definition Type is set to T1. In case Select evaluates to false, Type is set to T2
 Cblaze::SelectType< IsExpression< MT >::value, const MT, const MT & >
 Cblaze::SelectType< IsExpression< MT >::value, MT, MT & >
 Cblaze::SelectType< IsExpression< MT1 >::value, const MT1, const MT1 & >
 Cblaze::SelectType< IsExpression< MT2 >::value, const MT2, const MT2 & >
 Cblaze::SelectType< IsExpression< VT >::value, const VT, const VT & >
 Cblaze::SelectType< IsExpression< VT >::value, VT, VT & >
 Cblaze::SelectType< IsExpression< VT1 >::value, const VT1, const VT1 & >
 Cblaze::SelectType< IsExpression< VT2 >::value, const VT2, const VT2 & >
 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::size_tSize type of the Blaze library
 Cblaze::SizeTrait< T1, T2 >Base template for the SizeTrait class.The SizeTrait class template evaluates the larger of the two given data types by use of the sizeof operator. SizeTrait defines the data types Large for the larger of the two given data types and Small for the smaller data type. In case both data types have the same size, the first given data type T1 is chosen as the large and T2 as the small data type
 Cblaze::SMatAbsExprTrait< MT >Evaluation of the expression type of a sparse matrix absolute value operation.Via this type trait it is possible to evaluate the resulting expression type of a sparse matrix absolute value operation. Given the row-major sparse matrix type MT, the nested type Type corresponds to the resulting expression type. In case either MT is not a row-major sparse matrix type, the resulting Type is set to INVALID_TYPE
 Cblaze::SMatDMatAddExprTrait< MT1, MT2 >Evaluation of the expression type of a sparse matrix/dense matrix addition.Via this type trait it is possible to evaluate the resulting expression type of a sparse matrix/dense matrix addition. Given the row-major sparse matrix type MT1 and the row-major dense matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a row-major sparse matrix type or MT2 is not a row-major dense matrix type, the resulting data type Type is set to INVALID_TYPE
 Cblaze::SMatDMatMultExprTrait< MT1, MT2 >Evaluation of the expression type of a sparse matrix/dense matrix multiplication.Via this type trait it is possible to evaluate the resulting expression type of a sparse matrix/dense matrix multiplication. Given the row-major sparse matrix type MT1 and the row-major dense matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a row-major sparse matrix type or MT2 is not a row-major dense matrix type, the resulting data type Type is set to INVALID_TYPE
 Cblaze::SMatDMatSubExprTrait< MT1, MT2 >Evaluation of the expression type of a sparse matrix/dense matrix subtraction.Via this type trait it is possible to evaluate the resulting expression type of a sparse matrix/dense matrix subtraction. Given the row-major sparse matrix type MT1 and the row-major dense matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a row-major sparse matrix type or MT2 is not a row-major dense matrix type, the resulting data type Type is set to INVALID_TYPE
 Cblaze::SMatDVecMultExprTrait< MT, VT >Evaluation of the expression type of a sparse matrix/dense vector multiplication.Via this type trait it is possible to evaluate the resulting expression type of a sparse matrix/dense vector multiplication. Given the row-major sparse matrix type MT and the non-transpose dense vector type VT, the nested type Type corresponds to the resulting expression type. In case either MT is not a row-major sparse matrix type or VT is not a non-transpose dense vector type, the resulting data type Type is set to INVALID_TYPE
 Cblaze::SMatEvalExprTrait< MT >Evaluation of the expression type of a sparse matrix evaluation operation.Via this type trait it is possible to evaluate the resulting expression type of a sparse matrix evaluation operation. Given the row-major sparse matrix type MT, the nested type Type corresponds to the resulting expression type. In case either MT is not a row-major sparse matrix type, the resulting Type is set to INVALID_TYPE
 Cblaze::SMatScalarDivExprTrait< MT, ST >Evaluation of the expression type of a sparse matrix/scalar division.Via this type trait it is possible to evaluate the resulting expression type of a sparse matrix/scalar division. Given the row-major sparse matrix type MT and the scalar type ST, the nested type Type corresponds to the resulting expression type. In case either MT is not a row-major sparse matrix type or ST is not a scalar type, the resulting Type is set to INVALID_TYPE
 Cblaze::SMatScalarMultExprTrait< MT, ST >Evaluation of the expression type of a sparse matrix/scalar multiplication.Via this type trait it is possible to evaluate the resulting expression type of a sparse matrix/scalar multiplication. Given the row-major sparse matrix type MT and the scalar type ST, the nested type Type corresponds to the resulting expression type. In case either MT is not a row-major sparse matrix type or ST is not a scalar type, the resulting Type is set to INVALID_TYPE
 Cblaze::SMatSerialExprTrait< MT >Evaluation of the expression type of a sparse matrix serial evaluation operation.Via this type trait it is possible to evaluate the resulting expression type of a sparse matrix serial evaluation operation. Given the row-major sparse matrix type MT, the nested type Type corresponds to the resulting expression type. In case either MT is not a row-major sparse matrix type, the resulting Type is set to INVALID_TYPE
 Cblaze::SMatSMatAddExprTrait< MT1, MT2 >Evaluation of the expression type of a sparse matrix/sparse matrix addition.Via this type trait it is possible to evaluate the resulting expression type of a sparse matrix/sparse matrix addition. Given the two row-major sparse matrix types MT1 and MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 or MT2 is not a row-major sparse matrix, the resulting data type Type is set to INVALID_TYPE
 Cblaze::SMatSMatMultExprTrait< MT1, MT2 >Evaluation of the expression type of a sparse matrix/sparse matrix multiplication.Via this type trait it is possible to evaluate the resulting expression type of a sparse matrix/sparse matrix multiplication. Given the two row-major sparse matrix types MT1 and MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 or MT2 is not a row-major sparse matrix, the resulting data type Type is set to INVALID_TYPE
 Cblaze::SMatSMatSubExprTrait< MT1, MT2 >Evaluation of the expression type of a sparse matrix/sparse matrix subtraction.Via this type trait it is possible to evaluate the resulting expression type of a sparse matrix/sparse matrix subtraction. Given the two row-major sparse matrix types MT1 and MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 or MT2 is not a row-major sparse matrix, the resulting data type Type is set to INVALID_TYPE
 Cblaze::SMatSVecMultExprTrait< MT, VT >Evaluation of the expression type of a sparse matrix/sparse vector multiplication.Via this type trait it is possible to evaluate the resulting expression type of a sparse matrix/sparse vector multiplication. Given the row-major sparse matrix type MT and the non-transpose sparse vector type VT, the nested type Type corresponds to the resulting expression type. In case either MT is not a row-major sparse matrix type or VT is not a non-transpose sparse vector type, the resulting data type Type is set to INVALID_TYPE
 Cblaze::SMatTDMatAddExprTrait< MT1, MT2 >Evaluation of the expression type of a sparse matrix/transpose dense matrix addition.Via this type trait it is possible to evaluate the resulting expression type of a sparse matrix/transpose dense matrix addition. Given the row-major sparse matrix type MT1 and the column-major dense matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a row-major sparse matrix type or MT2 is not a column-major dense matrix type, the resulting data type Type is set to INVALID_TYPE
 Cblaze::SMatTDMatMultExprTrait< MT1, MT2 >Evaluation of the expression type of a sparse matrix/transpose dense matrix multiplication.Via this type trait it is possible to evaluate the resulting expression type of a sparse matrix/transpose dense matrix multiplication. Given the row-major sparse matrix type MT1 and the column-major dense matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a row-major sparse matrix type or MT2 is not a column-major dense matrix type, the resulting data type Type is set to INVALID_TYPE
 Cblaze::SMatTDMatSubExprTrait< MT1, MT2 >Evaluation of the expression type of a sparse matrix/transpose dense matrix subtraction.Via this type trait it is possible to evaluate the resulting expression type of a sparse matrix/transpose dense matrix subtraction. Given the row-major sparse matrix type MT1 and the column-major dense matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a row-major sparse matrix type or MT2 is not a column-major dense matrix type, the resulting data type Type is set to INVALID_TYPE
 Cblaze::SMatTransExprTrait< MT >Evaluation of the expression type of a sparse matrix transpose operation.Via this type trait it is possible to evaluate the resulting expression type of a sparse matrix transpose operation. Given the row-major sparse matrix type MT, the nested type Type corresponds to the resulting expression type. In case either MT is not a row-major sparse matrix type, the resulting Type is set to INVALID_TYPE
 Cblaze::SMatTSMatAddExprTrait< MT1, MT2 >Evaluation of the expression type of a sparse matrix/transpose sparse matrix addition.Via this type trait it is possible to evaluate the resulting expression type of a sparse matrix/transpose sparse matrix addition. Given the row-major sparse matrix type MT1 and the column-major sparse matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a row-major sparse matrix type or MT2 is not a column-major sparse matrix type, the resulting data type Type is set to INVALID_TYPE
 Cblaze::SMatTSMatMultExprTrait< MT1, MT2 >Evaluation of the expression type of a sparse matrix/transpose sparse matrix multiplication.Via this type trait it is possible to evaluate the resulting expression type of a sparse matrix/transpose sparse matrix multiplication. Given the row-major sparse matrix type MT1 and the column-major sparse matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a row-major sparse matrix type or MT2 is not a column-major sparse matrix type, the resulting data type Type is set to INVALID_TYPE
 Cblaze::SMatTSMatSubExprTrait< MT1, MT2 >Evaluation of the expression type of a sparse matrix/transpose sparse matrix subtraction.Via this type trait it is possible to evaluate the resulting expression type of a sparse matrix/transpose sparse matrix subtraction. Given the row-major sparse matrix type MT1 and the column-major sparse matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a row-major sparse matrix type or MT2 is not a column-major sparse matrix type, the resulting data type Type is set to INVALID_TYPE
 Cblaze::SolverBase class for all solver classes.TODO: description of the Solver class TODO: description of its functionality
 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::sse_cdouble_tIntrinsic type for 64-bit double precision complex values
 Cblaze::sse_cfloat_tIntrinsic type for 32-bit single precision complex values
 Cblaze::sse_double_tIntrinsic type for 64-bit double precision floating point data values
 Cblaze::sse_float_tIntrinsic type for 32-bit single precision floating point data values
 Cblaze::sse_int16_tIntrinsic type for 16-bit integral data values
 Cblaze::sse_int32_tIntrinsic type for 32-bit integral data values
 Cblaze::sse_int64_tIntrinsic type for 64-bit integral data values
 Cblaze::sse_int8_tIntrinsic type for 8-bit integral data values
 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::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::DenseSubmatrix< MT, AF, SO >::SubmatrixIterator< IteratorType >Iterator over the elements of the sparse submatrix
 Cblaze::SparseSubmatrix< typename, bool, bool >::SubmatrixIterator< MatrixType, IteratorType >Iterator over the elements of the sparse submatrix
 Cblaze::SubmatrixTrait< MT >Base template for the SubmatrixTrait class
 Cblaze::SubTrait< T1, T2 >Base template for the SubTrait class
 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::DenseSubvector< VT, AF, TF >::SubvectorIterator< IteratorType >Iterator over the elements of the sparse subvector
 Cblaze::SparseSubvector< typename, bool, bool >::SubvectorIterator< VectorType, IteratorType >Iterator over the elements of the sparse subvector
 Cblaze::SubvectorTrait< VT >Base template for the SubvectorTrait class
 Cblaze::SVecAbsExprTrait< VT >Evaluation of the expression type of a sparse vector absolute value operation.Via this type trait it is possible to evaluate the resulting expression type of a sparse vector absolute value operation. Given the non-transpose sparse vector type VT, the nested type Type corresponds to the resulting expression type. In case either VT is not a non-transpose sparse vector type, the resulting Type is set to INVALID_TYPE
 Cblaze::SVecDVecAddExprTrait< VT1, VT2 >Evaluation of the expression type of a sparse vector/dense vector addition.Via this type trait it is possible to evaluate the resulting expression type of a sparse vector/dense vector addition. Given the non-transpose sparse vector type VT1 and the non-transpose dense vector typeVT2, the nested type Type corresponds to the resulting expression type. In case either VT1 is not a non-transpose sparse vector type or VT2 is not a non-transpose dense vector type, the resulting Type is set to INVALID_TYPE
 Cblaze::SVecDVecCrossExprTrait< VT1, VT2 >Evaluation of the expression type of a sparse vector/dense vector cross product.Via this type trait it is possible to evaluate the resulting expression type of a sparse vector/dense vector cross product. Given the non-transpose sparse vector type VT1 and the non-transpose dense vector typeVT2, the nested type Type corresponds to the resulting expression type. In case either VT1 is not a non-transpose sparse vector type or VT2 is not a non-transpose dense vector type, the resulting Type is set to INVALID_TYPE
 Cblaze::SVecDVecMultExprTrait< VT1, VT2 >Evaluation of the expression type of a sparse vector/dense vector multiplication.Via this type trait it is possible to evaluate the resulting expression type of a sparse vector/dense vector multiplication. Given the non-transpose sparse vector type VT1 and the non-transpose dense vector typeVT2, the nested type Type corresponds to the resulting expression type. In case either VT1 is not a non-transpose sparse vector type or VT2 is not a non-transpose dense vector type, the resulting Type is set to INVALID_TYPE
 Cblaze::SVecDVecSubExprTrait< VT1, VT2 >Evaluation of the expression type of a sparse vector/dense vector subtraction.Via this type trait it is possible to evaluate the resulting expression type of a sparse vector/dense vector subtraction. Given the non-transpose sparse vector type VT1 and the non-transpose dense vector typeVT2, the nested type Type corresponds to the resulting expression type. In case either VT1 is not a non-transpose sparse vector type or VT2 is not a non-transpose dense vector type, the resulting Type is set to INVALID_TYPE
 Cblaze::SVecEvalExprTrait< VT >Evaluation of the expression type of a sparse vector evaluation operation.Via this type trait it is possible to evaluate the resulting expression type of a sparse vector evaluation operation. Given the non-transpose sparse vector type VT, the nested type Type corresponds to the resulting expression type. In case either VT is not a non-transpose sparse vector type, the resulting Type is set to INVALID_TYPE
 Cblaze::SVecScalarDivExprTrait< VT, ST >Evaluation of the expression type of a sparse vector/scalar division.Via this type trait it is possible to evaluate the resulting expression type of a sparse vector/scalar division. Given the non-transpose sparse vector type VT and the scalar type ST, the nested type Type corresponds to the resulting expression type. In case either VT is not a non-transpose sparse vector type or ST is not a scalar type, the resulting Type is set to INVALID_TYPE
 Cblaze::SVecScalarMultExprTrait< VT, ST >Evaluation of the expression type of a sparse vector/scalar multiplication.Via this type trait it is possible to evaluate the resulting expression type of a sparse vector/scalar multiplication. Given the non-transpose sparse vector type VT and the scalar type ST, the nested type Type corresponds to the resulting expression type. In case either VT is not a non-transpose sparse vector type or ST is not a scalar type, the resulting Type is set to INVALID_TYPE
 Cblaze::SVecSerialExprTrait< VT >Evaluation of the expression type of a sparse vector serial evaluation operation.Via this type trait it is possible to evaluate the resulting expression type of a sparse vector serial evaluation operation. Given the non-transpose sparse vector type VT, the nested type Type corresponds to the resulting expression type. In case either VT is not a non-transpose sparse vector type, the resulting Type is set to INVALID_TYPE
 Cblaze::SVecSVecAddExprTrait< VT1, VT2 >Evaluation of the expression type of a sparse vector/sparse vector addition.Via this type trait it is possible to evaluate the resulting expression type of a sparse vector/sparse vector addition. Given the two non-transpose sparse vector types VT1 and VT2, the nested type Type corresponds to the resulting expression type. In case either VT1 or VT2 is not a non-transpose sparse vector type, the resulting Type is set to INVALID_TYPE
 Cblaze::SVecSVecCrossExprTrait< VT1, VT2 >Evaluation of the expression type of a sparse vector/sparse vector cross product.Via this type trait it is possible to evaluate the resulting expression type of a sparse vector/sparse vector cross product. Given the two non-transpose sparse vector types VT1 and VT2, the nested type Type corresponds to the resulting expression type. In case either VT1 or VT2 is not a non-transpose sparse vector type, the resulting Type is set to INVALID_TYPE
 Cblaze::SVecSVecMultExprTrait< VT1, VT2 >Evaluation of the expression type of a sparse vector/sparse vector multiplication.Via this type trait it is possible to evaluate the resulting expression type of a sparse vector/sparse vector multiplication. Given the two non-transpose sparse vector types VT1 and VT2, the nested type Type corresponds to the resulting expression type. In case either VT1 or VT2 is not a non-transpose sparse vector type, the resulting Type is set to INVALID_TYPE
 Cblaze::SVecSVecSubExprTrait< VT1, VT2 >Evaluation of the expression type of a sparse vector/sparse vector subtraction.Via this type trait it is possible to evaluate the resulting expression type of a sparse vector/sparse vector subtraction. Given the two non-transpose sparse vector types VT1 and VT2, the nested type Type corresponds to the resulting expression type. In case either VT1 or VT2 is not a non-transpose sparse vector type, the resulting Type is set to INVALID_TYPE
 Cblaze::SVecTDVecMultExprTrait< VT1, VT2 >Evaluation of the expression type of a sparse vector/transpose dense vector multiplication.Via this type trait it is possible to evaluate the resulting expression type of a sparse vector/transpose dense vector multiplication (outer product). Given the non-transpose sparse vector type VT1 and the transpose dense vector type VT2, the nested type Type corresponds to the resulting expression type. In case either VT1 is not a non-transpose sparse vector type or VT2 is not a transpose dense vector type, the resulting Type is set to INVALID_TYPE
 Cblaze::SVecTransExprTrait< VT >Evaluation of the expression type of a sparse vector transpose operation.Via this type trait it is possible to evaluate the resulting expression type of a sparse vector transpose operation. Given the non-transpose sparse vector type VT, the nested type Type corresponds to the resulting expression type. In case either VT is not a non-transpose sparse vector type, the resulting Type is set to INVALID_TYPE
 Cblaze::SVecTSVecMultExprTrait< VT1, VT2 >Evaluation of the expression type of a sparse vector/transpose sparse vector multiplication.Via this type trait it is possible to evaluate the resulting expression type of a sparse vector/transpose sparse vector multiplication (outer product). Given the non-transpose sparse vector type VT1 and the transpose sparse vector type VT2, the nested type Type corresponds to the resulting expression type. In case either VT1 is not a non-transpose sparse vector type or VT2 is not a transpose sparse vector type, the resulting Type is set to INVALID_TYPE
 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::TDMatAbsExprTrait< MT >Evaluation of the expression type of a dense matrix absolute value operation.Via this type trait it is possible to evaluate the resulting expression type of a dense matrix absolute value operation. Given the column-major dense matrix type MT, the nested type Type corresponds to the resulting expression type. In case either MT is not a column-major dense matrix type, the resulting Type is set to INVALID_TYPE
 Cblaze::TDMatDMatAddExprTrait< MT1, MT2 >Evaluation of the expression type of a transpose dense matrix/dense matrix addition.Via this type trait it is possible to evaluate the resulting expression type of a transpose dense matrix/dense matrix addition. Given the column-major dense matrix type MT1 and the row-major dense matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a column-major dense matrix type or MT2 is not a row-major dense matrix type, the resulting data type Type is set to INVALID_TYPE
 Cblaze::TDMatDMatMultExprTrait< MT1, MT2 >Evaluation of the expression type of a transpose dense matrix/dense matrix multiplication.Via this type trait it is possible to evaluate the resulting expression type of a transpose dense matrix/dense matrix multiplication. Given the column-major dense matrix type MT1 and the row-major dense matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a column-major dense matrix type or MT2 is not a row-major dense matrix type, the resulting data type Type is set to INVALID_TYPE
 Cblaze::TDMatDMatSubExprTrait< MT1, MT2 >Evaluation of the expression type of a transpose dense matrix/dense matrix subtraction.Via this type trait it is possible to evaluate the resulting expression type of a transpose dense matrix/dense matrix subtraction. Given the column-major dense matrix type MT1 and the row-major dense matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a column-major dense matrix type or MT2 is not a row-major dense matrix type, the resulting data type Type is set to INVALID_TYPE
 Cblaze::TDMatDVecMultExprTrait< MT, VT >Evaluation of the expression type of a transpose dense matrix/dense vector multiplication.Via this type trait it is possible to evaluate the resulting expression type of a transpose dense matrix/dense vector multiplication. Given the column-major dense matrix type MT and the non-transpose dense vector type VT, the nested type Type corresponds to the resulting expression type. In case either MT is not a column-major dense matrix type or VT is not a non-transpose dense vector type, the resulting data type Type is set to INVALID_TYPE
 Cblaze::TDMatEvalExprTrait< MT >Evaluation of the expression type of a dense matrix evaluation operation.Via this type trait it is possible to evaluate the resulting expression type of a dense matrix evaluation operation. Given the column-major dense matrix type MT, the nested type Type corresponds to the resulting expression type. In case either MT is not a column-major dense matrix type, the resulting Type is set to INVALID_TYPE
 Cblaze::TDMatScalarDivExprTrait< MT, ST >Evaluation of the expression type of a transpose dense matrix/scalar division.Via this type trait it is possible to evaluate the resulting expression type of a transpose dense matrix/scalar division. Given the column-major dense matrix type MT and the scalar type ST, the nested type Type corresponds to the resulting expression type. In case either MT is not a column-major dense matrix type or ST is not a scalar type, the resulting Type is set to INVALID_TYPE
 Cblaze::TDMatScalarMultExprTrait< MT, ST >Evaluation of the expression type of a transpose dense matrix/scalar multiplication.Via this type trait it is possible to evaluate the resulting expression type of a transpose dense matrix/scalar multiplication. Given the column-major dense matrix type MT and the scalar type ST, the nested type Type corresponds to the resulting expression type. In case either MT is not a column-major dense matrix type or ST is not a scalar type, the resulting Type is set to INVALID_TYPE
 Cblaze::TDMatSerialExprTrait< MT >Evaluation of the expression type of a dense matrix serial evaluation operation.Via this type trait it is possible to evaluate the resulting expression type of a dense matrix serial evaluation operation. Given the column-major dense matrix type MT, the nested type Type corresponds to the resulting expression type. In case either MT is not a column-major dense matrix type, the resulting Type is set to INVALID_TYPE
 Cblaze::TDMatSMatAddExprTrait< MT1, MT2 >Evaluation of the expression type of a transpose dense matrix/sparse matrix addition.Via this type trait it is possible to evaluate the resulting expression type of a transpose dense matrix/sparse matrix addition. Given the column-major dense matrix type MT1 and the row-major sparse matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a column-major dense matrix type or MT2 is not a row-major sparse matrix type, the resulting data type Type is set to INVALID_TYPE
 Cblaze::TDMatSMatMultExprTrait< MT1, MT2 >Evaluation of the expression type of a transpose dense matrix/sparse matrix multiplication.Via this type trait it is possible to evaluate the resulting expression type of a transpose dense matrix/sparse matrix multiplication. Given the column-major dense matrix type MT1 and the row-major sparse matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a column-major dense matrix type or MT2 is not a row-major sparse matrix type, the resulting data type Type is set to INVALID_TYPE
 Cblaze::TDMatSMatSubExprTrait< MT1, MT2 >Evaluation of the expression type of a transpose dense matrix/sparse matrix subtraction.Via this type trait it is possible to evaluate the resulting expression type of a transpose dense matrix/sparse matrix subtraction. Given the column-major dense matrix type MT1 and the row-major sparse matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a column-major dense matrix type or MT2 is not a row-major sparse matrix type, the resulting data type Type is set to INVALID_TYPE
 Cblaze::TDMatSVecMultExprTrait< MT, VT >Evaluation of the expression type of a transpose dense matrix/sparse vector multiplication.Via this type trait it is possible to evaluate the resulting expression type of a transpose dense matrix/sparse vector multiplication. Given the column-major dense matrix type MT and the non-transpose sparse vector type VT, the nested type Type corresponds to the resulting expression type. In case either MT is not a column-major dense matrix type or VT is not a non-transpose sparse vector type, the resulting data type Type is set to INVALID_TYPE
 Cblaze::TDMatTDMatAddExprTrait< MT1, MT2 >Evaluation of the expression type of a transpose dense matrix/transpose dense matrix addition.Via this type trait it is possible to evaluate the resulting expression type of a transpose dense matrix/transpose dense matrix addition. Given the two column-major dense matrix types MT1 and MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 or MT2 is not a column-major dense matrix, the resulting data type Type is set to INVALID_TYPE
 Cblaze::TDMatTDMatMultExprTrait< MT1, MT2 >Evaluation of the expression type of a transpose dense matrix/transpose dense matrix multiplication.Via this type trait it is possible to evaluate the resulting expression type of a transpose dense matrix/transpose dense matrix multiplication. Given the two column-major dense matrix types MT1 and MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 or MT2 is not a column-major dense matrix, the resulting data type Type is set to INVALID_TYPE
 Cblaze::TDMatTDMatSubExprTrait< MT1, MT2 >Evaluation of the expression type of a transpose dense matrix/transpose dense matrix subtraction.Via this type trait it is possible to evaluate the resulting expression type of a transpose dense matrix/transpose dense matrix subtraction. Given the two column-major dense matrix types MT1 and MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 or MT2 is not a column-major dense matrix, the resulting data type Type is set to INVALID_TYPE
 Cblaze::TDMatTransExprTrait< MT >Evaluation of the expression type of a dense matrix transpose operation.Via this type trait it is possible to evaluate the resulting expression type of a dense matrix transpose operation. Given the column-major dense matrix type MT, the nested type Type corresponds to the resulting expression type. In case either MT is not a column-major dense matrix type, the resulting Type is set to INVALID_TYPE
 Cblaze::TDMatTSMatAddExprTrait< MT1, MT2 >Evaluation of the expression type of a transpose dense matrix/transpose sparse matrix addition.Via this type trait it is possible to evaluate the resulting expression type of a transpose dense matrix/transpose sparse matrix addition. Given the column-major dense matrix type MT1 and the column-major sparse matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a column-major dense matrix type or MT2 is not a column-major sparse matrix type, the resulting data type Type is set to INVALID_TYPE
 Cblaze::TDMatTSMatMultExprTrait< MT1, MT2 >Evaluation of the expression type of a transpose dense matrix/transpose sparse matrix multiplication.Via this type trait it is possible to evaluate the resulting expression type of a transpose dense matrix/transpose sparse matrix multiplication. Given the column-major dense matrix type MT1 and the column-major sparse matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a column-major dense matrix type or MT2 is not a column-major sparse matrix type, the resulting data type Type is set to INVALID_TYPE
 Cblaze::TDMatTSMatSubExprTrait< MT1, MT2 >Evaluation of the expression type of a transpose dense matrix/transpose sparse matrix subtraction.Via this type trait it is possible to evaluate the resulting expression type of a transpose dense matrix/transpose sparse matrix subtraction. Given the column-major dense matrix type MT1 and the column-major sparse matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a column-major dense matrix type or MT2 is not a column-major sparse matrix type, the resulting data type Type is set to INVALID_TYPE
 Cblaze::TDVecAbsExprTrait< VT >Evaluation of the expression type of a dense vector absolute value operation.Via this type trait it is possible to evaluate the resulting expression type of a dense vector absolute value operation. Given the transpose dense vector type VT, the nested type Type corresponds to the resulting expression type. In case either VT is not a transpose dense vector type, the resulting Type is set to INVALID_TYPE
 Cblaze::TDVecDMatMultExprTrait< VT, MT >Evaluation of the expression type of a dense vector/dense matrix multiplication.Via this type trait it is possible to evaluate the resulting expression type of a dense vector/dense matrix multiplication. Given the transpose dense vector type VT and the row-major dense matrix type MT, the nested type Type corresponds to the resulting expression type. In case either VT is not a transpose dense vector type or MT is not a row-major dense matrix type, the resulting data type Type is set to INVALID_TYPE
 Cblaze::TDVecDVecMultExprTrait< VT1, VT2 >Evaluation of the expression type of a transpose dense vector/dense vector multiplication.Via this type trait it is possible to evaluate the resulting expression type of a transpose dense vector/dense vector multiplication (inner product). Given the transpose dense vector type VT1 and the non-transpose dense vector type VT2, the nested type Type corresponds to the resulting expression type. In case either VT1 is not a transpose dense vector type or VT2 is not a non-transpose dense vector type, the resulting Type is set to INVALID_TYPE
 Cblaze::TDVecEvalExprTrait< VT >Evaluation of the expression type of a dense vector evaluation operation.Via this type trait it is possible to evaluate the resulting expression type of a dense vector evaluation operation. Given the transpose dense vector type VT, the nested type Type corresponds to the resulting expression type. In case either VT is not a transpose dense vector type, the resulting Type is set to INVALID_TYPE
 Cblaze::TDVecScalarDivExprTrait< VT, ST >Evaluation of the expression type of a transpose dense vector/scalar division.Via this type trait it is possible to evaluate the resulting expression type of a transpose dense vector/scalar division. Given the transpose dense vector type VT and the scalar type ST, the nested type Type corresponds to the resulting expression type. In case either VT is not a transpose dense vector type or ST is not a scalar type, the resulting Type is set to INVALID_TYPE
 Cblaze::TDVecScalarMultExprTrait< VT, ST >Evaluation of the expression type of a transpose dense vector/scalar multiplication.Via this type trait it is possible to evaluate the resulting expression type of a transpose dense vector/scalar multiplication. Given the transpose dense vector type VT and the scalar type ST, the nested type Type corresponds to the resulting expression type. In case either VT is not a transpose dense vector type or ST is not a scalar type, the resulting Type is set to INVALID_TYPE
 Cblaze::TDVecSerialExprTrait< VT >Evaluation of the expression type of a dense vector serial evaluation operation.Via this type trait it is possible to evaluate the resulting expression type of a dense vector serial evaluation operation. Given the transpose dense vector type VT, the nested type Type corresponds to the resulting expression type. In case either VT is not a transpose dense vector type, the resulting Type is set to INVALID_TYPE
 Cblaze::TDVecSMatMultExprTrait< VT, MT >Evaluation of the expression type of a dense vector/sparse matrix multiplication.Via this type trait it is possible to evaluate the resulting expression type of a dense vector/sparse matrix multiplication. Given the transpose dense vector type VT and the row-major sparse matrix type MT, the nested type Type corresponds to the resulting expression type. In case either VT is not a transpose dense vector type or MT is not a row-major sparse matrix type, the resulting data type Type is set to INVALID_TYPE
 Cblaze::TDVecSVecMultExprTrait< VT1, VT2 >Evaluation of the expression type of a transpose dense vector/sparse vector multiplication.Via this type trait it is possible to evaluate the resulting expression type of a transpose dense vector/sparse vector multiplication (inner product). Given the transpose dense vector type VT1 and the non-transpose sparse vector type VT2, the nested type Type corresponds to the resulting expression type. In case either VT1 is not a transpose dense vector type or VT2 is not a non-transpose sparse vector type, the resulting Type is set to INVALID_TYPE
 Cblaze::TDVecTDMatMultExprTrait< VT, MT >Evaluation of the expression type of a dense vector/transpose dense matrix multiplication.Via this type trait it is possible to evaluate the resulting expression type of a dense vector/transpose dense matrix multiplication. Given the transpose dense vector type VT and the column-major dense matrix type MT, the nested type Type corresponds to the resulting expression type. In case either VT is not a transpose dense vector type or MT is not a column-major dense matrix type, the resulting data type Type is set to INVALID_TYPE
 Cblaze::TDVecTDVecAddExprTrait< VT1, VT2 >Evaluation of the expression type of a transpose dense vector/transpose dense vector addition.Via this type trait it is possible to evaluate the resulting expression type of a transpose dense vector/transpose dense vector addition. Given the two transpose dense vector types VT1 and VT2, the nested type Type corresponds to the resulting expression type. In case either VT1 or VT2 is not a transpose dense vector type, the resulting Type is set to INVALID_TYPE
 Cblaze::TDVecTDVecMultExprTrait< VT1, VT2 >Evaluation of the expression type of a transpose dense vector/transpose dense vector multiplication.Via this type trait it is possible to evaluate the resulting expression type of a transpose dense vector/transpose dense vector multiplication. Given the two transpose dense vector types VT1 and VT2, the nested type Type corresponds to the resulting expression type. In case either VT1 or VT2 is not a transpose dense vector type, the resulting Type is set to INVALID_TYPE
 Cblaze::TDVecTDVecSubExprTrait< VT1, VT2 >Evaluation of the expression type of a transpose dense vector/transpose dense vector subtraction.Via this type trait it is possible to evaluate the resulting expression type of a transpose dense vector/transpose dense vector subtraction. Given the two transpose dense vector types VT1 and VT2, the nested type Type corresponds to the resulting expression type. In case either VT1 or VT2 is not a transpose dense vector type, the resulting Type is set to INVALID_TYPE
 Cblaze::TDVecTransExprTrait< VT >Evaluation of the expression type of a dense vector transpose operation.Via this type trait it is possible to evaluate the resulting expression type of a dense vector transpose operation. Given the transpose dense vector type VT, the nested type Type corresponds to the resulting expression type. In case either VT is not a transpose dense vector type, the resulting Type is set to INVALID_TYPE
 Cblaze::TDVecTSMatMultExprTrait< VT, MT >Evaluation of the expression type of a dense vector/transpose sparse matrix multiplication.Via this type trait it is possible to evaluate the resulting expression type of a dense vector/transpose sparse matrix multiplication. Given the transpose dense vector type VT and the column-major sparse matrix type MT, the nested type Type corresponds to the resulting expression type. In case either VT is not a transpose dense vector type or MT is not a column-major sparse matrix type, the resulting data type Type is set to INVALID_TYPE
 Cblaze::TDVecTSVecAddExprTrait< VT1, VT2 >Evaluation of the expression type of a transpose dense vector/transpose sparse vector addition.Via this type trait it is possible to evaluate the resulting expression type of a transpose dense vector/transpose sparse vector addition. Given the transpose dense vector type VT1 and the transpose sparse vector type VT2, the nested type Type corresponds to the resulting expression type. In case either VT1 is not a transpose dense vector type or VT2 is not a transpose sparse vector type, the resulting Type is set to INVALID_TYPE
 Cblaze::TDVecTSVecMultExprTrait< VT1, VT2 >Evaluation of the expression type of a transpose dense vector/transpose sparse vector multiplication.Via this type trait it is possible to evaluate the resulting expression type of a transpose dense vector/transpose sparse vector multiplication. Given the transpose dense vector type VT1 and the transpose sparse vector type VT2, the nested type Type corresponds to the resulting expression type. In case either VT1 is not a transpose dense vector type or VT2 is not a transpose sparse vector type, the resulting Type is set to INVALID_TYPE
 Cblaze::TDVecTSVecSubExprTrait< VT1, VT2 >Evaluation of the expression type of a transpose dense vector/transpose sparse vector subtraction.Via this type trait it is possible to evaluate the resulting expression type of a transpose dense vector/transpose sparse vector subtraction. Given the transpose dense vector type VT1 and the transpose sparse vector type VT2, the nested type Type corresponds to the resulting expression type. In case either VT1 is not a transpose dense vector type or VT2 is not a transpose sparse vector type, the resulting Type is set to INVALID_TYPE
 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::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::TSMatAbsExprTrait< MT >Evaluation of the expression type of a sparse matrix absolute value operation.Via this type trait it is possible to evaluate the resulting expression type of a sparse matrix absolute value operation. Given the column-major sparse matrix type MT, the nested type Type corresponds to the resulting expression type. In case either MT is not a column-major sparse matrix type, the resulting Type is set to INVALID_TYPE
 Cblaze::TSMatDMatAddExprTrait< MT1, MT2 >Evaluation of the expression type of a transpose sparse matrix/dense matrix addition.Via this type trait it is possible to evaluate the resulting expression type of a transpose sparse matrix/dense matrix addition. Given the column-major sparse matrix type MT1 and the row-major dense matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a column-major sparse matrix type or MT2 is not a row-major dense matrix type, the resulting data type Type is set to INVALID_TYPE
 Cblaze::TSMatDMatMultExprTrait< MT1, MT2 >Evaluation of the expression type of a transpose sparse matrix/dense matrix multiplication.Via this type trait it is possible to evaluate the resulting expression type of a transpose sparse matrix/dense matrix multiplication. Given the column-major sparse matrix type MT1 and the row-major dense matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a column-major sparse matrix type or MT2 is not a row-major dense matrix type, the resulting data type Type is set to INVALID_TYPE
 Cblaze::TSMatDMatSubExprTrait< MT1, MT2 >Evaluation of the expression type of a transpose sparse matrix/dense matrix subtraction.Via this type trait it is possible to evaluate the resulting expression type of a transpose sparse matrix/dense matrix subtraction. Given the column-major sparse matrix type MT1 and the row-major dense matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a column-major sparse matrix type or MT2 is not a row-major dense matrix type, the resulting data type Type is set to INVALID_TYPE
 Cblaze::TSMatDVecMultExprTrait< MT, VT >Evaluation of the expression type of a transpose sparse matrix/dense vector multiplication.Via this type trait it is possible to evaluate the resulting expression type of a transpose sparse matrix/dense vector multiplication. Given the column-major sparse matrix type MT and the non-transpose dense vector type VT, the nested type Type corresponds to the resulting expression type. In case either MT is not a column-major sparse matrix type or VT is not a non-transpose dense vector type, the resulting data type Type is set to INVALID_TYPE
 Cblaze::TSMatEvalExprTrait< MT >Evaluation of the expression type of a sparse matrix evaluation operation.Via this type trait it is possible to evaluate the resulting expression type of a sparse matrix evaluation operation. Given the column-major sparse matrix type MT, the nested type Type corresponds to the resulting expression type. In case either MT is not a column-major sparse matrix type, the resulting Type is set to INVALID_TYPE
 Cblaze::TSMatScalarDivExprTrait< MT, ST >Evaluation of the expression type of a transpose sparse matrix/scalar division.Via this type trait it is possible to evaluate the resulting expression type of a transpose sparse matrix/scalar division. Given the column-major sparse matrix type MT and the scalar type ST, the nested type Type corresponds to the resulting expression type. In case either MT is not a column-major sparse matrix type or ST is not a scalar type, the resulting Type is set to INVALID_TYPE
 Cblaze::TSMatScalarMultExprTrait< MT, ST >Evaluation of the expression type of a transpose sparse matrix/scalar multiplication.Via this type trait it is possible to evaluate the resulting expression type of a transpose sparse matrix/scalar multiplication. Given the column-major sparse matrix type MT and the scalar type ST, the nested type Type corresponds to the resulting expression type. In case either MT is not a column-major sparse matrix type or ST is not a scalar type, the resulting Type is set to INVALID_TYPE
 Cblaze::TSMatSerialExprTrait< MT >Evaluation of the expression type of a sparse matrix serial evaluation operation.Via this type trait it is possible to evaluate the resulting expression type of a sparse matrix serial evaluation operation. Given the column-major sparse matrix type MT, the nested type Type corresponds to the resulting expression type. In case either MT is not a column-major sparse matrix type, the resulting Type is set to INVALID_TYPE
 Cblaze::TSMatSMatAddExprTrait< MT1, MT2 >Evaluation of the expression type of a transpose sparse matrix/sparse matrix addition.Via this type trait it is possible to evaluate the resulting expression type of a transpose sparse matrix/sparse matrix addition. Given the column-major sparse matrix type MT1 and the row-major sparse matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a column-major sparse matrix type or MT2 is not a row-major sparse matrix type, the resulting data type Type is set to INVALID_TYPE
 Cblaze::TSMatSMatMultExprTrait< MT1, MT2 >Evaluation of the expression type of a transpose sparse matrix/sparse matrix multiplication.Via this type trait it is possible to evaluate the resulting expression type of a transpose sparse matrix/sparse matrix multiplication. Given the column-major sparse matrix type MT1 and the row-major sparse matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a column-major sparse matrix type or MT2 is not a row-major sparse matrix type, the resulting data type Type is set to INVALID_TYPE
 Cblaze::TSMatSMatSubExprTrait< MT1, MT2 >Evaluation of the expression type of a transpose sparse matrix/sparse matrix subtraction.Via this type trait it is possible to evaluate the resulting expression type of a transpose sparse matrix/sparse matrix subtraction. Given the column-major sparse matrix type MT1 and the row-major sparse matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a column-major sparse matrix type or MT2 is not a row-major sparse matrix type, the resulting data type Type is set to INVALID_TYPE
 Cblaze::TSMatSVecMultExprTrait< MT, VT >Evaluation of the expression type of a transpose sparse matrix/sparse vector multiplication.Via this type trait it is possible to evaluate the resulting expression type of a transpose sparse matrix/sparse vector multiplication. Given the column-major sparse matrix type MT and the non-transpose sparse vector type VT, the nested type Type corresponds to the resulting expression type. In case either MT is not a column-major sparse matrix type or VT is not a non-transpose sparse vector type, the resulting data type Type is set to INVALID_TYPE
 Cblaze::TSMatTDMatAddExprTrait< MT1, MT2 >Evaluation of the expression type of a transpose sparse matrix/transpose dense matrix addition.Via this type trait it is possible to evaluate the resulting expression type of a transpose sparse matrix/transpose dense matrix addition. Given the column-major sparse matrix type MT1 and the column-major dense matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a column-major sparse matrix type or MT2 is not a column-major dense matrix type, the resulting data type Type is set to INVALID_TYPE
 Cblaze::TSMatTDMatMultExprTrait< MT1, MT2 >Evaluation of the expression type of a transpose sparse matrix/transpose dense matrix multiplication.Via this type trait it is possible to evaluate the resulting expression type of a transpose sparse matrix/transpose dense matrix multiplication. Given the column-major sparse matrix type MT1 and the column-major dense matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a column-major sparse matrix type or MT2 is not a column-major dense matrix type, the resulting data type Type is set to INVALID_TYPE
 Cblaze::TSMatTDMatSubExprTrait< MT1, MT2 >Evaluation of the expression type of a transpose sparse matrix/transpose dense matrix subtraction.Via this type trait it is possible to evaluate the resulting expression type of a transpose sparse matrix/transpose dense matrix subtraction. Given the column-major sparse matrix type MT1 and the column-major dense matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a column-major sparse matrix type or MT2 is not a column-major dense matrix type, the resulting data type Type is set to INVALID_TYPE
 Cblaze::TSMatTransExprTrait< MT >Evaluation of the expression type of a sparse matrix transpose operation.Via this type trait it is possible to evaluate the resulting expression type of a sparse matrix transpose operation. Given the column-major sparse matrix type MT, the nested type Type corresponds to the resulting expression type. In case either MT is not a column-major sparse matrix type, the resulting Type is set to INVALID_TYPE
 Cblaze::TSMatTSMatAddExprTrait< MT1, MT2 >Evaluation of the expression type of a transpose sparse matrix/transpose sparse matrix addition.Via this type trait it is possible to evaluate the resulting expression type of a transpose sparse matrix/transpose sparse matrix addition. Given the two column-major sparse matrix types MT1 and MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 or MT2 is not a column-major sparse matrix, the resulting data type Type is set to INVALID_TYPE
 Cblaze::TSMatTSMatMultExprTrait< MT1, MT2 >Evaluation of the expression type of a transpose sparse matrix/transpose sparse matrix multiplication.Via this type trait it is possible to evaluate the resulting expression type of a transpose sparse matrix/transpose sparse matrix multiplication. Given the two column-major sparse matrix types MT1 and MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 or MT2 is not a column-major sparse matrix, the resulting data type Type is set to INVALID_TYPE
 Cblaze::TSMatTSMatSubExprTrait< MT1, MT2 >Evaluation of the expression type of a transpose sparse matrix/transpose sparse matrix subtraction.Via this type trait it is possible to evaluate the resulting expression type of a transpose sparse matrix/transpose sparse matrix subtraction. Given the two column-major sparse matrix types MT1 and MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 or MT2 is not a column-major sparse matrix, the resulting data type Type is set to INVALID_TYPE
 Cblaze::TSVecAbsExprTrait< VT >Evaluation of the expression type of a sparse vector absolute value operation.Via this type trait it is possible to evaluate the resulting expression type of a sparse vector absolute value operation. Given the transpose sparse vector type VT, the nested type Type corresponds to the resulting expression type. In case either VT is not a transpose sparse vector type, the resulting Type is set to INVALID_TYPE
 Cblaze::TSVecDMatMultExprTrait< VT, MT >Evaluation of the expression type of a sparse vector/dense matrix multiplication.Via this type trait it is possible to evaluate the resulting expression type of a sparse vector/dense matrix multiplication. Given the transpose sparse vector type VT and the row-major dense matrix type MT, the nested type Type corresponds to the resulting expression type. In case either VT is not a transpose sparse vector type or MT is not a row-major dense matrix type, the resulting data type Type is set to INVALID_TYPE
 Cblaze::TSVecDVecMultExprTrait< VT1, VT2 >Evaluation of the expression type of a transpose sparse vector/dense vector multiplication.Via this type trait it is possible to evaluate the resulting expression type of a transpose sparse vector/dense vector multiplication (inner product). Given the transpose sparse vector type VT1 and the non-transpose dense vector type VT2, the nested type Type corresponds to the resulting expression type. In case either VT1 is not a transpose sparse vector type or VT2 is not a non-transpose dense vector type, the resulting Type is set to INVALID_TYPE
 Cblaze::TSVecEvalExprTrait< VT >Evaluation of the expression type of a sparse vector evaluation operation.Via this type trait it is possible to evaluate the resulting expression type of a sparse vector evaluation operation. Given the transpose sparse vector type VT, the nested type Type corresponds to the resulting expression type. In case either VT is not a transpose sparse vector type, the resulting Type is set to INVALID_TYPE
 Cblaze::TSVecScalarDivExprTrait< VT, ST >Evaluation of the expression type of a transpose sparse vector/scalar division.Via this type trait it is possible to evaluate the resulting expression type of a transpose sparse vector/scalar division. Given the transpose sparse vector type VT and the scalar type ST, the nested type Type corresponds to the resulting expression type. In case either VT is not a transpose sparse vector type or ST is not a scalar type, the resulting Type is set to INVALID_TYPE
 Cblaze::TSVecScalarMultExprTrait< VT, ST >Evaluation of the expression type of a transpose sparse vector/scalar multiplication.Via this type trait it is possible to evaluate the resulting expression type of a transpose sparse vector/scalar multiplication. Given the transpose sparse vector type VT and the scalar type ST, the nested type Type corresponds to the resulting expression type. In case either VT is not a transpose sparse vector type or ST is not a scalar type, the resulting Type is set to INVALID_TYPE
 Cblaze::TSVecSerialExprTrait< VT >Evaluation of the expression type of a sparse vector serial evaluation operation.Via this type trait it is possible to evaluate the resulting expression type of a sparse vector serial evaluation operation. Given the transpose sparse vector type VT, the nested type Type corresponds to the resulting expression type. In case either VT is not a transpose sparse vector type, the resulting Type is set to INVALID_TYPE
 Cblaze::TSVecSMatMultExprTrait< VT, MT >Evaluation of the expression type of a sparse vector/sparse matrix multiplication.Via this type trait it is possible to evaluate the resulting expression type of a sparse vector/sparse matrix multiplication. Given the transpose sparse vector type VT and the row-major sparse matrix type MT, the nested type Type corresponds to the resulting expression type. In case either VT is not a transpose sparse vector type or MT is not a row-major sparse matrix type, the resulting data type Type is set to INVALID_TYPE
 Cblaze::TSVecSVecMultExprTrait< VT1, VT2 >Evaluation of the expression type of a transpose sparse vector/sparse vector multiplication.Via this type trait it is possible to evaluate the resulting expression type of a transpose sparse vector/sparse vector multiplication (inner product). Given the transpose sparse vector type VT1 and the non-transpose sparse vector type VT2, the nested type Type corresponds to the resulting expression type. In case either VT1 is not a transpose sparse vector type or VT2 is not a non-transpose sparse vector type, the resulting Type is set to INVALID_TYPE
 Cblaze::TSVecTDMatMultExprTrait< VT, MT >Evaluation of the expression type of a sparse vector/transpose dense matrix multiplication.Via this type trait it is possible to evaluate the resulting expression type of a sparse vector/transpose dense matrix multiplication. Given the transpose sparse vector type VT and the column-major dense matrix type MT, the nested type Type corresponds to the resulting expression type. In case either VT is not a transpose sparse vector type or MT is not a column-major dense matrix type, the resulting data type Type is set to INVALID_TYPE
 Cblaze::TSVecTDVecAddExprTrait< VT1, VT2 >Evaluation of the expression type of a transpose sparse vector/transpose dense vector addition.Via this type trait it is possible to evaluate the resulting expression type of a transpose sparse vector/transpose dense vector addition. Given the transpose sparse vector type VT1 and the transpose dense vector type VT2, the nested type Type corresponds to the resulting expression type. In case either VT1 is not a transpose sparse vector type or VT2 is not a transpose dense vector type, the resulting Type is set to INVALID_TYPE
 Cblaze::TSVecTDVecMultExprTrait< VT1, VT2 >Evaluation of the expression type of a transpose sparse vector/transpose dense vector multiplication.Via this type trait it is possible to evaluate the resulting expression type of a transpose sparse vector/transpose dense vector multiplication. Given the transpose sparse vector type VT1 and the transpose dense vector type VT2, the nested type Type corresponds to the resulting expression type. In case either VT1 is not a transpose sparse vector type or VT2 is not a transpose dense vector type, the resulting Type is set to INVALID_TYPE
 Cblaze::TSVecTDVecSubExprTrait< VT1, VT2 >Evaluation of the expression type of a transpose sparse vector/transpose dense vector subtraction.Via this type trait it is possible to evaluate the resulting expression type of a transpose sparse vector/transpose dense vector subtraction. Given the transpose sparse vector type VT1 and the transpose dense vector type VT2, the nested type Type corresponds to the resulting expression type. In case either VT1 is not a transpose sparse vector type or VT2 is not a transpose dense vector type, the resulting Type is set to INVALID_TYPE
 Cblaze::TSVecTransExprTrait< VT >Evaluation of the expression type of a sparse vector transpose operation.Via this type trait it is possible to evaluate the resulting expression type of a sparse vector transpose operation. Given the transpose sparse vector type VT, the nested type Type corresponds to the resulting expression type. In case either VT is not a transpose sparse vector type, the resulting Type is set to INVALID_TYPE
 Cblaze::TSVecTSMatMultExprTrait< VT, MT >Evaluation of the expression type of a sparse vector/transpose sparse matrix multiplication.Via this type trait it is possible to evaluate the resulting expression type of a sparse vector/transpose sparse matrix multiplication. Given the transpose sparse vector type VT and the column-major sparse matrix type MT, the nested type Type corresponds to the resulting expression type. In case either VT is not a transpose sparse vector type or MT is not a column-major sparse matrix type, the resulting data type Type is set to INVALID_TYPE
 Cblaze::TSVecTSVecAddExprTrait< VT1, VT2 >Evaluation of the expression type of a transpose sparse vector/transpose sparse vector addition.Via this type trait it is possible to evaluate the resulting expression type of a transpose sparse vector/transpose sparse vector addition. Given the two transpose sparse vector types VT1 and VT2, the nested type Type corresponds to the resulting expression type. In case either VT1 or VT2 is not a transpose sparse vector type, the resulting Type is set to INVALID_TYPE
 Cblaze::TSVecTSVecMultExprTrait< VT1, VT2 >Evaluation of the expression type of a transpose sparse vector/transpose sparse vector multiplication.Via this type trait it is possible to evaluate the resulting expression type of a transpose sparse vector/transpose sparse vector multiplication. Given the two transpose sparse vector types VT1 and VT2, the nested type Type corresponds to the resulting expression type. In case either VT1 or VT2 is not a transpose sparse vector type, the resulting Type is set to INVALID_TYPE
 Cblaze::TSVecTSVecSubExprTrait< VT1, VT2 >Evaluation of the expression type of a transpose sparse vector/transpose sparse vector subtraction.Via this type trait it is possible to evaluate the resulting expression type of a transpose sparse vector/transpose sparse vector subtraction. Given the two transpose sparse vector types VT1 and VT2, the nested type Type corresponds to the resulting expression type. In case either VT1 or VT2 is not a transpose sparse vector type, the resulting Type is set to INVALID_TYPE
 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
 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::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::Vector< typename, bool >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< VT, TF >
 Cblaze::VectorAccessProxy< VT >Access proxy for sparse, N-dimensional vectors.The VectorAccessProxy provides safe access to the elements of a non-const sparse vector.
The proxied access to the elements of a sparse vector is necessary since it may be possible that several insertion operations happen in the same statement. The following code illustrates this with two examples by means of the CompressedVector class:
 Cblaze::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:
 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