Class List

Here are the classes, structs, unions and interfaces with brief descriptions:

[detail level 123]

blaze	Namespace of the Blaze C++ math library
logging	Namespace for the logging module
FunctionTrace	RAII object for function tracing.The FunctionTrace class is an auxiliary helper class for the tracing of function calls. It is implemented as a wrapper around the Logger class and is responsible for the atomicity of the logging operations of trace information
Logger	Implementation of a logger class.The Logger class represents the core of the logging functionality. It is responsible for commiting logging messages immediately to the according log file(s). The logger works for both serial as well as MPI parallel environments. In case of a non-MPI-parallel simulation the Logger creates the log file 'blaze.log', which contains all logging information from all logging levels. In case of a MPI parallel simulation, each process creates his own individual log file called 'blazeX.log', where 'X' is replaced by the according rank the process has in the MPI_COMM_WORLD communicator. Note that the log file(s) are only created in case any logging information is created. This might for instance result in only a small number of log file(s) in MPI parallel simulations when only some of the processes encounter errors/warnings/etc. Note that the logging functionality may not be used before MPI_Init() has been finished. In consequence, this means that no global data that is initialized before the main() function may contain any use of the logging functionality!
LogSection	Logging 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)
solvers	Namespace for the solvers module
threadpool	Namespace for the threadpool module
TaskQueue	Task queue for the thread pool.The TaskQueue class represents the internal task container of a thread pool. It uses a FIFO (first in, first out) strategy to store and remove the assigned tasks
timing	Namespace for the time measurement module
CpuPolicy	Timing policy for the measurement of the CPU time.The CpuPolicy class represents the timing policy for CPU time measurements that can be used in combination with the Timer class template. This combination is realized with the CpuTimer type definition
Timer	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:
WcPolicy	Timing policy for the measurement of the wall clock time.The WcPolicy class represents the timing policy for wall clock time measurements that can be used in combination with the Timer class template. This combination is realized with the WcTimer type definition
NegativeAccuracy	Negative computation accuracy for floating point data types.The NegativeAccuracy class is a wrapper class around the functionality of the blaze::Limits class. It represents the negative computation accuracy of the Blaze library for any floating point data type. In order to assign a negative accuracy value, the NegativeAccuracy class can be implicitly converted to the three built-in floating point data types float, double and long double
Accuracy	Computation accuracy for floating point data types.The Accuracy class is a wrapper class around the functionality of the blaze::Limits class. It represents the computation accuracy of the Blaze library for any floating point data type. In order to assign an accuracy value, the Accuracy class can be implicitly converted to the three built-in floating point data types float, double and long double. In order to handle accuracy values conveniently, the global Accuracy instance blaze::accuracy is provided, which can be used wherever a floating point data value is required
DenseIterator	Implementation of a generic iterator for dense vectors and matrices.The DenseIterator represents a generic random-access iterator that can be used for dense vectors and specific rows/columns of dense matrices
DynamicMatrix	Efficient implementation of a dynamic matrix.The DynamicMatrix class template is the representation of an arbitrary sized matrix with dynamically allocated elements of arbitrary type. The type of the elements and the storage order of the matrix can be specified via the two template parameters:
DynamicVector	Efficient implementation of an arbitrary sized vector.The DynamicVector class template is the representation of an arbitrary sized vector with dynamically allocated elements of arbitrary type. The type of the elements and the transpose flag of the vector can be specified via the two template parameters:
HybridVector	Efficient implementation of a dynamically sized vector with static memory.The HybridVector class template combines the flexibility of a dynamically sized vector with the efficiency and performance of a fixed-size vector. It is implemented as a crossing between the blaze::StaticVector and the blaze::DynamicVector class templates: Similar to the static vector it uses static stack memory instead of dynamically allocated memory and similar to the dynamic vector it can be resized (within the extend of the static memory). The type of the elements, the maximum number of elements and the transpose flag of the vector can be specified via the three template parameters:
StaticMatrix	Efficient implementation of a fixed-sized matrix.The StaticMatrix class template is the representation of a fixed-size matrix with statically allocated elements of arbitrary type. The type of the elements, the number of rows and columns and the storage order of the matrix can be specified via the four template parameters:
StaticVector	Efficient implementation of a fixed-sized vector.The StaticVector class template is the representation of a fixed-size vector with statically allocated elements of arbitrary type. The type of the elements, the number of elements and the transpose flag of the vector can be specified via the three template parameters:
NegativeEpsilon	Negative epsilon value for floating point data types.The NegativeEpsilon class is a wrapper class around the functionality of the blaze::Limits class. It represents the negative smallest difference between two values of any floating point data type. In order to assign a negative epsilon value, the Epsilon class can be implicitly converted to the three built-in floating point data types float, double and long double
Epsilon	Numerical epsilon value for floating point data types.The Epsilon class is a wrapper class around the functionality of the blaze::Limits class. It represents the smallest difference between two values of any floating point data type. In order to assign an epsilon value, the Epsilon class can be implicitly converted to the three built-in floating point data types float, double and long double. In order to handle epsilon values conveniently, the global Epsilon instance blaze::epsilon is provided, which can be used wherever a floating point data type is required
AbsExpr	Base class for all absolute value expression templates.The AbsExpr class serves as a tag for all expression templates that implement an absolute value operation. All classes, that represent an absolute value operation and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as absolute value expression template. Only in case a class is derived from the AbsExpr base class, the IsAbsExpr type trait recognizes the class as valid absolute value expression template
AddExpr	Base class for all addition expression templates.The AddExpr class serves as a tag for all expression templates that implement mathematical additions. All classes, that represent a mathematical addition (vector additions and matrix additions) and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as addition expression template. Only in case a class is derived from the AddExpr base class, the IsAddExpr type trait recognizes the class as valid addition expression template
Column	Base class for all columns.The Column class serves as a tag for all columns (i.e. dense and sparse columns). All classes that represent a column and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as a column. Only in case a class is derived from the Column base class, the IsColumn type trait recognizes the class as valid column
Computation	Base class for all compute expression templates.The Computation class serves as a tag for all computational expression templates. All classes, that represent a mathematical computation (addition, subtraction, multiplication, division, absolute value calculation, ...) and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as computational expression template. Only in case a class is derived from the Computation base class, the IsComputation type trait recognizes the class as valid computational expression template
CrossExpr	Base class for all cross product expression templates.The CrossExpr class serves as a tag for all expression templates that implement mathematical cross products. All classes, that represent a mathematical cross product and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as cross product expression template. Only in case a class is derived from the CrossExpr base class, the IsCrossExpr type trait recognizes the class as valid cross product expression template
DenseMatrix	Base class for dense matrices.The DenseMatrix class is a base class for all dense matrix classes. It provides an abstraction from the actual type of the dense matrix, but enables a conversion back to this type via the Matrix base class
DenseVector	Base class for N-dimensional dense vectors.The DenseVector class is a base class for all arbitrarily sized (N-dimensional) dense vectors. It provides an abstraction from the actual type of the dense vector, but enables a conversion back to this type via the Vector base class
DivExpr	Base class for all division expression templates.The DivExpr class serves as a tag for all expression templates that implement mathematical divisions. All classes, that represent a mathematical division (vector/scalar divisions and matrix/scalar division) and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as division expression template. Only in case a class is derived from the DivExpr base class, the IsDivExpr type trait recognizes the class as valid division expression template
DMatAbsExpr	Expression object for the dense matrix abs() function.The DMatAbsExpr class represents the compile time expression for the calculation of the absolute value of each element of a dense matrix via the abs() function
ConstIterator	Iterator over the elements of the dense matrix
DMatDMatAddExpr	Expression object for dense matrix-dense matrix additions.The DMatDMatAddExpr class represents the compile time expression for additions between dense matrices with identical storage order
ConstIterator	Iterator over the elements of the dense matrix
DMatDMatMultExpr	Expression object for dense matrix-dense matrix multiplications.The DMatDMatMultExpr class represents the compile time expression for multiplications between row-major dense matrices
DMatDMatSubExpr	Expression object for dense matrix-dense matrix subtractions.The DMatDMatSubExpr class represents the compile time expression for subtractions between dense matrices with identical storage order
ConstIterator	Iterator over the elements of the dense matrix
DMatDVecMultExpr	Expression object for dense matrix-dense vector multiplications.The DMatDVecMultExpr class represents the compile time expression for multiplications between row-major dense matrices and dense vectors
DMatEvalExpr	Expression object for the forced evaluation of dense matrices.The DMatEvalExpr class represents the compile time expression for the forced evaluation of a dense matrix
DMatScalarDivExpr	Expression object for divisions of a dense matrix by a scalar.The DMatScalarDivExpr class represents the compile time expression for divisions of dense matrices and by scalar values
ConstIterator	Iterator over the elements of the dense matrix
DMatScalarMultExpr	Expression object for dense matrix-scalar multiplications.The DMatScalarMultExpr class represents the compile time expression for multiplications between a dense matrix and a scalar value
ConstIterator	Iterator over the elements of the dense matrix
DMatSMatAddExpr	Expression object for dense matrix-sparse matrix additions.The DMatSMatAddExpr class represents the compile time expression for additions between a dense matrix and a sparse matrix with identical storage order
DMatSMatMultExpr	Expression object for dense matrix-sparse matrix multiplications.The DMatSMatMultExpr class represents the compile time expression for multiplications between a row-major dense matrix and a row-major sparse matrix
DMatSMatSubExpr	Expression object for dense matrix-sparse matrix subtractions.The DMatSMatSubExpr class represents the compile time expression for subtractions between a dense matrix and a sparse matrix with identical storage order
DMatSVecMultExpr	Expression object for dense matrix-sparse vector multiplications.The DMatSVecMultExpr class represents the compile time expression for multiplications between row-major dense matrices and sparse vectors
DMatTDMatAddExpr	Expression object for dense matrix-transpose dense matrix additions.The DMatTDMatAddExpr class represents the compile time expression for additions between a row-major dense matrix and column-major dense matrix
DMatTDMatMultExpr	Expression object for dense matrix-transpose dense matrix multiplications.The DMatTDMatMultExpr class represents the compile time expression for multiplications between a row-major dense matrix and a column-major dense matrix
DMatTDMatSubExpr	Expression object for dense matrix-transpose dense matrix subtractions.The DMatTDMatSubExpr class represents the compile time expression for subtractions between a row-major dense matrix and a column-major dense matrix
DMatTransExpr	Expression object for dense matrix transpositions.The DMatTransExpr class represents the compile time expression for transpositions of dense matrices
ConstIterator	Iterator over the elements of the dense matrix
DMatTransposer	Expression object for the transposition of a dense matrix.The DMatTransposer class is a wrapper object for the temporary transposition of a dense matrix
DMatTSMatAddExpr	Expression object for dense matrix-sparse matrix additions.The DMatTSMatAddExpr class represents the compile time expression for additions between a row-major dense matrix and a column-major sparse matrix
DMatTSMatMultExpr	Expression object for dense matrix-transpose sparse matrix multiplications.The DMatTSMatMultExpr class represents the compile time expression for multiplications between a row-major dense matrix and a column-major sparse matrix
DMatTSMatSubExpr	Expression object for dense matrix-transpose sparse matrix subtractions.The DMatTSMatSubExpr class represents the compile time expression for subtractions between a row-major dense matrix and a column-major sparse matrix
DVecAbsExpr	Expression object for the dense vector abs() function.The DVecAbsExpr class represents the compile time expression for the calculation of the absolute value of each element of a dense vector via the abs() function
ConstIterator	Iterator over the elements of the dense vector
DVecDVecAddExpr	Expression object for dense vector-dense vector additions.The DVecDVecAddExpr class represents the compile time expression for additions between dense vectors
ConstIterator	Iterator over the elements of the dense vector
DVecDVecCrossExpr	Expression object for dense vector-dense vector cross products.The DVecDVecCrossExpr class represents the compile time expression for cross products between dense vectors
DVecDVecMultExpr	Expression object for dense vector-dense vector multiplications.The DVecDVecMultExpr class represents the compile time expression for componentwise multiplications between dense vectors
ConstIterator	Iterator over the elements of the dense vector
DVecDVecSubExpr	Expression object for dense vector-dense vector subtractions.The DVecDVecSubExpr class represents the compile time expression for subtractions between dense vectors
ConstIterator	Iterator over the elements of the dense vector
DVecEvalExpr	Expression object for the forced evaluation of dense vectors.The DVecEvalExpr class represents the compile time expression for the forced evaluation of a dense vector
DVecScalarDivExpr	Expression object for divisions of a dense vector by a scalar.The DVecScalarDivExpr class represents the compile time expression for divisions of dense vectors by scalar values
ConstIterator	Iterator over the elements of the dense vector
DVecScalarMultExpr	Expression object for dense vector-scalar multiplications.The DVecScalarMultExpr class represents the compile time expression for multiplications between a dense vector and a scalar value
ConstIterator	Iterator over the elements of the dense vector
DVecSVecAddExpr	Expression object for dense vector-sparse vector additions.The DVecSVecAddExpr class represents the compile time expression for additions between a dense vector and a sparse vector
DVecSVecCrossExpr	Expression object for dense vector-sparse vector cross products.The DVecSVecCrossExpr class represents the compile time expression for cross products between a dense vector and a sparse vector
DVecSVecMultExpr	Expression object for dense vector-sparse vector multiplications.The DVecSVecMultExpr class represents the compile time expression for componentwise multiplications between a dense vector and a sparse vector
ConstIterator	Iterator over the elements of the dense vector-sparse vector multiplication expression
DVecSVecSubExpr	Expression object for dense vector-sparse vector subtractions.The DVecSVecSubExpr class represents the compile time expression for subtractions between a dense vector and a sparse vector
DVecTDVecMultExpr	Expression object for outer products between two dense vectors.The DVecTDVecMultExpr class represents the compile time expression for outer products between dense vectors
ConstIterator	Iterator over the elements of the dense matrix
DVecTransExpr	Expression object for dense vector transpositions.The DVecTransExpr class represents the compile time expression for transpositions of dense vectors
ConstIterator	Iterator over the elements of the dense vector
DVecTransposer	Expression object for the transposition of a dense vector.The DVecTransposer class is a wrapper object for the temporary transposition of a dense vector
DVecTSVecMultExpr	Expression object for dense vector-sparse vector outer products.The DVecTSVecMultExpr class represents the compile time expression for dense vector-sparse vector outer products
ConstIterator	Iterator over the elements of the dense vector-sparse vector outer product expression
EvalExpr	Base class for all evaluation expression templates.The EvalExpr class serves as a tag for all expression templates that implement an evaluation operation. All classes, that represent an evaluation operation and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as evaluation expression template. Only in case a class is derived from the EvalExpr base class, the IsEvalExpr type trait recognizes the class as valid evaluation expression template
Expression	Base class for all expression templates.The Expression class is the base class for all expression templates. All classes, that represent a mathematical operation and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as expression template. Only in case a class is derived from the Expression base class, the IsExpression type trait recognizes the class as valid expression template
Matrix	Base class for matrices.The Matrix class is a base class for all dense and sparse matrix classes within the Blaze library. It provides an abstraction from the actual type of the matrix, but enables a conversion back to this type via the 'Curiously Recurring Template Pattern' (CRTP)
SMatAbsExpr	Expression object for the sparse matrix abs() function.The SMatAbsExpr class represents the compile time expression for the calculation of the absolute value of each element of a sparse matrix via the abs() function
ConstIterator	Iterator over the elements of the sparse matrix absolute value expression
SMatDMatMultExpr	Expression object for sparse matrix-dense matrix multiplications.The SMatDMatMultExpr class represents the compile time expression for multiplications between a row-major sparse matrix and a row-major dense matrix
SMatDMatSubExpr	Expression object for sparse matrix-dense matrix subtractions.The SMatDMatSubExpr class represents the compile time expression for subtractions between a sparse matrix and a dense matrix with identical storage order
SMatDVecMultExpr	Expression object for sparse matrix-dense vector multiplications.The SMatDVecMultExpr class represents the compile time expression for multiplications between row-major sparse matrices and dense vectors
SMatEvalExpr	Expression object for the forced evaluation of sparse matrices.The SMatEvalExpr class represents the compile time expression for the forced evaluation of a sparse matrix
SMatScalarDivExpr	Expression object for sparse matrix-scalar divisions.The SMatScalarMult class represents the compile time expression for divisions between a sparse matrix and a scalar value
ConstIterator	Iterator over the elements of the sparse matrix/scalar division expression
SMatScalarMultExpr	Expression object for sparse matrix-scalar multiplications.The SMatScalarMult class represents the compile time expression for multiplications between a sparse matrix and a scalar value
ConstIterator	Iterator over the elements of the sparse matrix/scalar multiplication expression
SMatSMatAddExpr	Expression object for sparse matrix-sparse matrix additions.The SMatSMatAddExpr class represents the compile time expression for additions between two row-major sparse matrices
SMatSMatMultExpr	Expression object for sparse matrix-sparse matrix multiplications.The SMatSMatMultExpr class represents the compile time expression for multiplications between row-major sparse matrices
SMatSMatSubExpr	Expression object for sparse matrix-sparse matrix subtractions.The SMatSMatSubExpr class represents the compile time expression for subtractions between sparse matrices
SMatSVecMultExpr	Expression object for sparse matrix-sparse vector multiplications.The SMatSVecMultExpr class represents the compile time expression for multiplications between row-major sparse matrices and sparse vectors
SMatTDMatMultExpr	Expression object for sparse matrix-transpose dense matrix multiplications.The SMatTDMatMultExpr class represents the compile time expression for multiplications between a row-major sparse matrix and a column-major dense matrix
SMatTDMatSubExpr	Expression object for sparse matrix-transpose dense matrix subtractions.The SMatTDMatSubExpr class represents the compile time expression for subtractions between a row-major sparse matrix and a column-major dense matrix
SMatTransExpr	Expression object for sparse matrix transpositions.The SMatTransExpr class represents the compile time expression for transpositions of sparse matrices
ConstIterator	Iterator over the elements of the sparse matrix transposition expression
SMatTransposer	Expression object for the transposition of a sparse matrix.The SMatTransposer class is a wrapper object for the temporary transposition of a sparse matrix
SMatTSMatAddExpr	Expression object for sparse matrix-transpose sparse matrix additions.The SMatTSMatAddExpr class represents the compile time expression for additions between a row-major sparse matrix and a column-major sparse matrix
SMatTSMatMultExpr	Expression object for sparse matrix-transpose sparse matrix multiplications.The SMatTSMatMultExpr class represents the compile time expression for multiplications between a row-major and a column-major sparse matrix
SMatTSMatSubExpr	Expression object for sparse matrix-transpose sparse matrix subtractions.The SMatTSMatSubExpr class represents the compile time expression for subtractions between a row-major sparse matrix and a column-major sparse matrix
SparseMatrix	Base class for sparse matrices.The SparseMatrix class is a base class for all sparse matrix classes. It provides an abstraction from the actual type of the sparse matrix, but enables a conversion back to this type via the Matrix base class
SparseVector	Base class for sparse vectors.The SparseVector class is a base class for all arbitrarily sized (N-dimensional) sparse vectors. It provides an abstraction from the actual type of the sparse vector, but enables a conversion back to this type via the Vector base class
SVecAbsExpr	Expression object for the sparse vector abs() function.The SVecAbsExpr class represents the compile time expression for the calculation of the absolute value of each element of a sparse vector via the abs() function
ConstIterator	Iterator over the elements of the sparse vector absolute value expression
SVecDVecCrossExpr	Expression object for sparse vector-dense vector cross products.The SVecDVecCrossExpr class represents the compile time expression for cross products between a sparse vector and a dense vector
SVecDVecMultExpr	Expression object for sparse vector-dense vector multiplications.The SVecDVecMultExpr class represents the compile time expression for componentwise multiplications between a sparse vector and a dense vector
ConstIterator	Iterator over the elements of the sparse vector-dense vector multiplication expression
SVecDVecSubExpr	Expression object for sparse vector-dense vector subtractions.The SVecDVecSubExpr class represents the compile time expression for subtractions between a sparse vector and a dense vector
SVecEvalExpr	Expression object for the forced evaluation of sparse vectors.The SVecEvalExpr class represents the compile time expression for the forced evaluation of a sparse vector
SVecScalarDivExpr	Expression object for divisions of a sparse vector by a scalar.The SVecScalarDivExpr class represents the compile time expression for divisions of sparse vectors by scalar values
ConstIterator	Iterator over the elements of the sparse vector/scalar multiplication expression
SVecScalarMultExpr	Expression object for sparse vector-scalar multiplications.The SVecScalarMultExpr class represents the compile time expression for multiplications between a sparse vector and a scalar value
ConstIterator	Iterator over the elements of the sparse vector/scalar multiplication expression
SVecSVecAddExpr	Expression object for sparse vector-sparse vector additions.The SVecSVecAddExpr class represents the compile time expression for additions between sparse vectors
SVecSVecCrossExpr	Expression object for sparse vector-sparse vector cross products.The SVecSVecCrossExpr class represents the compile time expression for cross products between sparse vectors
SVecSVecMultExpr	Expression object for sparse vector-sparse vector multiplications.The SVecSVecMultExpr class represents the compile time expression for componentwise multiplications between sparse vectors
SVecSVecSubExpr	Expression object for sparse vector-sparse vector subtractions.The SVecSVecSubExpr class represents the compile time expression for subtractions between sparse vectors
SVecTDVecMultExpr	Expression object for sparse vector-dense vector outer products.The SVecTDVecMultExpr class represents the compile time expression for sparse vector-dense vector outer products
ConstIterator	Iterator over the elements of the sparse vector-dense vector outer product expression
SVecTransExpr	Expression object for sparse vector transpositions.The SVecTransExpr class represents the compile time expression for transpositions of sparse vectors
ConstIterator	Iterator over the elements of the sparse vector absolute value expression
SVecTransposer	Expression object for the transposition of a sparse vector.The SVecTransposer class is a wrapper object for the temporary transposition of a sparse vector
SVecTSVecMultExpr	Expression object for sparse vector-sparse vector outer products.The SVecTSVecMultExpr class represents the compile time expression for sparse vector-sparse vector outer products
TDMatDMatMultExpr	Expression object for transpose dense matrix-dense matrix multiplications.The TDMatDMatMultExpr class represents the compile time expression for multiplications between a column-major dense matrix and a row-major dense matrix
TDMatDVecMultExpr	Expression object for transpose dense matrix-dense vector multiplications.The TDMatDVecMultExpr class represents the compile time expression for multiplications between column-major dense matrices and dense vectors
TDMatSMatAddExpr	Expression object for dense matrix-sparse matrix additions.The TDMatSMatAddExpr class represents the compile time expression for additions between a column-major dense matrix and a row-major sparse matrix
TDMatSMatMultExpr	Expression object for transpose dense matrix-sparse matrix multiplications.The TDMatSMatMultExpr class represents the compile time expression for multiplications between a column-major dense matrix and a row-major sparse matrix
TDMatSMatSubExpr	Expression object for transpose dense matrix-sparse matrix subtractions.The TDMatSMatSubExpr class represents the compile time expression for subtractions between a row-major dense matrix and a column-major sparse matrix
TDMatSVecMultExpr	Expression object for transpose dense matrix-sparse vector multiplications.The TDMatSVecMultExpr class represents the compile time expression for multiplications between column-major dense matrices and sparse vectors
TDMatTDMatMultExpr	Expression object for transpose dense matrix-transpose dense matrix multiplications.The TDMatTDMatMultExpr class represents the compile time expression for multiplications between two column-major dense matrices
TDMatTSMatMultExpr	Expression object for transpose dense matrix-transpose sparse matrix multiplications.The TDMatTSMatMultExpr class represents the compile time expression for multiplications between a column-major dense matrix and a column-major sparse matrix
TDVecDMatMultExpr	Expression object for transpose dense vector-dense matrix multiplications.The TDVecDMatMultExpr class represents the compile time expression for multiplications between transpose dense vectors and dense matrices
TDVecSMatMultExpr	Expression object for transpose dense vector-sparse matrix multiplications.The TDVecSMatMultExpr class represents the compile time expression for multiplications between transpose dense vectors and row-major sparse matrices
TDVecTDMatMultExpr	Expression object for transpose dense vector-transpose dense matrix multiplications.The TDVecTDMatMultExpr class represents the compile time expression for multiplications between transpose dense vectors and column-major dense matrices
TDVecTSMatMultExpr	Expression object for transpose dense vector-transpose sparse matrix multiplications.The TDVecTSMatMultExpr class represents the compile time expression for multiplications between transpose dense vectors and column-major sparse matrices
TSMatDMatMultExpr	Expression object for transpose sparse matrix-dense matrix multiplications.The TSMatDMatMultExpr class represents the compile time expression for multiplications between a column-major sparse matrix and a row-major dense matrix
TSMatDMatSubExpr	Expression object for transpose sparse matrix-dense matrix subtractions.The TSMatDMatSubExpr class represents the compile time expression for subtractions between a column-major sparse matrix and a row-major dense matrix
TSMatDVecMultExpr	Expression object for transpose sparse matrix-dense vector multiplications.The TSMatDVecMultExpr class represents the compile time expression for multiplications between column-major sparse matrices and dense vectors
TSMatSMatMultExpr	Expression object for transpose sparse matrix-sparse matrix multiplications.The TSMatSMatMultExpr class represents the compile time expression for multiplications between a column-major and a row-major sparse matrix
TSMatSMatSubExpr	Expression object for transpose sparse matrix-sparse matrix subtractions.The TSMatSMatSubExpr class represents the compile time expression for subtractions between a column-major sparse matrix and a row-major sparse matrix
TSMatSVecMultExpr	Expression object for sparse matrix-sparse vector multiplications.The TSMatSVecMultExpr class represents the compile time expression for multiplications between column-major sparse matrices and sparse vectors
TSMatTDMatMultExpr	Expression object for transpose sparse matrix-transpose dense matrix multiplications.The TSMatTDMatMultExpr class represents the compile time expression for multiplications between a column-major sparse matrix and a column-major dense matrix
TSMatTSMatAddExpr	Expression object for transpose sparse matrix-transpose sparse matrix additions.The TSMatTSMatAddExpr class represents the compile time expression for additions between two column-major sparse matrices
TSMatTSMatMultExpr	Expression object for transpose sparse matrix-transpose sparse matrix multiplications.The TSMatTSMatMultExpr class represents the compile time expression for multiplications between two column-major sparse matrices
TSMatTSMatSubExpr	Expression object for transpose sparse matrix-transpose sparse matrix subtractions.The TSMatTSMatSubExpr class represents the compile time expression for subtractions between two column-major sparse matrices
TSVecDMatMultExpr	Expression object for transpose sparse vector-dense matrix multiplications.The TSVecDMatMultExpr class represents the compile time expression for multiplications between transpose sparse vectors and row-major dense matrices
TSVecSMatMultExpr	Expression object for sparse vector-sparse matrix multiplications.The TSVecSMatMultExpr class represents the compile time expression for multiplications between transpose sparse vectors and row-major sparse matrices
TSVecTDMatMultExpr	Expression object for transpose sparse vector-transpose dense matrix multiplications.The TSVecTDMatMultExpr class represents the compile time expression for multiplications between transpose sparse vectors and column-major dense matrices
TSVecTSMatMultExpr	Expression object for sparse vector-sparse matrix multiplications.The TSVecTSMatMultExpr class represents the compile time expression for multiplications between transpose sparse vectors and column-major sparse matrices
Vector	Base class for N-dimensional vectors.The Vector class is a base class for all arbitrarily sized (N-dimensional) dense and sparse vector classes within the Blaze library. It provides an abstraction from the actual type of the vector, but enables a conversion back to this type via the 'Curiously Recurring Template Pattern' (CRTP)
MatAbsExpr	Base class for all matrix absolute value expression templates.The MatAbsExpr class serves as a tag for all expression templates that implement a matrix absolute value operation. All classes, that represent a matrix absolute value operation and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as matrix absolute value expression template. Only in case a class is derived from the MatAbsExpr base class, the IsMatAbsExpr type trait recognizes the class as valid matrix absolute value expression template
MatEvalExpr	Base class for all matrix evaluation expression templates.The MatEvalExpr class serves as a tag for all expression templates that implement a matrix evaluation operation. All classes, that represent a matrix evaluation operation and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as matrix evaluation expression template. Only in case a class is derived from the MatEvalExpr base class, the IsMatEvalExpr type trait recognizes the class as valid matrix evaluation expression template
MatMatAddExpr	Base class for all matrix/matrix addition expression templates.The MatMatAddExpr class serves as a tag for all expression templates that implement a matrix/matrix addition. All classes, that represent a matrix addition and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as matrix addition expression template. Only in case a class is derived from the MatMatAddExpr base class, the IsMatMatAddExpr type trait recognizes the class as valid matrix addition expression template
MatMatMultExpr	Base class for all matrix/matrix multiplication expression templates.The MatMatMultExpr class serves as a tag for all expression templates that implement a matrix/matrix multiplication. All classes, that represent a matrix multiplication and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as matrix multiplication expression template. Only in case a class is derived from the MatMatMultExpr base class, the IsMatMatMultExpr type trait recognizes the class as valid matrix multiplication expression template
MatMatSubExpr	Base class for all matrix/matrix subtraction expression templates.The MatMatSubExpr class serves as a tag for all expression templates that implement a matrix/matrix subtraction. All classes, that represent a matrix subtraction and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as matrix subtraction expression template. Only in case a class is derived from the MatMatSubExpr base class, the IsMatMatSubExpr type trait recognizes the class as valid matrix subtraction expression template
MatScalarDivExpr	Base class for all matrix/scalar divsion expression templates.The MatScalarDivExpr class serves as a tag for all expression templates that implement a matrix/scalar divsion. All classes, that represent a matrix/scalar divsion and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as matrix/scalar divsion expression template. Only in case a class is derived from the MatScalarDivExpr base class, the IsMatScalarDivExpr type trait recognizes the class as valid matrix/scalar divsion expression template
MatScalarMultExpr	Base class for all matrix/scalar multiplication expression templates.The MatScalarMultExpr class serves as a tag for all expression templates that implement a matrix/scalar multiplication. All classes, that represent a matrix/scalar multiplication and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as matrix/scalar multiplication expression template. Only in case a class is derived from the MatScalarMultExpr base class, the IsMatScalarMultExpr type trait recognizes the class as valid matrix/scalar multiplication expression template
MatTransExpr	Base class for all matrix transposition expression templates.The MatTransExpr class serves as a tag for all expression templates that implement a matrix transposition operation. All classes, that represent a matrix transposition operation and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as matrix transposition expression template. Only in case a class is derived from the MatTransExpr base class, the IsMatTransExpr type trait recognizes the class as valid matrix transposition expression template
MatVecMultExpr	Base class for all matrix/vector multiplication expression templates.The MatVecMultExpr class serves as a tag for all expression templates that implement a matrix/vector multiplication. All classes, that represent a matrix/vector multiplication and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as matrix/vector multiplication expression template. Only in case a class is derived from the MatVecMultExpr base class, the IsMatVecMultExpr type trait recognizes the class as valid matrix/vector multiplication expression template
MultExpr	Base class for all multiplication expression templates.The MultExpr class serves as a tag for all expression templates that implement mathematical multiplications. All classes, that represent a mathematical multiplication (element-wise vector multiplications, matrix/vector multiplications, vector/matrix multiplications and matrix/matrix multiplications) and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as multiplication expression template. Only in case a class is derived from the MultExpr base class, the IsMultExpr type trait recognizes the class as valid multiplication expression template
Row	Base class for all rows.The Row class serves as a tag for all rows (i.e. dense and sparse rows). All classes that represent a row and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as a row. Only in case a class is derived from the Row base class, the IsRow type trait recognizes the class as valid row
SubExpr	Base class for all subtraction expression templates.The SubExpr class serves as a tag for all expression templates that implement mathematical subtractions. All classes, that represent a mathematical subtraction (vector subtractions and matrix subtractions) and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as subtraction expression template. Only in case a class is derived from the SubExpr base class, the IsSubExpr type trait recognizes the class as valid subtraction expression template
Submatrix	Base class for all submatrices.The Submatrix class serves as a tag for all submatrices (i.e. dense and sparse submatrices). All classes that represent a submatrix and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as a submatrix. Only in case a class is derived from the Submatrix base class, the IsSubmatrix type trait recognizes the class as valid submatrix
Subvector	Base class for all subvectors.The Subvector class serves as a tag for all subvectors (i.e. dense and sparse subvectors). All classes that represent a subvector and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as a subvector. Only in case a class is derived from the Subvector base class, the IsSubvector type trait recognizes the class as valid subvector
TransExpr	Base class for all transposition expression templates.The TransExpr class serves as a tag for all expression templates that implement mathematical transpositions. All classes, that represent a mathematical transposition (vector transpositions and matrix transpositions) and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as transposition expression template. Only in case a class is derived from the TransExpr base class, the IsTransExpr type trait recognizes the class as valid transposition expression template
TVecMatMultExpr	Base class for all vector/matrix multiplication expression templates.The TVecMatMultExpr class serves as a tag for all expression templates that implement a vector/matrix multiplication. All classes, that represent a vector/matrix multiplication and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as vector/matrix multiplication expression template. Only in case a class is derived from the TVecMatMultExpr base class, the IsTVecMatMultExpr type trait recognizes the class as valid vector/matrix multiplication expression template
VecAbsExpr	Base class for all vector absolute value expression templates.The VecAbsExpr class serves as a tag for all expression templates that implement a vector absolute value operation. All classes, that represent a vector absolute value operation and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as vector absolute value expression template. Only in case a class is derived from the VecAbsExpr base class, the IsVecAbsExpr type trait recognizes the class as valid vector absolute value expression template
VecEvalExpr	Base class for all vector evaluation expression templates.The VecEvalExpr class serves as a tag for all expression templates that implement a vector evaluation operation. All classes, that represent a vector evaluation operation and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as vector evaluation expression template. Only in case a class is derived from the VecEvalExpr base class, the IsVecEvalExpr type trait recognizes the class as valid vector evaluation expression template
VecScalarDivExpr	Base class for all vector/scalar division expression templates.The VecScalarDivExpr class serves as a tag for all expression templates that implement a vector/scalar division. All classes, that represent a vector/scalar division and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as vector/scalar division expression template. Only in case a class is derived from the VecScalarDivExpr base class, the IsVecScalarDivExpr type trait recognizes the class as valid vector/scalar division expression template
VecScalarMultExpr	Base class for all vector/scalar multiplication expression templates.The VecScalarMultExpr class serves as a tag for all expression templates that implement a vector/scalar multiplication. All classes, that represent a vector/scalar multiplication and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as vector/scalar multiplication expression template. Only in case a class is derived from the VecScalarMultExpr base class, the IsVecScalarMultExpr type trait recognizes the class as valid vector/scalar multiplication expression template
VecTransExpr	Base class for all vector transposition expression templates.The VecTransExpr class serves as a tag for all expression templates that implement a vector transposition operation. All classes, that represent a vector transposition operation and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as vector transposition expression template. Only in case a class is derived from the VecTransExpr base class, the IsVecTransExpr type trait recognizes the class as valid vector transposition expression template
VecTVecMultExpr	Base class for all outer product expression templates.The VecTVecMultExpr class serves as a tag for all expression templates that implement mathematical outer products (i.e. multiplications between a column vector and a row vector). All classes, that represent a mathematical outer product and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as outer product expression template. Only in case a class is derived from the VecTVecMultExpr base class, the IsVecTVecMultExpr type trait recognizes the class as valid outer product expression template
VecVecAddExpr	Base class for all vector/vector addition expression templates.The VecVecAddExpr class serves as a tag for all expression templates that implement a vector/vector addition. All classes, that represent a vector addition and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as vector addition expression template. Only in case a class is derived from the VecVecAddExpr base class, the IsVecVecAddExpr type trait recognizes the class as valid vector addition expression template
VecVecMultExpr	Base class for all vector/vector multiplication expression templates.The VecVecMultExpr class serves as a tag for all expression templates that implement a vector/vector multiplication. All classes, that represent a vector multiplication and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as vector multiplication expression template. Only in case a class is derived from the VecVecMultExpr base class, the IsVecVecMultExpr type trait recognizes the class as valid vector multiplication expression template
VecVecSubExpr	Base class for all vector/vector subtraction expression templates.The VecVecSubExpr class serves as a tag for all expression templates that implement a vector/vector subtraction. All classes, that represent a vector subtraction and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as vector subtraction expression template. Only in case a class is derived from the VecVecSubExpr base class, the IsVecVecSubExpr type trait recognizes the class as valid vector subtraction expression template
View	Base class for all views.The View class serves as a tag for all views (subvectors, submatrices, rows, columns, ...). All classes that represent a view and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as a view. Only in case a class is derived from the View base class, the IsView type trait recognizes the class as valid view
Quaternion	Efficient implementation of a quaternion.Quaternions are a superior way to deal with rotations and orientations. This quaternion consists of 4 statically allocated elements, where the first element represents the real part and the three other elements represent the three imaginary parts. The naming convention of the elements is as following:
RotationMatrix	Efficient, generic implementation of a 3x3 rotation matrix.The RotationMatrix class is the representation of a 3x3 rotation matrix with a total of 9 statically allocated elements of arbitrary type. The naming convention of the elements is as following:
NegativeInfinity	Negative infinity for built-in data types.The NegativeInfinity class is a wrapper class around the functionality of the blaze::Limits class to provide the possibility to assign negative infinity values to built-in data types. As negative infinity value, the largest possible negative value of the corresponding data type is used. In order to assign the negative infinity value, the NegativeInfinity class can be implicitly converted to all signed integral and floating point data types:
Infinity	Positive infinity for built-in data types.The Infinity class is a wrapper class around the functionality of the blaze::Limits class to provide the possiblity to assign a positive infinity value to built-in data types. As positive infinity value, the largest possible positive value of the corresponding data type is used. In order to assign the positive infinity value, the Infinity class can be implicitly converted to the following 13 built-in integral and floating point data types:
IntrinsicTrait	Intrinsic characteristics of data types.The IntrinsicTrait class template provides the intrinsic characteristics of a specific data type:
BoxLCP	A box linear complementarity problem (BLCP) data structure.The BoxLCP class represent a box linear complementarity problem (BLCP) of the form
ContactLCP	A data structure for linear complementarity problems (LCPs) for contact mechanics.TODO
LCP	A linear complementarity problem (LCP) data structure.The LCP class represent a linear complementarity problem of the form
LSE	A linear system of equations (LSE) data structure.The LSE class represent a linear system of equations of the form
MixedLCP	A mixed linear complementarity problem (MLCP) data structure.The LCP class represent a mixed linear complementarity problem of the form
ModifiedBoxLCP	A modified box linear complementarity problem (MBLCP) data structure.The ModifiedBoxLCP class represent a modified box linear complementarity problem (MBLCP) of the form
MatrixSerializer	Serializer for dense and sparse matrices.The MatrixSerializer implements the necessary logic to serialize dense and sparse matrices, i.e. to convert them into a portable, binary representation. The following example demonstrates the (de-)serialization process of matrices:
TypeValueMapping	Conversion from a data type to a serial representation.This class template converts the given data type into an integral representation suited for serialization. Depending on the given data type, the value member enumeration is set to the according serial representation
VectorSerializer	Serializer for dense and sparse vectors.The VectorSerializer implements the necessary logic to serialize dense and sparse vectors, i.e. to convert them into a portable, binary representation. The following example demonstrates the (de-)serialization process of vectors:
SerialSection	Section to enforce the serial execution of operations.The SerialSection class is an auxiliary helper class for the BLAZE_SERIAL_SECTION macro. It provides the functionality to detect whether a serial section is active, i.e. if the currently executed code is inside a serial section
CG	A conjugate gradient solver.TODO: description TODO: Problem formulation: !!
CPG	Implementation of the conjugate projected gradient algorithm.TODO: description of the CPG solver TODO: capabilities of the CPG solver (which LCP problems, etc) TODO: known issues of the CPG solver
GaussianElimination	Implementation of the Gaussian elimination direct linear system solver.TODO: description TODO: Problem formulation: !!
Lemke	The Lemke pivoting algorithm for solving LCPs.TODO
PGS	A projected Gauss-Seidel Solver for (box) LCPs.TODO: description of the PGS solver TODO: capabilities of the PGS solver (which LCP problems, etc) TODO: known issues of the PGS solver
Solver	Base class for all solver classes.TODO: description of the Solver class TODO: description of its functionality
CompressedMatrix	Efficient implementation of a compressed matrix.The CompressedMatrix class template is the representation of an arbitrary sized sparse matrix with dynamically allocated elements of arbitrary type. The type of the elements and the storage order of the matrix can be specified via the two template parameters:
CompressedVector	Efficient implementation of an arbitrary sized sparse vector.The CompressedVector class is the representation of an arbitrarily sized sparse vector, which stores only non-zero elements of arbitrary type. The type of the elements and the transpose flag of the vector can be specified via the two template parameters:
MatrixAccessProxy	Access proxy for sparse, matrices.The MatrixAccessProxy provides safe access to the elements of a non-const sparse matrices. The proxied access to the elements of a sparse matrix is necessary since it may be possible that several insertion operations happen in the same statement. The following code illustrates this with two examples by means of the CompressedMatrix class:
SparseElement	Base class for all sparse element types.The SparseElement class is the base class for all sparse element types. All types that conceptually represent a sparse vector or matrix element and that provide a value() and an index() member function have to derive from this class in order to qualify as sparse element. Only in case a class is derived from the SparseElement base class, the IsSparseElement type trait recognizes the class as valid sparse element
ValueIndexPair	Index-value-pair for sparse vectors and matrices.The ValueIndexPair class represents a single index-value-pair of a sparse vector or sparse matrix
VectorAccessProxy	Access proxy for sparse, N-dimensional vectors.The VectorAccessProxy provides safe access to the elements of a non-const sparse vector. The proxied access to the elements of a sparse vector is necessary since it may be possible that several insertion operations happen in the same statement. The following code illustrates this with two examples by means of the CompressedVector class:
AbsExprTrait	Evaluation of the return type of an absolute value expression.Via this type trait it is possible to evaluate the return type of an absolute value expression. Given the type T, which must either be a scalar, vector, or matrix type, the nested type Type corresponds to the resulting return type. In case the type of T doesn't fit or if no absolute value operation exists for the type, the resulting data type Type is set to INVALID_TYPE
AddExprTrait	Evaluation of the return type of an addition expression.Via this type trait it is possible to evaluate the return type of an addition expression between scalars, vectors, and matrices. Given the two types T1 and T2, which must either be scalar, vector, or matrix types, the nested type Type corresponds to the resulting return type. In case the types of T1 or T2 don't fit or if the two types cannot be added, the resulting data type Type is set to INVALID_TYPE
AddTrait	Base template for the AddTrait class
CMathTrait	Base template for the CMathTrait class.The CMathTrait template evaluates the return type of the mathematical functions defined in the C++ header <cmath> depending on the type of the template argument. In case of an integral data type or double precision argument, the return value of the functions is double, whereas the return type is float for single precision arguments and long double for long double precision arguments
ColumnExprTrait	Evaluation of the expression type type of a column operation.Via this type trait it is possible to evaluate the return type of a column operation. Given the dense or sparse matrix type MT, the nested type Type corresponds to the resulting return type. In case the given type is neither a dense nor a sparse matrix type, the resulting data type Type is set to INVALID_TYPE
ColumnTrait	Base template for the ColumnTrait class
CrossExprTrait	Evaluation of the return type of a cross product expression.Via this type trait it is possible to evaluate the return type of a cross product expression. Given the two types T1 and T2, which must be dense or sparse column vectors, the nested type Type corresponds to the resulting return type. In case the types of T1 or T2 don't fit or if the two types cannot be used in a cross product, the resulting data type Type is set to INVALID_TYPE
CrossTrait	Base template for the CrossTrait class
DivExprTrait	Evaluation of the resulting expression type of a division.Via this type trait it is possible to evaluate the return type of a division expression between scalars, vectors, and matrices. Given the two types T1 and T2, where T1 must either be a scalar, vector, or matrix type and T2 which must be a scalar type, the nested type Type corresponds to the resulting return type. In case T1 or T2 don't fit or if the two types cannot be divided, the resulting data type Type is set to INVALID_TYPE
DivTrait	Base template for the DivTrait class
DMatAbsExprTrait	Evaluation of the expression type of a dense matrix absolute value operation.Via this type trait it is possible to evaluate the resulting expression type of a dense matrix absolute value operation. Given the row-major dense matrix type MT, the nested type Type corresponds to the resulting expression type. In case either MT is not a row-major dense matrix type, the resulting Type is set to INVALID_TYPE
DMatDMatAddExprTrait	Evaluation of the expression type of a dense matrix/dense matrix addition.Via this type trait it is possible to evaluate the resulting expression type of a dense matrix/dense matrix addition. Given the two row-major dense matrix types MT1 and MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 or MT2 is not a row-major dense matrix, the resulting data type Type is set to INVALID_TYPE
DMatDMatMultExprTrait	Evaluation of the expression type of a dense matrix/dense matrix multiplication.Via this type trait it is possible to evaluate the resulting expression type of a dense matrix/dense matrix multiplication. Given the two row-major dense matrix types MT1 and MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 or MT2 is not a row-major dense matrix, the resulting data type Type is set to INVALID_TYPE
DMatDMatSubExprTrait	Evaluation of the expression type of a dense matrix/dense matrix subtraction.Via this type trait it is possible to evaluate the resulting expression type of a dense matrix/dense matrix subtraction. Given the two row-major dense matrix types MT1 and MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 or MT2 is not a row-major dense matrix, the resulting data type Type is set to INVALID_TYPE
DMatDVecMultExprTrait	Evaluation of the expression type of a dense matrix/dense vector multiplication.Via this type trait it is possible to evaluate the resulting expression type of a dense matrix/dense vector multiplication. Given the row-major dense matrix type MT and the non-transpose dense vector type VT, the nested type Type corresponds to the resulting expression type. In case either MT is not a row-major dense matrix type or VT is not a non-transpose dense vector type, the resulting data type Type is set to INVALID_TYPE
DMatEvalExprTrait	Evaluation of the expression type of a dense matrix evaluation operation.Via this type trait it is possible to evaluate the resulting expression type of a dense matrix evaluation operation. Given the row-major dense matrix type MT, the nested type Type corresponds to the resulting expression type. In case either MT is not a row-major dense matrix type, the resulting Type is set to INVALID_TYPE
DMatScalarDivExprTrait	Evaluation of the expression type of a dense matrix/scalar division.Via this type trait it is possible to evaluate the resulting expression type of a dense matrix/scalar division. Given the row-major dense matrix type MT and the scalar type ST, the nested type Type corresponds to the resulting expression type. In case either MT is not a row-major dense matrix type or ST is not a scalar type, the resulting Type is set to INVALID_TYPE
DMatScalarMultExprTrait	Evaluation of the expression type of a dense matrix/scalar multiplication.Via this type trait it is possible to evaluate the resulting expression type of a dense matrix/scalar multiplication. Given the row-major dense matrix type MT and the scalar type ST, the nested type Type corresponds to the resulting expression type. In case either MT is not a row-major dense matrix type or ST is not a scalar type, the resulting Type is set to INVALID_TYPE
DMatSMatAddExprTrait	Evaluation of the expression type of a dense matrix/sparse matrix addition.Via this type trait it is possible to evaluate the resulting expression type of a dense matrix/sparse matrix addition. Given the row-major dense matrix type MT1 and the row-major sparse matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a row-major dense matrix type or MT2 is not a row-major sparse matrix type, the resulting data type Type is set to INVALID_TYPE
DMatSMatMultExprTrait	Evaluation of the expression type of a dense matrix/sparse matrix multiplication.Via this type trait it is possible to evaluate the resulting expression type of a dense matrix/sparse matrix multiplication. Given the row-major dense matrix type MT1 and the row-major sparse matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a row-major dense matrix type or MT2 is not a row-major sparse matrix type, the resulting data type Type is set to INVALID_TYPE
DMatSMatSubExprTrait	Evaluation of the expression type of a dense matrix/sparse matrix subtraction.Via this type trait it is possible to evaluate the resulting expression type of a dense matrix/sparse matrix subtraction. Given the row-major dense matrix type MT1 and the row-major sparse matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a row-major dense matrix type or MT2 is not a row-major sparse matrix type, the resulting data type Type is set to INVALID_TYPE
DMatSVecMultExprTrait	Evaluation of the expression type of a dense matrix/sparse vector multiplication.Via this type trait it is possible to evaluate the resulting expression type of a dense matrix/sparse vector multiplication. Given the row-major dense matrix type MT and the non-transpose sparse vector type VT, the nested type Type corresponds to the resulting expression type. In case either MT is not a row-major dense matrix type or VT is not a non-transpose sparse vector type, the resulting data type Type is set to INVALID_TYPE
DMatTDMatAddExprTrait	Evaluation of the expression type of a dense matrix/transpose dense matrix addition.Via this type trait it is possible to evaluate the resulting expression type of a dense matrix/transpose dense matrix addition. Given the row-major dense matrix type MT1 and the column-major dense matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a row-major dense matrix type or MT2 is not a column-major dense matrix type, the resulting data type Type is set to INVALID_TYPE
DMatTDMatMultExprTrait	Evaluation of the expression type of a dense matrix/transpose dense matrix multiplication.Via this type trait it is possible to evaluate the resulting expression type of a dense matrix/transpose dense matrix multiplication. Given the row-major dense matrix type MT1 and the column-major dense matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a row-major dense matrix type or MT2 is not a column-major dense matrix type, the resulting data type Type is set to INVALID_TYPE
DMatTDMatSubExprTrait	Evaluation of the expression type of a dense matrix/transpose dense matrix subtraction.Via this type trait it is possible to evaluate the resulting expression type of a dense matrix/transpose dense matrix subtraction. Given the row-major dense matrix type MT1 and the column-major dense matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a row-major dense matrix type or MT2 is not a column-major dense matrix type, the resulting data type Type is set to INVALID_TYPE
DMatTransExprTrait	Evaluation of the expression type of a dense matrix transpose operation.Via this type trait it is possible to evaluate the resulting expression type of a dense matrix transpose operation. Given the row-major dense matrix type MT, the nested type Type corresponds to the resulting expression type. In case either MT is not a row-major dense matrix type, the resulting Type is set to INVALID_TYPE
DMatTSMatAddExprTrait	Evaluation of the expression type of a dense matrix/transpose sparse matrix addition.Via this type trait it is possible to evaluate the resulting expression type of a dense matrix/transpose sparse matrix addition. Given the row-major dense matrix type MT1 and the column-major sparse matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a row-major dense matrix type or MT2 is not a column-major sparse matrix type, the resulting data type Type is set to INVALID_TYPE
DMatTSMatMultExprTrait	Evaluation of the expression type of a dense matrix/transpose sparse matrix multiplication.Via this type trait it is possible to evaluate the resulting expression type of a dense matrix/ transpose sparse matrix multiplication. Given the row-major dense matrix type MT1 and the column-major sparse matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a row-major dense matrix type or MT2 is not a column-major sparse matrix type, the resulting data type Type is set to INVALID_TYPE
DMatTSMatSubExprTrait	Evaluation of the expression type of a dense matrix/transpose sparse matrix subtraction.Via this type trait it is possible to evaluate the resulting expression type of a dense matrix/ transpose sparse matrix subtraction. Given the row-major dense matrix type MT1 and the column-major sparse matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a row-major dense matrix type or MT2 is not a column-major sparse matrix type, the resulting data type Type is set to INVALID_TYPE
DVecAbsExprTrait	Evaluation of the expression type of a dense vector absolute value operation.Via this type trait it is possible to evaluate the resulting expression type of a dense vector absolute value operation. Given the non-transpose dense vector type VT, the nested type Type corresponds to the resulting expression type. In case either VT is not a non-transpose dense vector type, the resulting Type is set to INVALID_TYPE
DVecDVecAddExprTrait	Evaluation of the expression type of a dense vector/dense vector addition.Via this type trait it is possible to evaluate the resulting expression type of a dense vector/dense vector addition. Given the two non-transpose dense vector types VT1 and VT2, the nested type Type corresponds to the resulting expression type. In case either VT1 or VT2 is not a non-transpose dense vector type, the resulting Type is set to INVALID_TYPE
DVecDVecCrossExprTrait	Evaluation of the expression type of a dense vector/dense vector cross product.Via this type trait it is possible to evaluate the resulting expression type of a dense vector/dense vector cross product. Given the two non-transpose dense vector types VT1 and VT2, the nested type Type corresponds to the resulting expression type. In case either VT1 or VT2 is not a non-transpose dense vector type, the resulting Type is set to INVALID_TYPE
DVecDVecMultExprTrait	Evaluation of the expression type of a dense vector/dense vector multiplication.Via this type trait it is possible to evaluate the resulting expression type of a dense vector/dense vector multiplication. Given the two non-transpose dense vector types VT1 and VT2, the nested type Type corresponds to the resulting expression type. In case either VT1 or VT2 is not a non-transpose dense vector type, the resulting Type is set to INVALID_TYPE
DVecDVecSubExprTrait	Evaluation of the expression type of a dense vector/dense vector subtraction.Via this type trait it is possible to evaluate the resulting expression type of a dense vector/dense vector subtraction. Given the two non-transpose dense vector types VT1 and VT2, the nested type Type corresponds to the resulting expression type. In case either VT1 or VT2 is not a non-transpose dense vector type, the resulting Type is set to INVALID_TYPE
DVecEvalExprTrait	Evaluation of the expression type of a dense vector evaluation operation.Via this type trait it is possible to evaluate the resulting expression type of a dense vector evaluation operation. Given the non-transpose dense vector type VT, the nested type Type corresponds to the resulting expression type. In case either VT is not a non-transpose dense vector type, the resulting Type is set to INVALID_TYPE
DVecScalarDivExprTrait	Evaluation of the expression type of a dense vector/scalar division.Via this type trait it is possible to evaluate the resulting expression type of a dense vector/scalar division. Given the non-transpose dense vector type VT and the scalar type ST, the nested type Type corresponds to the resulting expression type. In case either VT is not a non-transpose dense vector type or ST is not a scalar type, the resulting Type is set to INVALID_TYPE
DVecScalarMultExprTrait	Evaluation of the expression type of a dense vector/scalar multiplication.Via this type trait it is possible to evaluate the resulting expression type of a dense vector/scalar multiplication. Given the non-transpose dense vector type VT and the scalar type ST, the nested type Type corresponds to the resulting expression type. In case either VT is not a non-transpose dense vector type or ST is not a scalar type, the resulting Type is set to INVALID_TYPE
DVecSVecAddExprTrait	Evaluation of the expression type of a dense vector/sparse vector addition.Via this type trait it is possible to evaluate the resulting expression type of a dense vector/sparse vector addition. Given the non-transpose dense vector type VT1 and the non-transpose sparse vector typeVT2, the nested type Type corresponds to the resulting expression type. In case either VT1 is not a non-transpose dense vector type or VT2 is not a non-transpose sparse vector type, the resulting Type is set to INVALID_TYPE
DVecSVecCrossExprTrait	Evaluation of the expression type of a dense vector/sparse vector cross product.Via this type trait it is possible to evaluate the resulting expression type of a dense vector/sparse vector cross product. Given the non-transpose dense vector type VT1 and the non-transpose sparse vector typeVT2, the nested type Type corresponds to the resulting expression type. In case either VT1 is not a non-transpose dense vector type or VT2 is not a non-transpose sparse vector type, the resulting Type is set to INVALID_TYPE
DVecSVecMultExprTrait	Evaluation of the expression type of a dense vector/sparse vector multiplication.Via this type trait it is possible to evaluate the resulting expression type of a dense vector/sparse vector multiplication. Given the non-transpose dense vector type VT1 and the non-transpose sparse vector typeVT2, the nested type Type corresponds to the resulting expression type. In case either VT1 is not a non-transpose dense vector type or VT2 is not a non-transpose sparse vector type, the resulting Type is set to INVALID_TYPE
DVecSVecSubExprTrait	Evaluation of the expression type of a dense vector/sparse vector subtraction.Via this type trait it is possible to evaluate the resulting expression type of a dense vector/sparse vector subtraction. Given the non-transpose dense vector type VT1 and the non-transpose sparse vector typeVT2, the nested type Type corresponds to the resulting expression type. In case either VT1 is not a non-transpose dense vector type or VT2 is not a non-transpose sparse vector type, the resulting Type is set to INVALID_TYPE
DVecTDVecMultExprTrait	Evaluation of the expression type of a dense vector/transpose dense vector multiplication.Via this type trait it is possible to evaluate the resulting expression type of a dense vector/transpose dense vector multiplication (outer product). Given the non-transpose dense vector type VT1 and the transpose dense vector type VT2, the nested type Type corresponds to the resulting expression type. In case either VT1 is not a non-transpose dense vector type or VT2 is not a transpose dense vector type, the resulting Type is set to INVALID_TYPE
DVecTransExprTrait	Evaluation of the expression type of a dense vector transpose operation.Via this type trait it is possible to evaluate the resulting expression type of a dense vector transpose operation. Given the non-transpose dense vector type VT, the nested type Type corresponds to the resulting expression type. In case either VT is not a non-transpose dense vector type, the resulting Type is set to INVALID_TYPE
DVecTSVecMultExprTrait	Evaluation of the expression type of a dense vector/transpose sparse vector multiplication.Via this type trait it is possible to evaluate the resulting expression type of a dense vector/transpose sparse vector multiplication (outer product). Given the non-transpose dense vector type VT1 and the transpose sparse vector type VT2, the nested type Type corresponds to the resulting expression type. In case either VT1 is not a non-transpose dense vector type or VT2 is not a transpose sparse vector type, the resulting Type is set to INVALID_TYPE
EvalExprTrait	Evaluation of the return type of an evaluation expression.Via this type trait it is possible to evaluate the return type of an evaluation expression. Given the type T, which must either be a vector or matrix type, the nested type Type corresponds to the resulting return type. In case the type of T doesn't fit or if no evaluation operation exists for the type, the resulting data type Type is set to INVALID_TYPE
MathTrait	Base template for the MathTrait class
MultExprTrait	Evaluation of the resulting expression type of a multiplication.Via this type trait it is possible to evaluate the return type of a multiplication expression between scalars, vectors, and matrices. Given the two types T1 and T2, which must be either scalar, vector, or matrix types, the nested type Type corresponds to the resulting return type. In case T1 or T2 don't fit or if the two types cannot be multiplied, the resulting data type Type is set to INVALID_TYPE
MultTrait	Base template for the MultTrait class
RowExprTrait	Evaluation of the expression type type of a row operation.Via this type trait it is possible to evaluate the return type of a row operation. Given the dense or sparse matrix type MT, the nested type Type corresponds to the resulting return type. In case the given type is neither a dense nor a sparse matrix type, the resulting data type Type is set to INVALID_TYPE
RowTrait	Base template for the RowTrait class
SMatAbsExprTrait	Evaluation of the expression type of a sparse matrix absolute value operation.Via this type trait it is possible to evaluate the resulting expression type of a sparse matrix absolute value operation. Given the row-major sparse matrix type MT, the nested type Type corresponds to the resulting expression type. In case either MT is not a row-major sparse matrix type, the resulting Type is set to INVALID_TYPE
SMatDMatAddExprTrait	Evaluation of the expression type of a sparse matrix/dense matrix addition.Via this type trait it is possible to evaluate the resulting expression type of a sparse matrix/dense matrix addition. Given the row-major sparse matrix type MT1 and the row-major dense matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a row-major sparse matrix type or MT2 is not a row-major dense matrix type, the resulting data type Type is set to INVALID_TYPE
SMatDMatMultExprTrait	Evaluation of the expression type of a sparse matrix/dense matrix multiplication.Via this type trait it is possible to evaluate the resulting expression type of a sparse matrix/dense matrix multiplication. Given the row-major sparse matrix type MT1 and the row-major dense matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a row-major sparse matrix type or MT2 is not a row-major dense matrix type, the resulting data type Type is set to INVALID_TYPE
SMatDMatSubExprTrait	Evaluation of the expression type of a sparse matrix/dense matrix subtraction.Via this type trait it is possible to evaluate the resulting expression type of a sparse matrix/dense matrix subtraction. Given the row-major sparse matrix type MT1 and the row-major dense matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a row-major sparse matrix type or MT2 is not a row-major dense matrix type, the resulting data type Type is set to INVALID_TYPE
SMatDVecMultExprTrait	Evaluation of the expression type of a sparse matrix/dense vector multiplication.Via this type trait it is possible to evaluate the resulting expression type of a sparse matrix/dense vector multiplication. Given the row-major sparse matrix type MT and the non-transpose dense vector type VT, the nested type Type corresponds to the resulting expression type. In case either MT is not a row-major sparse matrix type or VT is not a non-transpose dense vector type, the resulting data type Type is set to INVALID_TYPE
SMatEvalExprTrait	Evaluation of the expression type of a sparse matrix evaluation operation.Via this type trait it is possible to evaluate the resulting expression type of a sparse matrix evaluation operation. Given the row-major sparse matrix type MT, the nested type Type corresponds to the resulting expression type. In case either MT is not a row-major sparse matrix type, the resulting Type is set to INVALID_TYPE
SMatScalarDivExprTrait	Evaluation of the expression type of a sparse matrix/scalar division.Via this type trait it is possible to evaluate the resulting expression type of a sparse matrix/scalar division. Given the row-major sparse matrix type MT and the scalar type ST, the nested type Type corresponds to the resulting expression type. In case either MT is not a row-major sparse matrix type or ST is not a scalar type, the resulting Type is set to INVALID_TYPE
SMatScalarMultExprTrait	Evaluation of the expression type of a sparse matrix/scalar multiplication.Via this type trait it is possible to evaluate the resulting expression type of a sparse matrix/scalar multiplication. Given the row-major sparse matrix type MT and the scalar type ST, the nested type Type corresponds to the resulting expression type. In case either MT is not a row-major sparse matrix type or ST is not a scalar type, the resulting Type is set to INVALID_TYPE
SMatSMatAddExprTrait	Evaluation of the expression type of a sparse matrix/sparse matrix addition.Via this type trait it is possible to evaluate the resulting expression type of a sparse matrix/sparse matrix addition. Given the two row-major sparse matrix types MT1 and MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 or MT2 is not a row-major sparse matrix, the resulting data type Type is set to INVALID_TYPE
SMatSMatMultExprTrait	Evaluation of the expression type of a sparse matrix/sparse matrix multiplication.Via this type trait it is possible to evaluate the resulting expression type of a sparse matrix/sparse matrix multiplication. Given the two row-major sparse matrix types MT1 and MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 or MT2 is not a row-major sparse matrix, the resulting data type Type is set to INVALID_TYPE
SMatSMatSubExprTrait	Evaluation of the expression type of a sparse matrix/sparse matrix subtraction.Via this type trait it is possible to evaluate the resulting expression type of a sparse matrix/sparse matrix subtraction. Given the two row-major sparse matrix types MT1 and MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 or MT2 is not a row-major sparse matrix, the resulting data type Type is set to INVALID_TYPE
SMatSVecMultExprTrait	Evaluation of the expression type of a sparse matrix/sparse vector multiplication.Via this type trait it is possible to evaluate the resulting expression type of a sparse matrix/sparse vector multiplication. Given the row-major sparse matrix type MT and the non-transpose sparse vector type VT, the nested type Type corresponds to the resulting expression type. In case either MT is not a row-major sparse matrix type or VT is not a non-transpose sparse vector type, the resulting data type Type is set to INVALID_TYPE
SMatTDMatAddExprTrait	Evaluation of the expression type of a sparse matrix/transpose dense matrix addition.Via this type trait it is possible to evaluate the resulting expression type of a sparse matrix/transpose dense matrix addition. Given the row-major sparse matrix type MT1 and the column-major dense matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a row-major sparse matrix type or MT2 is not a column-major dense matrix type, the resulting data type Type is set to INVALID_TYPE
SMatTDMatMultExprTrait	Evaluation of the expression type of a sparse matrix/transpose dense matrix multiplication.Via this type trait it is possible to evaluate the resulting expression type of a sparse matrix/transpose dense matrix multiplication. Given the row-major sparse matrix type MT1 and the column-major dense matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a row-major sparse matrix type or MT2 is not a column-major dense matrix type, the resulting data type Type is set to INVALID_TYPE
SMatTDMatSubExprTrait	Evaluation of the expression type of a sparse matrix/transpose dense matrix subtraction.Via this type trait it is possible to evaluate the resulting expression type of a sparse matrix/transpose dense matrix subtraction. Given the row-major sparse matrix type MT1 and the column-major dense matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a row-major sparse matrix type or MT2 is not a column-major dense matrix type, the resulting data type Type is set to INVALID_TYPE
SMatTransExprTrait	Evaluation of the expression type of a sparse matrix transpose operation.Via this type trait it is possible to evaluate the resulting expression type of a sparse matrix transpose operation. Given the row-major sparse matrix type MT, the nested type Type corresponds to the resulting expression type. In case either MT is not a row-major sparse matrix type, the resulting Type is set to INVALID_TYPE
SMatTSMatAddExprTrait	Evaluation of the expression type of a sparse matrix/transpose sparse matrix addition.Via this type trait it is possible to evaluate the resulting expression type of a sparse matrix/transpose sparse matrix addition. Given the row-major sparse matrix type MT1 and the column-major sparse matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a row-major sparse matrix type or MT2 is not a column-major sparse matrix type, the resulting data type Type is set to INVALID_TYPE
SMatTSMatMultExprTrait	Evaluation of the expression type of a sparse matrix/transpose sparse matrix multiplication.Via this type trait it is possible to evaluate the resulting expression type of a sparse matrix/transpose sparse matrix multiplication. Given the row-major sparse matrix type MT1 and the column-major sparse matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a row-major sparse matrix type or MT2 is not a column-major sparse matrix type, the resulting data type Type is set to INVALID_TYPE
SMatTSMatSubExprTrait	Evaluation of the expression type of a sparse matrix/transpose sparse matrix subtraction.Via this type trait it is possible to evaluate the resulting expression type of a sparse matrix/transpose sparse matrix subtraction. Given the row-major sparse matrix type MT1 and the column-major sparse matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a row-major sparse matrix type or MT2 is not a column-major sparse matrix type, the resulting data type Type is set to INVALID_TYPE
SubExprTrait	Evaluation of the return type of a subtraction expression.Via this type trait it is possible to evaluate the return type of a subtraction expression between scalar, vectors, and matrices. Given the two types T1 and T2, which must be either scalar, vector, or matrix types, the nested type Type corresponds to the resulting return type. In case T1 or T2 don't fit or if the two types cannot be subtracted, the resulting data type Type is set to INVALID_TYPE
SubmatrixExprTrait	Evaluation of the expression type type of a submatrix operation.Via this type trait it is possible to evaluate the return type of a submatrix operation. Given the dense or sparse matrix type MT and the alignment flag AF, the nested type Type corresponds to the resulting return type. In case the given type is neither a dense nor a sparse matrix type, the resulting data type Type is set to INVALID_TYPE
SubmatrixTrait	Base template for the SubmatrixTrait class
SubTrait	Base template for the SubTrait class
SubvectorExprTrait	Evaluation of the expression type type of a subvector operation.Via this type trait it is possible to evaluate the return type of a subvector operation. Given the dense or sparse vector type VT and the alignment flag AF, the nested type Type corresponds to the resulting return type. In case the given type is neither a dense nor a sparse vector type, the resulting data type Type is set to INVALID_TYPE
SubvectorTrait	Base template for the SubvectorTrait class
SVecAbsExprTrait	Evaluation of the expression type of a sparse vector absolute value operation.Via this type trait it is possible to evaluate the resulting expression type of a sparse vector absolute value operation. Given the non-transpose sparse vector type VT, the nested type Type corresponds to the resulting expression type. In case either VT is not a non-transpose sparse vector type, the resulting Type is set to INVALID_TYPE
SVecDVecAddExprTrait	Evaluation of the expression type of a sparse vector/dense vector addition.Via this type trait it is possible to evaluate the resulting expression type of a sparse vector/dense vector addition. Given the non-transpose sparse vector type VT1 and the non-transpose dense vector typeVT2, the nested type Type corresponds to the resulting expression type. In case either VT1 is not a non-transpose sparse vector type or VT2 is not a non-transpose dense vector type, the resulting Type is set to INVALID_TYPE
SVecDVecCrossExprTrait	Evaluation of the expression type of a sparse vector/dense vector cross product.Via this type trait it is possible to evaluate the resulting expression type of a sparse vector/dense vector cross product. Given the non-transpose sparse vector type VT1 and the non-transpose dense vector typeVT2, the nested type Type corresponds to the resulting expression type. In case either VT1 is not a non-transpose sparse vector type or VT2 is not a non-transpose dense vector type, the resulting Type is set to INVALID_TYPE
SVecDVecMultExprTrait	Evaluation of the expression type of a sparse vector/dense vector multiplication.Via this type trait it is possible to evaluate the resulting expression type of a sparse vector/dense vector multiplication. Given the non-transpose sparse vector type VT1 and the non-transpose dense vector typeVT2, the nested type Type corresponds to the resulting expression type. In case either VT1 is not a non-transpose sparse vector type or VT2 is not a non-transpose dense vector type, the resulting Type is set to INVALID_TYPE
SVecDVecSubExprTrait	Evaluation of the expression type of a sparse vector/dense vector subtraction.Via this type trait it is possible to evaluate the resulting expression type of a sparse vector/dense vector subtraction. Given the non-transpose sparse vector type VT1 and the non-transpose dense vector typeVT2, the nested type Type corresponds to the resulting expression type. In case either VT1 is not a non-transpose sparse vector type or VT2 is not a non-transpose dense vector type, the resulting Type is set to INVALID_TYPE
SVecEvalExprTrait	Evaluation of the expression type of a sparse vector evaluation operation.Via this type trait it is possible to evaluate the resulting expression type of a sparse vector evaluation operation. Given the non-transpose sparse vector type VT, the nested type Type corresponds to the resulting expression type. In case either VT is not a non-transpose sparse vector type, the resulting Type is set to INVALID_TYPE
SVecScalarDivExprTrait	Evaluation of the expression type of a sparse vector/scalar division.Via this type trait it is possible to evaluate the resulting expression type of a sparse vector/scalar division. Given the non-transpose sparse vector type VT and the scalar type ST, the nested type Type corresponds to the resulting expression type. In case either VT is not a non-transpose sparse vector type or ST is not a scalar type, the resulting Type is set to INVALID_TYPE
SVecScalarMultExprTrait	Evaluation of the expression type of a sparse vector/scalar multiplication.Via this type trait it is possible to evaluate the resulting expression type of a sparse vector/scalar multiplication. Given the non-transpose sparse vector type VT and the scalar type ST, the nested type Type corresponds to the resulting expression type. In case either VT is not a non-transpose sparse vector type or ST is not a scalar type, the resulting Type is set to INVALID_TYPE
SVecSVecAddExprTrait	Evaluation of the expression type of a sparse vector/sparse vector addition.Via this type trait it is possible to evaluate the resulting expression type of a sparse vector/sparse vector addition. Given the two non-transpose sparse vector types VT1 and VT2, the nested type Type corresponds to the resulting expression type. In case either VT1 or VT2 is not a non-transpose sparse vector type, the resulting Type is set to INVALID_TYPE
SVecSVecCrossExprTrait	Evaluation of the expression type of a sparse vector/sparse vector cross product.Via this type trait it is possible to evaluate the resulting expression type of a sparse vector/sparse vector cross product. Given the two non-transpose sparse vector types VT1 and VT2, the nested type Type corresponds to the resulting expression type. In case either VT1 or VT2 is not a non-transpose sparse vector type, the resulting Type is set to INVALID_TYPE
SVecSVecMultExprTrait	Evaluation of the expression type of a sparse vector/sparse vector multiplication.Via this type trait it is possible to evaluate the resulting expression type of a sparse vector/sparse vector multiplication. Given the two non-transpose sparse vector types VT1 and VT2, the nested type Type corresponds to the resulting expression type. In case either VT1 or VT2 is not a non-transpose sparse vector type, the resulting Type is set to INVALID_TYPE
SVecSVecSubExprTrait	Evaluation of the expression type of a sparse vector/sparse vector subtraction.Via this type trait it is possible to evaluate the resulting expression type of a sparse vector/sparse vector subtraction. Given the two non-transpose sparse vector types VT1 and VT2, the nested type Type corresponds to the resulting expression type. In case either VT1 or VT2 is not a non-transpose sparse vector type, the resulting Type is set to INVALID_TYPE
SVecTDVecMultExprTrait	Evaluation of the expression type of a sparse vector/transpose dense vector multiplication.Via this type trait it is possible to evaluate the resulting expression type of a sparse vector/transpose dense vector multiplication (outer product). Given the non-transpose sparse vector type VT1 and the transpose dense vector type VT2, the nested type Type corresponds to the resulting expression type. In case either VT1 is not a non-transpose sparse vector type or VT2 is not a transpose dense vector type, the resulting Type is set to INVALID_TYPE
SVecTransExprTrait	Evaluation of the expression type of a sparse vector transpose operation.Via this type trait it is possible to evaluate the resulting expression type of a sparse vector transpose operation. Given the non-transpose sparse vector type VT, the nested type Type corresponds to the resulting expression type. In case either VT is not a non-transpose sparse vector type, the resulting Type is set to INVALID_TYPE
SVecTSVecMultExprTrait	Evaluation of the expression type of a sparse vector/transpose sparse vector multiplication.Via this type trait it is possible to evaluate the resulting expression type of a sparse vector/transpose sparse vector multiplication (outer product). Given the non-transpose sparse vector type VT1 and the transpose sparse vector type VT2, the nested type Type corresponds to the resulting expression type. In case either VT1 is not a non-transpose sparse vector type or VT2 is not a transpose sparse vector type, the resulting Type is set to INVALID_TYPE
TDMatAbsExprTrait	Evaluation of the expression type of a dense matrix absolute value operation.Via this type trait it is possible to evaluate the resulting expression type of a dense matrix absolute value operation. Given the column-major dense matrix type MT, the nested type Type corresponds to the resulting expression type. In case either MT is not a column-major dense matrix type, the resulting Type is set to INVALID_TYPE
TDMatDMatAddExprTrait	Evaluation of the expression type of a transpose dense matrix/dense matrix addition.Via this type trait it is possible to evaluate the resulting expression type of a transpose dense matrix/dense matrix addition. Given the column-major dense matrix type MT1 and the row-major dense matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a column-major dense matrix type or MT2 is not a row-major dense matrix type, the resulting data type Type is set to INVALID_TYPE
TDMatDMatMultExprTrait	Evaluation of the expression type of a transpose dense matrix/dense matrix multiplication.Via this type trait it is possible to evaluate the resulting expression type of a transpose dense matrix/dense matrix multiplication. Given the column-major dense matrix type MT1 and the row-major dense matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a column-major dense matrix type or MT2 is not a row-major dense matrix type, the resulting data type Type is set to INVALID_TYPE
TDMatDMatSubExprTrait	Evaluation of the expression type of a transpose dense matrix/dense matrix subtraction.Via this type trait it is possible to evaluate the resulting expression type of a transpose dense matrix/dense matrix subtraction. Given the column-major dense matrix type MT1 and the row-major dense matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a column-major dense matrix type or MT2 is not a row-major dense matrix type, the resulting data type Type is set to INVALID_TYPE
TDMatDVecMultExprTrait	Evaluation of the expression type of a transpose dense matrix/dense vector multiplication.Via this type trait it is possible to evaluate the resulting expression type of a transpose dense matrix/dense vector multiplication. Given the column-major dense matrix type MT and the non-transpose dense vector type VT, the nested type Type corresponds to the resulting expression type. In case either MT is not a column-major dense matrix type or VT is not a non-transpose dense vector type, the resulting data type Type is set to INVALID_TYPE
TDMatEvalExprTrait	Evaluation of the expression type of a dense matrix evaluation operation.Via this type trait it is possible to evaluate the resulting expression type of a dense matrix evaluation operation. Given the column-major dense matrix type MT, the nested type Type corresponds to the resulting expression type. In case either MT is not a column-major dense matrix type, the resulting Type is set to INVALID_TYPE
TDMatScalarDivExprTrait	Evaluation of the expression type of a transpose dense matrix/scalar division.Via this type trait it is possible to evaluate the resulting expression type of a transpose dense matrix/scalar division. Given the column-major dense matrix type MT and the scalar type ST, the nested type Type corresponds to the resulting expression type. In case either MT is not a column-major dense matrix type or ST is not a scalar type, the resulting Type is set to INVALID_TYPE
TDMatScalarMultExprTrait	Evaluation of the expression type of a transpose dense matrix/scalar multiplication.Via this type trait it is possible to evaluate the resulting expression type of a transpose dense matrix/scalar multiplication. Given the column-major dense matrix type MT and the scalar type ST, the nested type Type corresponds to the resulting expression type. In case either MT is not a column-major dense matrix type or ST is not a scalar type, the resulting Type is set to INVALID_TYPE
TDMatSMatAddExprTrait	Evaluation of the expression type of a transpose dense matrix/sparse matrix addition.Via this type trait it is possible to evaluate the resulting expression type of a transpose dense matrix/sparse matrix addition. Given the column-major dense matrix type MT1 and the row-major sparse matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a column-major dense matrix type or MT2 is not a row-major sparse matrix type, the resulting data type Type is set to INVALID_TYPE
TDMatSMatMultExprTrait	Evaluation of the expression type of a transpose dense matrix/sparse matrix multiplication.Via this type trait it is possible to evaluate the resulting expression type of a transpose dense matrix/sparse matrix multiplication. Given the column-major dense matrix type MT1 and the row-major sparse matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a column-major dense matrix type or MT2 is not a row-major sparse matrix type, the resulting data type Type is set to INVALID_TYPE
TDMatSMatSubExprTrait	Evaluation of the expression type of a transpose dense matrix/sparse matrix subtraction.Via this type trait it is possible to evaluate the resulting expression type of a transpose dense matrix/sparse matrix subtraction. Given the column-major dense matrix type MT1 and the row-major sparse matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a column-major dense matrix type or MT2 is not a row-major sparse matrix type, the resulting data type Type is set to INVALID_TYPE
TDMatSVecMultExprTrait	Evaluation of the expression type of a transpose dense matrix/sparse vector multiplication.Via this type trait it is possible to evaluate the resulting expression type of a transpose dense matrix/sparse vector multiplication. Given the column-major dense matrix type MT and the non-transpose sparse vector type VT, the nested type Type corresponds to the resulting expression type. In case either MT is not a column-major dense matrix type or VT is not a non-transpose sparse vector type, the resulting data type Type is set to INVALID_TYPE
TDMatTDMatAddExprTrait	Evaluation of the expression type of a transpose dense matrix/transpose dense matrix addition.Via this type trait it is possible to evaluate the resulting expression type of a transpose dense matrix/transpose dense matrix addition. Given the two column-major dense matrix types MT1 and MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 or MT2 is not a column-major dense matrix, the resulting data type Type is set to INVALID_TYPE
TDMatTDMatMultExprTrait	Evaluation of the expression type of a transpose dense matrix/transpose dense matrix multiplication.Via this type trait it is possible to evaluate the resulting expression type of a transpose dense matrix/transpose dense matrix multiplication. Given the two column-major dense matrix types MT1 and MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 or MT2 is not a column-major dense matrix, the resulting data type Type is set to INVALID_TYPE
TDMatTDMatSubExprTrait	Evaluation of the expression type of a transpose dense matrix/transpose dense matrix subtraction.Via this type trait it is possible to evaluate the resulting expression type of a transpose dense matrix/transpose dense matrix subtraction. Given the two column-major dense matrix types MT1 and MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 or MT2 is not a column-major dense matrix, the resulting data type Type is set to INVALID_TYPE
TDMatTransExprTrait	Evaluation of the expression type of a dense matrix transpose operation.Via this type trait it is possible to evaluate the resulting expression type of a dense matrix transpose operation. Given the column-major dense matrix type MT, the nested type Type corresponds to the resulting expression type. In case either MT is not a column-major dense matrix type, the resulting Type is set to INVALID_TYPE
TDMatTSMatAddExprTrait	Evaluation of the expression type of a transpose dense matrix/transpose sparse matrix addition.Via this type trait it is possible to evaluate the resulting expression type of a transpose dense matrix/transpose sparse matrix addition. Given the column-major dense matrix type MT1 and the column-major sparse matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a column-major dense matrix type or MT2 is not a column-major sparse matrix type, the resulting data type Type is set to INVALID_TYPE
TDMatTSMatMultExprTrait	Evaluation of the expression type of a transpose dense matrix/transpose sparse matrix multiplication.Via this type trait it is possible to evaluate the resulting expression type of a transpose dense matrix/transpose sparse matrix multiplication. Given the column-major dense matrix type MT1 and the column-major sparse matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a column-major dense matrix type or MT2 is not a column-major sparse matrix type, the resulting data type Type is set to INVALID_TYPE
TDMatTSMatSubExprTrait	Evaluation of the expression type of a transpose dense matrix/transpose sparse matrix subtraction.Via this type trait it is possible to evaluate the resulting expression type of a transpose dense matrix/transpose sparse matrix subtraction. Given the column-major dense matrix type MT1 and the column-major sparse matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a column-major dense matrix type or MT2 is not a column-major sparse matrix type, the resulting data type Type is set to INVALID_TYPE
TDVecAbsExprTrait	Evaluation of the expression type of a dense vector absolute value operation.Via this type trait it is possible to evaluate the resulting expression type of a dense vector absolute value operation. Given the transpose dense vector type VT, the nested type Type corresponds to the resulting expression type. In case either VT is not a transpose dense vector type, the resulting Type is set to INVALID_TYPE
TDVecDMatMultExprTrait	Evaluation of the expression type of a dense vector/dense matrix multiplication.Via this type trait it is possible to evaluate the resulting expression type of a dense vector/dense matrix multiplication. Given the transpose dense vector type VT and the row-major dense matrix type MT, the nested type Type corresponds to the resulting expression type. In case either VT is not a transpose dense vector type or MT is not a row-major dense matrix type, the resulting data type Type is set to INVALID_TYPE
TDVecDVecMultExprTrait	Evaluation of the expression type of a transpose dense vector/dense vector multiplication.Via this type trait it is possible to evaluate the resulting expression type of a transpose dense vector/dense vector multiplication (inner product). Given the transpose dense vector type VT1 and the non-transpose dense vector type VT2, the nested type Type corresponds to the resulting expression type. In case either VT1 is not a transpose dense vector type or VT2 is not a non-transpose dense vector type, the resulting Type is set to INVALID_TYPE
TDVecEvalExprTrait	Evaluation of the expression type of a dense vector evaluation operation.Via this type trait it is possible to evaluate the resulting expression type of a dense vector evaluation operation. Given the transpose dense vector type VT, the nested type Type corresponds to the resulting expression type. In case either VT is not a transpose dense vector type, the resulting Type is set to INVALID_TYPE
TDVecScalarDivExprTrait	Evaluation of the expression type of a transpose dense vector/scalar division.Via this type trait it is possible to evaluate the resulting expression type of a transpose dense vector/scalar division. Given the transpose dense vector type VT and the scalar type ST, the nested type Type corresponds to the resulting expression type. In case either VT is not a transpose dense vector type or ST is not a scalar type, the resulting Type is set to INVALID_TYPE
TDVecScalarMultExprTrait	Evaluation of the expression type of a transpose dense vector/scalar multiplication.Via this type trait it is possible to evaluate the resulting expression type of a transpose dense vector/scalar multiplication. Given the transpose dense vector type VT and the scalar type ST, the nested type Type corresponds to the resulting expression type. In case either VT is not a transpose dense vector type or ST is not a scalar type, the resulting Type is set to INVALID_TYPE
TDVecSMatMultExprTrait	Evaluation of the expression type of a dense vector/sparse matrix multiplication.Via this type trait it is possible to evaluate the resulting expression type of a dense vector/sparse matrix multiplication. Given the transpose dense vector type VT and the row-major sparse matrix type MT, the nested type Type corresponds to the resulting expression type. In case either VT is not a transpose dense vector type or MT is not a row-major sparse matrix type, the resulting data type Type is set to INVALID_TYPE
TDVecSVecMultExprTrait	Evaluation of the expression type of a transpose dense vector/sparse vector multiplication.Via this type trait it is possible to evaluate the resulting expression type of a transpose dense vector/sparse vector multiplication (inner product). Given the transpose dense vector type VT1 and the non-transpose sparse vector type VT2, the nested type Type corresponds to the resulting expression type. In case either VT1 is not a transpose dense vector type or VT2 is not a non-transpose sparse vector type, the resulting Type is set to INVALID_TYPE
TDVecTDMatMultExprTrait	Evaluation of the expression type of a dense vector/transpose dense matrix multiplication.Via this type trait it is possible to evaluate the resulting expression type of a dense vector/transpose dense matrix multiplication. Given the transpose dense vector type VT and the column-major dense matrix type MT, the nested type Type corresponds to the resulting expression type. In case either VT is not a transpose dense vector type or MT is not a column-major dense matrix type, the resulting data type Type is set to INVALID_TYPE
TDVecTDVecAddExprTrait	Evaluation of the expression type of a transpose dense vector/transpose dense vector addition.Via this type trait it is possible to evaluate the resulting expression type of a transpose dense vector/transpose dense vector addition. Given the two transpose dense vector types VT1 and VT2, the nested type Type corresponds to the resulting expression type. In case either VT1 or VT2 is not a transpose dense vector type, the resulting Type is set to INVALID_TYPE
TDVecTDVecMultExprTrait	Evaluation of the expression type of a transpose dense vector/transpose dense vector multiplication.Via this type trait it is possible to evaluate the resulting expression type of a transpose dense vector/transpose dense vector multiplication. Given the two transpose dense vector types VT1 and VT2, the nested type Type corresponds to the resulting expression type. In case either VT1 or VT2 is not a transpose dense vector type, the resulting Type is set to INVALID_TYPE
TDVecTDVecSubExprTrait	Evaluation of the expression type of a transpose dense vector/transpose dense vector subtraction.Via this type trait it is possible to evaluate the resulting expression type of a transpose dense vector/transpose dense vector subtraction. Given the two transpose dense vector types VT1 and VT2, the nested type Type corresponds to the resulting expression type. In case either VT1 or VT2 is not a transpose dense vector type, the resulting Type is set to INVALID_TYPE
TDVecTransExprTrait	Evaluation of the expression type of a dense vector transpose operation.Via this type trait it is possible to evaluate the resulting expression type of a dense vector transpose operation. Given the transpose dense vector type VT, the nested type Type corresponds to the resulting expression type. In case either VT is not a transpose dense vector type, the resulting Type is set to INVALID_TYPE
TDVecTSMatMultExprTrait	Evaluation of the expression type of a dense vector/transpose sparse matrix multiplication.Via this type trait it is possible to evaluate the resulting expression type of a dense vector/transpose sparse matrix multiplication. Given the transpose dense vector type VT and the column-major sparse matrix type MT, the nested type Type corresponds to the resulting expression type. In case either VT is not a transpose dense vector type or MT is not a column-major sparse matrix type, the resulting data type Type is set to INVALID_TYPE
TDVecTSVecAddExprTrait	Evaluation of the expression type of a transpose dense vector/transpose sparse vector addition.Via this type trait it is possible to evaluate the resulting expression type of a transpose dense vector/transpose sparse vector addition. Given the transpose dense vector type VT1 and the transpose sparse vector type VT2, the nested type Type corresponds to the resulting expression type. In case either VT1 is not a transpose dense vector type or VT2 is not a transpose sparse vector type, the resulting Type is set to INVALID_TYPE
TDVecTSVecMultExprTrait	Evaluation of the expression type of a transpose dense vector/transpose sparse vector multiplication.Via this type trait it is possible to evaluate the resulting expression type of a transpose dense vector/transpose sparse vector multiplication. Given the transpose dense vector type VT1 and the transpose sparse vector type VT2, the nested type Type corresponds to the resulting expression type. In case either VT1 is not a transpose dense vector type or VT2 is not a transpose sparse vector type, the resulting Type is set to INVALID_TYPE
TDVecTSVecSubExprTrait	Evaluation of the expression type of a transpose dense vector/transpose sparse vector subtraction.Via this type trait it is possible to evaluate the resulting expression type of a transpose dense vector/transpose sparse vector subtraction. Given the transpose dense vector type VT1 and the transpose sparse vector type VT2, the nested type Type corresponds to the resulting expression type. In case either VT1 is not a transpose dense vector type or VT2 is not a transpose sparse vector type, the resulting Type is set to INVALID_TYPE
TransExprTrait	Evaluation of the return type of a transpose expression.Via this type trait it is possible to evaluate the return type of a transpose expression. Given the type T, which must either be a vector or matrix type, the nested type Type corresponds to the resulting return type. In case the type of T doesn't fit or if no transpose operation exists for the type, the resulting data type Type is set to INVALID_TYPE
TSMatAbsExprTrait	Evaluation of the expression type of a sparse matrix absolute value operation.Via this type trait it is possible to evaluate the resulting expression type of a sparse matrix absolute value operation. Given the column-major sparse matrix type MT, the nested type Type corresponds to the resulting expression type. In case either MT is not a column-major sparse matrix type, the resulting Type is set to INVALID_TYPE
TSMatDMatAddExprTrait	Evaluation of the expression type of a transpose sparse matrix/dense matrix addition.Via this type trait it is possible to evaluate the resulting expression type of a transpose sparse matrix/dense matrix addition. Given the column-major sparse matrix type MT1 and the row-major dense matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a column-major sparse matrix type or MT2 is not a row-major dense matrix type, the resulting data type Type is set to INVALID_TYPE
TSMatDMatMultExprTrait	Evaluation of the expression type of a transpose sparse matrix/dense matrix multiplication.Via this type trait it is possible to evaluate the resulting expression type of a transpose sparse matrix/dense matrix multiplication. Given the column-major sparse matrix type MT1 and the row-major dense matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a column-major sparse matrix type or MT2 is not a row-major dense matrix type, the resulting data type Type is set to INVALID_TYPE
TSMatDMatSubExprTrait	Evaluation of the expression type of a transpose sparse matrix/dense matrix subtraction.Via this type trait it is possible to evaluate the resulting expression type of a transpose sparse matrix/dense matrix subtraction. Given the column-major sparse matrix type MT1 and the row-major dense matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a column-major sparse matrix type or MT2 is not a row-major dense matrix type, the resulting data type Type is set to INVALID_TYPE
TSMatDVecMultExprTrait	Evaluation of the expression type of a transpose sparse matrix/dense vector multiplication.Via this type trait it is possible to evaluate the resulting expression type of a transpose sparse matrix/dense vector multiplication. Given the column-major sparse matrix type MT and the non-transpose dense vector type VT, the nested type Type corresponds to the resulting expression type. In case either MT is not a column-major sparse matrix type or VT is not a non-transpose dense vector type, the resulting data type Type is set to INVALID_TYPE
TSMatEvalExprTrait	Evaluation of the expression type of a sparse matrix evaluation operation.Via this type trait it is possible to evaluate the resulting expression type of a sparse matrix evaluation operation. Given the column-major sparse matrix type MT, the nested type Type corresponds to the resulting expression type. In case either MT is not a column-major sparse matrix type, the resulting Type is set to INVALID_TYPE
TSMatScalarDivExprTrait	Evaluation of the expression type of a transpose sparse matrix/scalar division.Via this type trait it is possible to evaluate the resulting expression type of a transpose sparse matrix/scalar division. Given the column-major sparse matrix type MT and the scalar type ST, the nested type Type corresponds to the resulting expression type. In case either MT is not a column-major sparse matrix type or ST is not a scalar type, the resulting Type is set to INVALID_TYPE
TSMatScalarMultExprTrait	Evaluation of the expression type of a transpose sparse matrix/scalar multiplication.Via this type trait it is possible to evaluate the resulting expression type of a transpose sparse matrix/scalar multiplication. Given the column-major sparse matrix type MT and the scalar type ST, the nested type Type corresponds to the resulting expression type. In case either MT is not a column-major sparse matrix type or ST is not a scalar type, the resulting Type is set to INVALID_TYPE
TSMatSMatAddExprTrait	Evaluation of the expression type of a transpose sparse matrix/sparse matrix addition.Via this type trait it is possible to evaluate the resulting expression type of a transpose sparse matrix/sparse matrix addition. Given the column-major sparse matrix type MT1 and the row-major sparse matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a column-major sparse matrix type or MT2 is not a row-major sparse matrix type, the resulting data type Type is set to INVALID_TYPE
TSMatSMatMultExprTrait	Evaluation of the expression type of a transpose sparse matrix/sparse matrix multiplication.Via this type trait it is possible to evaluate the resulting expression type of a transpose sparse matrix/sparse matrix multiplication. Given the column-major sparse matrix type MT1 and the row-major sparse matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a column-major sparse matrix type or MT2 is not a row-major sparse matrix type, the resulting data type Type is set to INVALID_TYPE
TSMatSMatSubExprTrait	Evaluation of the expression type of a transpose sparse matrix/sparse matrix subtraction.Via this type trait it is possible to evaluate the resulting expression type of a transpose sparse matrix/sparse matrix subtraction. Given the column-major sparse matrix type MT1 and the row-major sparse matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a column-major sparse matrix type or MT2 is not a row-major sparse matrix type, the resulting data type Type is set to INVALID_TYPE
TSMatSVecMultExprTrait	Evaluation of the expression type of a transpose sparse matrix/sparse vector multiplication.Via this type trait it is possible to evaluate the resulting expression type of a transpose sparse matrix/sparse vector multiplication. Given the column-major sparse matrix type MT and the non-transpose sparse vector type VT, the nested type Type corresponds to the resulting expression type. In case either MT is not a column-major sparse matrix type or VT is not a non-transpose sparse vector type, the resulting data type Type is set to INVALID_TYPE
TSMatTDMatAddExprTrait	Evaluation of the expression type of a transpose sparse matrix/transpose dense matrix addition.Via this type trait it is possible to evaluate the resulting expression type of a transpose sparse matrix/transpose dense matrix addition. Given the column-major sparse matrix type MT1 and the column-major dense matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a column-major sparse matrix type or MT2 is not a column-major dense matrix type, the resulting data type Type is set to INVALID_TYPE
TSMatTDMatMultExprTrait	Evaluation of the expression type of a transpose sparse matrix/transpose dense matrix multiplication.Via this type trait it is possible to evaluate the resulting expression type of a transpose sparse matrix/transpose dense matrix multiplication. Given the column-major sparse matrix type MT1 and the column-major dense matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a column-major sparse matrix type or MT2 is not a column-major dense matrix type, the resulting data type Type is set to INVALID_TYPE
TSMatTDMatSubExprTrait	Evaluation of the expression type of a transpose sparse matrix/transpose dense matrix subtraction.Via this type trait it is possible to evaluate the resulting expression type of a transpose sparse matrix/transpose dense matrix subtraction. Given the column-major sparse matrix type MT1 and the column-major dense matrix type MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 is not a column-major sparse matrix type or MT2 is not a column-major dense matrix type, the resulting data type Type is set to INVALID_TYPE
TSMatTransExprTrait	Evaluation of the expression type of a sparse matrix transpose operation.Via this type trait it is possible to evaluate the resulting expression type of a sparse matrix transpose operation. Given the column-major sparse matrix type MT, the nested type Type corresponds to the resulting expression type. In case either MT is not a column-major sparse matrix type, the resulting Type is set to INVALID_TYPE
TSMatTSMatAddExprTrait	Evaluation of the expression type of a transpose sparse matrix/transpose sparse matrix addition.Via this type trait it is possible to evaluate the resulting expression type of a transpose sparse matrix/transpose sparse matrix addition. Given the two column-major sparse matrix types MT1 and MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 or MT2 is not a column-major sparse matrix, the resulting data type Type is set to INVALID_TYPE
TSMatTSMatMultExprTrait	Evaluation of the expression type of a transpose sparse matrix/transpose sparse matrix multiplication.Via this type trait it is possible to evaluate the resulting expression type of a transpose sparse matrix/transpose sparse matrix multiplication. Given the two column-major sparse matrix types MT1 and MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 or MT2 is not a column-major sparse matrix, the resulting data type Type is set to INVALID_TYPE
TSMatTSMatSubExprTrait	Evaluation of the expression type of a transpose sparse matrix/transpose sparse matrix subtraction.Via this type trait it is possible to evaluate the resulting expression type of a transpose sparse matrix/transpose sparse matrix subtraction. Given the two column-major sparse matrix types MT1 and MT2, the nested type Type corresponds to the resulting expression type. In case either MT1 or MT2 is not a column-major sparse matrix, the resulting data type Type is set to INVALID_TYPE
TSVecAbsExprTrait	Evaluation of the expression type of a sparse vector absolute value operation.Via this type trait it is possible to evaluate the resulting expression type of a sparse vector absolute value operation. Given the transpose sparse vector type VT, the nested type Type corresponds to the resulting expression type. In case either VT is not a transpose sparse vector type, the resulting Type is set to INVALID_TYPE
TSVecDMatMultExprTrait	Evaluation of the expression type of a sparse vector/dense matrix multiplication.Via this type trait it is possible to evaluate the resulting expression type of a sparse vector/dense matrix multiplication. Given the transpose sparse vector type VT and the row-major dense matrix type MT, the nested type Type corresponds to the resulting expression type. In case either VT is not a transpose sparse vector type or MT is not a row-major dense matrix type, the resulting data type Type is set to INVALID_TYPE
TSVecDVecMultExprTrait	Evaluation of the expression type of a transpose sparse vector/dense vector multiplication.Via this type trait it is possible to evaluate the resulting expression type of a transpose sparse vector/dense vector multiplication (inner product). Given the transpose sparse vector type VT1 and the non-transpose dense vector type VT2, the nested type Type corresponds to the resulting expression type. In case either VT1 is not a transpose sparse vector type or VT2 is not a non-transpose dense vector type, the resulting Type is set to INVALID_TYPE
TSVecEvalExprTrait	Evaluation of the expression type of a sparse vector evaluation operation.Via this type trait it is possible to evaluate the resulting expression type of a sparse vector evaluation operation. Given the transpose sparse vector type VT, the nested type Type corresponds to the resulting expression type. In case either VT is not a transpose sparse vector type, the resulting Type is set to INVALID_TYPE
TSVecScalarDivExprTrait	Evaluation of the expression type of a transpose sparse vector/scalar division.Via this type trait it is possible to evaluate the resulting expression type of a transpose sparse vector/scalar division. Given the transpose sparse vector type VT and the scalar type ST, the nested type Type corresponds to the resulting expression type. In case either VT is not a transpose sparse vector type or ST is not a scalar type, the resulting Type is set to INVALID_TYPE
TSVecScalarMultExprTrait	Evaluation of the expression type of a transpose sparse vector/scalar multiplication.Via this type trait it is possible to evaluate the resulting expression type of a transpose sparse vector/scalar multiplication. Given the transpose sparse vector type VT and the scalar type ST, the nested type Type corresponds to the resulting expression type. In case either VT is not a transpose sparse vector type or ST is not a scalar type, the resulting Type is set to INVALID_TYPE
TSVecSMatMultExprTrait	Evaluation of the expression type of a sparse vector/sparse matrix multiplication.Via this type trait it is possible to evaluate the resulting expression type of a sparse vector/sparse matrix multiplication. Given the transpose sparse vector type VT and the row-major sparse matrix type MT, the nested type Type corresponds to the resulting expression type. In case either VT is not a transpose sparse vector type or MT is not a row-major sparse matrix type, the resulting data type Type is set to INVALID_TYPE
TSVecSVecMultExprTrait	Evaluation of the expression type of a transpose sparse vector/sparse vector multiplication.Via this type trait it is possible to evaluate the resulting expression type of a transpose sparse vector/sparse vector multiplication (inner product). Given the transpose sparse vector type VT1 and the non-transpose sparse vector type VT2, the nested type Type corresponds to the resulting expression type. In case either VT1 is not a transpose sparse vector type or VT2 is not a non-transpose sparse vector type, the resulting Type is set to INVALID_TYPE
TSVecTDMatMultExprTrait	Evaluation of the expression type of a sparse vector/transpose dense matrix multiplication.Via this type trait it is possible to evaluate the resulting expression type of a sparse vector/transpose dense matrix multiplication. Given the transpose sparse vector type VT and the column-major dense matrix type MT, the nested type Type corresponds to the resulting expression type. In case either VT is not a transpose sparse vector type or MT is not a column-major dense matrix type, the resulting data type Type is set to INVALID_TYPE
TSVecTDVecAddExprTrait	Evaluation of the expression type of a transpose sparse vector/transpose dense vector addition.Via this type trait it is possible to evaluate the resulting expression type of a transpose sparse vector/transpose dense vector addition. Given the transpose sparse vector type VT1 and the transpose dense vector type VT2, the nested type Type corresponds to the resulting expression type. In case either VT1 is not a transpose sparse vector type or VT2 is not a transpose dense vector type, the resulting Type is set to INVALID_TYPE
TSVecTDVecMultExprTrait	Evaluation of the expression type of a transpose sparse vector/transpose dense vector multiplication.Via this type trait it is possible to evaluate the resulting expression type of a transpose sparse vector/transpose dense vector multiplication. Given the transpose sparse vector type VT1 and the transpose dense vector type VT2, the nested type Type corresponds to the resulting expression type. In case either VT1 is not a transpose sparse vector type or VT2 is not a transpose dense vector type, the resulting Type is set to INVALID_TYPE
TSVecTDVecSubExprTrait	Evaluation of the expression type of a transpose sparse vector/transpose dense vector subtraction.Via this type trait it is possible to evaluate the resulting expression type of a transpose sparse vector/transpose dense vector subtraction. Given the transpose sparse vector type VT1 and the transpose dense vector type VT2, the nested type Type corresponds to the resulting expression type. In case either VT1 is not a transpose sparse vector type or VT2 is not a transpose dense vector type, the resulting Type is set to INVALID_TYPE
TSVecTransExprTrait	Evaluation of the expression type of a sparse vector transpose operation.Via this type trait it is possible to evaluate the resulting expression type of a sparse vector transpose operation. Given the transpose sparse vector type VT, the nested type Type corresponds to the resulting expression type. In case either VT is not a transpose sparse vector type, the resulting Type is set to INVALID_TYPE
TSVecTSMatMultExprTrait	Evaluation of the expression type of a sparse vector/transpose sparse matrix multiplication.Via this type trait it is possible to evaluate the resulting expression type of a sparse vector/transpose sparse matrix multiplication. Given the transpose sparse vector type VT and the column-major sparse matrix type MT, the nested type Type corresponds to the resulting expression type. In case either VT is not a transpose sparse vector type or MT is not a column-major sparse matrix type, the resulting data type Type is set to INVALID_TYPE
TSVecTSVecAddExprTrait	Evaluation of the expression type of a transpose sparse vector/transpose sparse vector addition.Via this type trait it is possible to evaluate the resulting expression type of a transpose sparse vector/transpose sparse vector addition. Given the two transpose sparse vector types VT1 and VT2, the nested type Type corresponds to the resulting expression type. In case either VT1 or VT2 is not a transpose sparse vector type, the resulting Type is set to INVALID_TYPE
TSVecTSVecMultExprTrait	Evaluation of the expression type of a transpose sparse vector/transpose sparse vector multiplication.Via this type trait it is possible to evaluate the resulting expression type of a transpose sparse vector/transpose sparse vector multiplication. Given the two transpose sparse vector types VT1 and VT2, the nested type Type corresponds to the resulting expression type. In case either VT1 or VT2 is not a transpose sparse vector type, the resulting Type is set to INVALID_TYPE
TSVecTSVecSubExprTrait	Evaluation of the expression type of a transpose sparse vector/transpose sparse vector subtraction.Via this type trait it is possible to evaluate the resulting expression type of a transpose sparse vector/transpose sparse vector subtraction. Given the two transpose sparse vector types VT1 and VT2, the nested type Type corresponds to the resulting expression type. In case either VT1 or VT2 is not a transpose sparse vector type, the resulting Type is set to INVALID_TYPE
BaseElementType	Evaluation of the base element type of a given data type.Via this type trait it is possible to evaluate the base (fundamental) element type at the heart of a given data type. Examples:
IsAbsExpr	Compile time check whether the given type is an absolute value expression template.This type trait class tests whether or not the given type Type is an absolute value expression template. In order to qualify as a valid absolute value expression template, the given type has to derive (publicly or privately) from the AbsExpr base class. In case the given type is a valid absolute value expression template, the value member enumeration is set to 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to 0, Type is FalseType, and the class derives from FalseType
IsAddExpr	Compile time check whether the given type is an addition expression template.This type trait class tests whether or not the given type Type is an addition expression template (i.e. an expression representing a vector addition or a matrix addition). In order to qualify as a valid addition expression template, the given type has to derive (publicly or privately) from the AddExpr base class. In case the given type is a valid addition expression template, the value member enumeration is set to 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to 0, Type is FalseType, and the class derives from FalseType
IsBlasCompatible	Compile time check for data types.This type trait tests whether or not the given template parameter is a data type compatible to the BLAS standard. The BLAS standard currently only supports float, double, complex<float> and complex<double> values. If the type is BLAS compatible, the value member enumeration is set to 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to 0, Type is FalseType, and the class derives from FalseType
IsColumn	Compile time check for columns.This type trait tests whether or not the given template parameter is a column (i.e. dense or sparse column). In case the type is a column, the value member enumeration is set to 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to 0, Type is FalseType, and the class derives from FalseType
IsColumnMajorMatrix	Compile time check for column-major matrix types.This type trait tests whether or not the given template argument is a column-major dense or sparse matrix type (i.e., a matrix whose storage order is set to true). In case the type is a column-major matrix type, the value member enumeration is set to 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to 0, Type is FalseType, and the class derives from FalseType
IsColumnVector	Compile time check for column vector types.This type trait tests whether or not the given template argument is a column dense or sparse vector type (i.e. a vector whose transposition flag is set to blaze::columnVector). In case the type is a column vector type, the value member enumeration is set to 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to 0, Type is FalseType, and the class derives from FalseType
IsComputation	Compile time check whether the given type is a computational expression template.This type trait class tests whether or not the given type Type is a computational expression template (i.e. a mathematical operation such as an addition, a subtraction, a multiplication, a division, an absolute value calculation, ...). In order to qualify as a valid computational expression template, the given type has to derive (publicly or privately) from the Computation base class. In case the given type is a valid computational expression template, the value member enumeration is set to 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to 0, Type is FalseType, and the class derives from FalseType
IsCrossExpr	Compile time check whether the given type is a cross product expression template.This type trait class tests whether or not the given type Type is a cross product expression template. In order to qualify as a valid cross product expression template, the given type has to derive (publicly or privately) from the CrossExpr base class. In case the given type is a valid cross product expression template, the value member enumeration is set to 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to 0, Type is FalseType, and the class derives from FalseType
IsDenseMatrix	Compile time check for dense matrix types.This type trait tests whether or not the given template parameter is a dense, N-dimensional matrix type. In case the type is a dense matrix type, the value member enumeration is set to 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise yes is set to 0, Type is FalseType, and the class derives from FalseType
IsDenseVector	Compile time check for dense vector types.This type trait tests whether or not the given template parameter is a dense, N-dimensional vector type. In case the type is a dense vector type, the value member enumeration is set to 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to 0, Type is FalseType, and the class derives from FalseType
IsDivExpr	Compile time check whether the given type is a division expression template.This type trait class tests whether or not the given type Type is a division expression template (i.e. an expression representing a vector/scalar division or a matrix/scalar division). In order to qualify as a valid division expression template, the given type has to derive (publicly or privately) from the DivExpr base class. In case the given type is a valid division expression template, the value member enumeration is set to 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to 0, Type is FalseType, and the class derives from FalseType
IsEvalExpr	Compile time check whether the given type is an evaluation expression template.This type trait class tests whether or not the given type Type is an evaluation expression template. In order to qualify as a valid evaluation expression template, the given type has to derive (publicly or privately) from the EvalExpr base class. In case the given type is a valid evaluation expression template, the value member enumeration is set to 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to 0, Type is FalseType, and the class derives from FalseType
IsExpression	Compile time check whether the given type is an expression template.This type trait class tests whether or not the given type Type is a Blaze expression template. In order to qualify as a valid expression template, the given type has to derive (publicly or privately) from the Expression base class. In case the given type is a valid expression template, the value member enumeration is set to 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to 0, Type is FalseType, and the class derives from FalseType
IsMatAbsExpr	Compile time check whether the given type is a matrix absolute value expression template.This type trait class tests whether or not the given type Type is a matrix absolute value expression template. In order to qualify as a valid matrix absolute value expression template, the given type has to derive (publicly or privately) from the MatAbsExpr base class. In case the given type is a valid matrix absolute value expression template, the value member enumeration is set to 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to 0, Type is FalseType, and the class derives from FalseType
IsMatEvalExpr	Compile time check whether the given type is a matrix evaluation expression template.This type trait class tests whether or not the given type Type is a matrix evaluation expression template. In order to qualify as a valid matrix evaluation expression template, the given type has to derive (publicly or privately) from the MatEvalExpr base class. In case the given type is a valid matrix evaluation expression template, the value member enumeration is set to 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to 0, Type is FalseType, and the class derives from FalseType
IsMatMatAddExpr	Compile time check whether the given type is a matrix/matrix addition expression template.This type trait class tests whether or not the given type Type is a matrix/matrix addition expression template. In order to qualify as a valid matrix addition expression template, the given type has to derive (publicly or privately) from the MatMatAddExpr base class. In case the given type is a valid matrix addition expression template, the value member enumeration is set to 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to 0, Type is FalseType, and the class derives from FalseType
IsMatMatMultExpr	Compile time check whether the given type is a matrix/matrix multiplication expression template.This type trait class tests whether or not the given type Type is a matrix/matrix multiplication expression template. In order to qualify as a valid matrix multiplication expression template, the given type has to derive (publicly or privately) from the MatMatMultExpr base class. In case the given type is a valid matrix multiplication expression template, the value member enumeration is set to 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to 0, Type is FalseType, and the class derives from FalseType
IsMatMatSubExpr	Compile time check whether the given type is a matrix/matrix subtraction expression template.This type trait class tests whether or not the given type Type is a matrix/matrix subtraction expression template. In order to qualify as a valid matrix subtraction expression template, the given type has to derive (publicly or privately) from the MatMatSubExpr base class. In case the given type is a valid matrix subtraction expression template, the value member enumeration is set to 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to 0, Type is FalseType, and the class derives from FalseType
IsMatrix	Compile time check for matrix types.This type trait tests whether or not the given template parameter is a N-dimensional dense or sparse matrix type. In case the type is a matrix type, the value member enumeration is set to 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise yes is set to 0, Type is FalseType, and the class derives from FalseType
IsMatScalarDivExpr	Compile time check whether the given type is a matrix/scalar division expression template.This type trait class tests whether or not the given type Type is a matrix/scalar division expression template. In order to qualify as a valid matrix/scalar division expression template, the given type has to derive (publicly or privately) from the MatScalarDivExpr base class. In case the given type is a valid matrix/scalar division expression template, the value member enumeration is set to 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to 0, Type is FalseType, and the class derives from FalseType
IsMatScalarMultExpr	Compile time check whether the given type is a matrix/scalar multiplication expression template.This type trait class tests whether or not the given type Type is a matrix/scalar multiplication expression template. In order to qualify as a valid matrix/scalar multiplication expression template, the given type has to derive (publicly or privately) from the MatScalarMultExpr base class. In case the given type is a valid matrix/scalar multiplication expression template, the value member enumeration is set to 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to 0, Type is FalseType, and the class derives from FalseType
IsMatTransExpr	Compile time check whether the given type is a matrix transposition expression template.This type trait class tests whether or not the given type Type is a matrix transposition expression template. In order to qualify as a valid matrix transposition expression template, the given type has to derive (publicly or privately) from the MatTransExpr base class. In case the given type is a valid matrix transposition expression template, the value member enumeration is set to 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to 0, Type is FalseType, and the class derives from FalseType
IsMatVecMultExpr	Compile time check whether the given type is a matrix/vector multiplication expression template.This type trait class tests whether or not the given type Type is a matrix/vector multiplication expression template. In order to qualify as a valid matrix/vector multiplication expression template, the given type has to derive (publicly or privately) from the MatVecMultExpr base class. In case the given type is a valid matrix/vector multiplication expression template, the value member enumeration is set to 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to 0, Type is FalseType, and the class derives from FalseType
IsMultExpr	Compile time check whether the given type is a multiplication expression template.This type trait class tests whether or not the given type Type is a multiplication expression template (i.e. an expression representing an element-wise vector multiplication, a matrix/vector multiplication, a vector/matrix multiplication, or a matrix multiplication). In order to qualify as a valid multiplication expression template, the given type has to derive (publicly or privately) from the MultExpr base class. In case the given type is a valid multiplication expression template, the value member enumeration is set to 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to 0, Type is FalseType, and the class derives from FalseType
IsResizable	Compile time check for resizable data types.This type trait tests whether the given data type is a resizable data type. In case the data type can be resized (via the resize() function), the value member enumeration is set to 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to 0, Type is FalseType, and the class derives from FalseType. Examples:
IsRow	Compile time check for rows.This type trait tests whether or not the given template parameter is a row (i.e. dense or sparse row). In case the type is a row, the value member enumeration is set to 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to 0, Type is FalseType, and the class derives from FalseType
IsRowMajorMatrix	Compile time check for row-major matrix types.This type trait tests whether or not the given template argument is a row-major dense or sparse matrix type (i.e., a matrix whose storage order is set to true). In case the type is a row-major matrix type, the value member enumeration is set to 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to 0, Type is FalseType, and the class derives from FalseType
IsRowVector	Compile time check for row vector types.This type trait tests whether or not the given template argument is a row dense or sparse vector type (i.e. a vector whose transposition flag is set to blaze::rowVector). In case the type is a row vector type, the value member enumeration is set to 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to 0, Type is FalseType, and the class derives from FalseType
IsSparseElement	Compile time check whether the given type is a sparse element type.This type trait class tests whether or not the given type Type is a Blaze sparse element type, i.e. if the type implements the sparse element concept by providing a value() and an index() member function. In order to qualify as a valid sparse element type, the given type has to derive (publicly or privately) from the SparseElement base class. In case the given type is a valid sparse element, the value member enumeration is set to 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to 0, Type is FalseType, and the class derives from FalseType
IsSparseMatrix	Compile time check for sparse matrix types.This type trait tests whether or not the given template parameter is a sparse, N-dimensional matrix type. In case the type is a sparse matrix type, the value member enumeration is set to 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to 0, Type is FalseType, and the class derives from FalseType
IsSparseVector	Compile time check for sparse vector types.This type trait tests whether or not the given template parameter is a sparse, N-dimensional vector type. In case the type is a sparse vector type, the value member enumeration is set to 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to 0, Type is FalseType, and the class derives from FalseType
IsSubExpr	Compile time check whether the given type is a subtraction expression template.This type trait class tests whether or not the given type Type is a subtraction expression template (i.e. an expression representing a vector subtraction or a matrix subtraction). In order to qualify as a valid subtraction expression template, the given type has to derive (publicly or privately) from the SubExpr base class. In case the given type is a valid subtraction expression template, the value member enumeration is set to 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to 0, Type is FalseType, and the class derives from FalseType
IsSubmatrix	Compile time check for submatrices.This type trait tests whether or not the given template parameter is a submatrix (i.e. dense or sparse submatrix). In case the type is a submatrix, the value member enumeration is set to 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to 0, Type is FalseType, and the class derives from FalseType
IsSubvector	Compile time check for subvectors.This type trait tests whether or not the given template parameter is a subvector (i.e. dense or sparse subvector). In case the type is a subvector, the value member enumeration is set to 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to 0, Type is FalseType, and the class derives from FalseType
IsTemporary	Compile time check whether the given type is a temporary vector or matrix type.This type trait class tests whether the given type is a temporary vector or matrix type, i.e. can be used for a temporary vector or matrix. In case the given type can be used as temporary, the value member enumeration is set to 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to 0, Type is FalseType, and the class derives from FalseType
IsTransExpr	Compile time check whether the given type is a transposition expression template.This type trait class tests whether or not the given type Type is a transposition expression template (i.e. an expression representing a vector transposition or a matrix transposition). In order to qualify as a valid transposition expression template, the given type has to derive (publicly or privately) from the TransExpr base class. In case the given type is a valid transposition expression template, the value member enumeration is set to 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to 0, Type is FalseType, and the class derives from FalseType
IsTVecMatMultExpr	Compile time check whether the given type is a vector/matrix multiplication expression template.This type trait class tests whether or not the given type Type is a vector/matrix multiplication expression template. In order to qualify as a valid vector/matrix multiplication expression template, the given type has to derive (publicly or privately) from the TVecMatMultExpr base class. In case the given type is a valid vector/matrix multiplication expression template, the value member enumeration is set to 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to 0, Type is FalseType, and the class derives from FalseType
IsVecAbsExpr	Compile time check whether the given type is a vector absolute value expression template.This type trait class tests whether or not the given type Type is a vector absolute value expression template. In order to qualify as a valid vector absolute value expression template, the given type has to derive (publicly or privately) from the VecAbsExpr base class. In case the given type is a valid vector absolute value expression template, the value member enumeration is set to 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to 0, Type is FalseType, and the class derives from FalseType
IsVecEvalExpr	Compile time check whether the given type is a vector evaluation expression template.This type trait class tests whether or not the given type Type is a vector evaluation expression template. In order to qualify as a valid vector evaluation expression template, the given type has to derive (publicly or privately) from the VecEvalExpr base class. In case the given type is a valid vector evaluation expression template, the value member enumeration is set to 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to 0, Type is FalseType, and the class derives from FalseType
IsVecScalarDivExpr	Compile time check whether the given type is a vector/scalar division expression template.This type trait class tests whether or not the given type Type is a vector/scalar division expression template. In order to qualify as a valid vector/scalar division expression template, the given type has to derive (publicly or privately) from the VecScalarDivExpr base class. In case the given type is a valid vector/scalar division expression template, the value member enumeration is set to 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to 0, Type is FalseType, and the class derives from FalseType
IsVecScalarMultExpr	Compile time check whether the given type is a vector/scalar multiplication expression template.This type trait class tests whether or not the given type Type is a vector/scalar multiplication expression template. In order to qualify as a valid vector/scalar multiplication expression template, the given type has to derive (publicly or privately) from the VecScalarMultExpr base class. In case the given type is a valid vector/scalar multiplication expression template, the value member enumeration is set to 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to 0, Type is FalseType, and the class derives from FalseType
IsVector	Compile time check for vector types.This type trait tests whether or not the given template parameter is a N-dimensional dense or sparse vector type. In case the type is a vector type, the value member enumeration is set to 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to 0, Type is FalseType, and the class derives from FalseType
IsVecTransExpr	Compile time check whether the given type is a vector transposition expression template.This type trait class tests whether or not the given type Type is a vector transposition expression template. In order to qualify as a valid vector transposition expression template, the given type has to derive (publicly or privately) from the VecTransExpr base class. In case the given type is a valid vector transposition expression template, the value member enumeration is set to 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to 0, Type is FalseType, and the class derives from FalseType
IsVecTVecMultExpr	Compile time check whether the given type is an outer product expression template.This type trait class tests whether or not the given type Type is an outer product expression template (i.e. an expression representing the multiplication between a column vector and a row vector). In order to qualify as a valid outer product expression template, the given type has to derive (publicly or privately) from the VecTVecMultExpr base class. In case the given type is a valid outer product expression template, the value member enumeration is set to 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to 0, Type is FalseType, and the class derives from FalseType
IsVecVecAddExpr	Compile time check whether the given type is a vector/vector addition expression template.This type trait class tests whether or not the given type Type is a vector/vector addition expression template. In order to qualify as a valid vector addition expression template, the given type has to derive (publicly or privately) from the VecVecAddExpr base class. In case the given type is a valid vector addition expression template, the value member enumeration is set to 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to 0, Type is FalseType, and the class derives from FalseType
IsVecVecMultExpr	Compile time check whether the given type is a vector/vector multiplication expression template.This type trait class tests whether or not the given type Type is a vector/vector multiplication expression template. In order to qualify as a valid vector multiplication expression template, the given type has to derive (publicly or privately) from the VecVecMultExpr base class. In case the given type is a valid vector multiplication expression template, the value member enumeration is set to 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to 0, Type is FalseType, and the class derives from FalseType
IsVecVecSubExpr	Compile time check whether the given type is a vector/vector subtraction expression template.This type trait class tests whether or not the given type Type is a vector/vector subtraction expression template. In order to qualify as a valid vector subtraction expression template, the given type has to derive (publicly or privately) from the VecVecSubExpr base class. In case the given type is a valid vector subtraction expression template, the value member enumeration is set to 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to 0, Type is FalseType, and the class derives from FalseType
IsView	Compile time check for views.This type trait tests whether or not the given template parameter is a view (i.e. subvector, submatrix, row, column, ...). In case the type is a view, the value member enumeration is set to 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to 0, Type is FalseType, and the class derives from FalseType
NumericElementType	Evaluation of the numeric element type of a given data type.Via this type trait it is possible to evaluate the numeric (fundamental or complex) element type at the heart of a given data type. Examples:
RequiresEvaluation	Compile time check to query the requirement to evaluate an expression.Via this type trait it is possible to determine whether a given vector or matrix expression type requires an intermediate evaluation in the context of a compound expression. In case the given type requires an evaluation, the value member enumeration is set to 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to 0, Type is FalseType, and the class derives from FalseType
DenseColumn	Reference to a specific column of a dense matrix.The DenseColumn template represents a reference to a specific column of a dense matrix primitive. The type of the dense matrix is specified via the first template parameter:
DenseRow	Reference to a specific row of a dense matrix.The DenseRow template represents a reference to a specific row of a dense matrix primitive. The type of the dense matrix is specified via the first template parameter:
DenseSubmatrix	View on a specific submatrix of a dense matrix.The DenseSubmatrix template represents a view on a specific submatrix of a dense matrix primitive. The type of the dense matrix is specified via the first template parameter:
SubmatrixIterator	Iterator over the elements of the sparse submatrix
DenseSubvector	View on a specific subvector of a dense vector.The DenseSubvector template represents a view on a specific subvector of a dense vector primitive. The type of the dense vector is specified via the first template parameter:
SubvectorIterator	Iterator over the elements of the sparse subvector
SparseColumn	Reference to a specific column of a sparse matrix.The SparseColumn template represents a reference to a specific column of a sparse matrix primitive. The type of the sparse matrix is specified via the first template parameter:
SparseRow	Reference to a specific row of a sparse matrix.The SparseRow template represents a reference to a specific row of a sparse matrix primitive. The type of the sparse matrix is specified via the first template parameter:
SparseSubmatrix	View on a specific submatrix of a sparse matrix.The SparseSubmatrix template represents a view on a specific submatrix of a sparse matrix primitive. The type of the sparse matrix is specified via the first template parameter:
SubmatrixElement	Access proxy for a specific element of the sparse submatrix
SubmatrixIterator	Iterator over the elements of the sparse submatrix
SparseSubvector	View on a specific subvector of a sparse vector.The SparseSubvector template represents a view on a specific subvector of a sparse vector primitive. The type of the sparse vector is specified via the first template parameter:
SubvectorElement	Access proxy for a specific element of the sparse subvector
SubvectorIterator	Iterator over the elements of the sparse subvector
AlignedAllocator	Allocator for type-specific aligned memory.The AlignedAllocator class template represents an implementation of the allocator concept of the standard library for the allocation of type-specific, aligned, uninitialized memory. The allocator performs its allocation via the blaze::allocate() and blaze::deallocate() functions to guarantee properly aligned memory based on the alignment restrictions of the specified type Type. For instance, in case the given type is a fundamental, built-in data type and in case SSE vectorization is possible, the returned memory is guaranteed to be at least 16-byte aligned. In case AVX is active, the memory is even guaranteed to be at least 32-byte aligned
rebind	Implementation of the AlignedAllocator rebind mechanism
AlignedArray	Implementation of a static array with a fixed alignment.The AlignedArray class template represents a static array with a guaranteed, fixed alignment. The type of the array elements, the number of elements and the alignment of the array can be specified via the three template parameters:
AlignedStorage	POD data type with a fixed alignment.The AlignedStorage class template represents a POD data type with a fixed alignment. Via this class it is possible to enforce a specific, type-based alignment for static data types. The required alignment is evaluated based on the given data type T. In case T is a built-in, vectorizable data type, AlignedStorage enforces an alignment of 16 or 32 bytes, depending on the active SSE/AVX level. In all other cases, no specific alignment is enforced
AlignmentTrait	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
DisableIfTrue	Substitution Failure Is Not An Error (SFINAE) class.The DisableIfTrue class template is an auxiliary tool for an intentional application of the Substitution Failure Is Not An Error (SFINAE) principle. It allows a function template or a class template specialization to include or exclude itself from a set of matching functions or specializations based on properties of its template arguments. For instance, it can be used to restrict the selection of a function template to specific data types. The following example illustrates this in more detail
DisableIf	Substitution Failure Is Not An Error (SFINAE) class.The DisableIf class template is an auxiliary tool for an intentional application of the Substitution Failure Is Not An Error (SFINAE) principle. It allows a function template or a class template specialization to include or exclude itself from a set of matching functions or specializations based on properties of its template arguments. For instance, it can be used to restrict the selection of a function template to specific data types. The following example illustrates this in more detail
EmptyType	Empty data type for utility purposes
EnableIfTrue	Substitution Failure Is Not An Error (SFINAE) class.The EnableIfTrue class template is an auxiliary tool for an intentional application of the Substitution Failure Is Not An Error (SFINAE) principle. It allows a function template or a class template specialization to include or exclude itself from a set of matching functions or specializations based on properties of its template arguments. For instance, it can be used to restrict the selection of a function template to specific data types. The following example illustrates this in more detail
EnableIf	Substitution Failure Is Not An Error (SFINAE) class.The EnableIf class template is an auxiliary tool for an intentional application of the Substitution Failure Is Not An Error (SFINAE) principle. It allows a function template or a class template specialization to include or exclude itself from a set of matching functions or specializations based on properties of its template arguments. For instance, it can be used to restrict the selection of a function template to specific data types. The following example illustrates this in more detail
InputString	Implementation of a string wrapper.The InputString class is a wrapper class for the purpose to read input strings delimited by quotations from streams, like for instance "example input". All characters between the leading and the trailing quotation are extracted unchanged from the input stream, including whitespaces. The input string has to be in one single line. In case of input errors, the std::istream::failbit of the input stream is set
Limits	Numerical limits of built-in data types.The Limits class provides numerical limits for the following built-in data types:
MemoryPool	Memory pool for small objects.The memory pool efficiently improves the performance of dynamic memory allocations for small objects. By allocating a large block of memory that can be dynamically assigned to small objects, the memory allocation is reduced from a few hundred cycles to only a few cycles. The memory pool is build from memory blocks of type Block, which hold the memory for a specified number of objects. The memory of these blocks is managed as a single free list
Block	Memory block within the memory bool
FreeObject	A single element of the free list of the memory pool
And	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:
EqualTo	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
IfTrue	Compile time type selection.The IfTrue class template selects one of the two given types T1 and T2 depending on the Condition template argument. In case the Condition compile time constant expression evaluates to true, the member type definition Type is set to T1. In case Condition evaluates to false, Type is set to T2
If	Compile time type selection.The If class template selects one of the two given types T2 and T3 depending on T1. In case T1::value evaluates to true, the member type definition Type is set to T2. In case T1::value evaluates to false, Type is set to T3
Not	Compile time type negation.The Not class template negates the given compile time condition. In case the given condition would evaluate to true, the nested member enumeration is set to false and vice versa:
Or	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:
NonCopyable	Base class for non-copyable class instances.The NonCopyable class is intended to work as a base class for non-copyable classes. Both the copy constructor and the copy assignment operator are declared private and left undefined in order to prohibit copy operations of the derived classes.
NonCreatable	Base class for non-creatable (static) classes.The NonCreatable class is intended to work as a base class for non-creatable classes, i.e. classes that cannot be instantiated and exclusively offer static functions/data. Both the standard as well as the copy constructor and the copy assignment operator are declared private and left undefinded in order to prohibit the instantiation of objects of derived classes.
Null	Safe C++ NULL pointer implementation.This implementation offers a remedy for the use of the NULL pointer in C++. For this, the NULL macro is replaced by an instance of the Null class, which can only be assigned and compared with pointers and pointers-to-member. Therefore the use of NULL regains the type safety it lost in C++ due to the strict C++ type system. The NULL pointer is used exactly as before:
NullType	Utility type for generic codes.The NullType class represents an invalid or terminating data type for generic codes. For instance, the TypeList class uses the NullType as terminating data type for the type list
ArrayDelete	Array-delete policy class.The ArrayDelete policy functor class applies an array delete operation to the given argument. Note that the array delete operation is NOT permitted for inclomplete types (i.e. declared but undefined data types). The attempt to apply an ArrayDelete functor to a pointer to an array of objects of incomplete type results in a compile time error!
ConstantGrowth	Constant growth policy class.The ConstantGrowth policy class implements a constant growth strategy. It can be customized for any purpose: the Growth template argument specifies the constant increase of the given size
Deallocate	Deallocate policy class.The Deallocate deletion policy is the according deletion policy for arrays allocated via the blaze::allocate function. It uses deallocate to free the resource. Note that the delete operation is NOT permitted for inclomplete types (i.e. declared but undefined data types). The attempt to apply a PtrDelete functor to a pointer to an object of incomplete type results in a compile time error!
DefaultDelete	Default C++ deletion policy class.The DefaultDelete deletion policy is the standard delete for resources allocated via the new operator. It uses delete or array delete (depending on the template argument) to free the resource:
LinearGrowth	Linear growth policy class.The LinearGrowth policy class implements a linear growth strategy. It can be customized for any purpose: the Growth template argument specifies the factor of the size growth
NoDelete	No-delete policy class
OptimalGrowth	Optimal growth policy class.The OptimalGrowth policy class implements the optimal growth strategy suggested by Andrew Koenig for the std::vector class (see Andrew Koenig's column in the September 1998 issue of JOOP (Journal of Object-Oriented Programming), or the Dr. Dobb's article 'C++ Made Easier: How Vectors Grow', 2001). It applies an exponential growth strategy using a factor of 1.5 and additionally ensures that the sizes returns are always multiples of four
PtrDelete	Pointer-delete policy class.The PtrDelete policy functor class applies a delete operation to the given argument. Note that the delete operation is NOT permitted for inclomplete types (i.e. declared but undefined data types). The attempt to apply a PtrDelete functor to a pointer to an object of incomplete type results in a compile time error!
PtrIterator	Implementation of an iterator for pointer vectors.The PtrIterator class follows the example of the random-access iterator classes of the STL. However, the focus of this iterator implementation is the use with (polymorphic) pointers. The implementation of the Blaze library eases the use of iterators over a range of pointers and improves the semantics on these pointers.
PtrVector	Implementation of a vector for (polymorphic) pointers
CastIterator	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
ConstCastIterator	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
Rand	Default implementation of the Rand class for integral data types.This default implementation of the Rand class creates random, integral numbers in the range , where max is the maximal value of the given data type T
Random	Random number generator.The Random class encapsulates the initialization of the given random number generator with a pseudo-random seed obtained by the std::time() function. Currently, the mersenne-twister mt19937 as provided by the boost library is used per default. For more information see the class description of the boost library:
SelectType	Compile time type selection.The SelectType class template selects one of the two given types T1 and T2 depending on the Select template argument. In case the Select compile time constant expression evaluates to true, the member type definition Type is set to T1. In case Select evaluates to false, Type is set to T2
Archive	Binary archive for the portable serialization of data.The Archive class implements the functionality to create platform independent, portable, representations of arbitrary C++ data structures. The resulting binary data structures can be used to reconstitute the data structures in a different context, on another platform, etc
Dependency	Lifetime dependency on a singleton object.The Dependency template class represents a lifetime dependency on a singleton object based on the Blaze Singleton functionality. By use of the Dependency template, any class can by either public or non-public inheritance or composition define a single or multiple lifetime dependencies on one or several singletons, which guarantees that the singleton instance(s) will be destroyed after the dependent object. The following example demonstrates both the inheritance as well as the composition approach:
HasCyclicDependency
Singleton	Base class for all lifetime managed singletons.The Singleton class represents the base class for all lifetime managed singletons of the Blaze library. Classes, which are supposed to be implemented in terms of the singleton pattern, only have to derive from this class in order to gain all basic characteristics of a singleton:
SizeTrait	Base template for the SizeTrait class.The SizeTrait class template evaluates the larger of the two given data types by use of the sizeof operator. SizeTrait defines the data types Large for the larger of the two given data types and Small for the smaller data type. In case both data types have the same size, the first given data type T1 is chosen as the large and T2 as the small data type
SystemClock	System clock of the Blaze library.The SystemClock class represents the system clock of the Blaze library. The system clock is the central timing functionality that can be used to query for the start time of the process, the current timestamp and the elapsed time since the start of the process. The following example demonstrates how the single system clock instance is acquired via the theSystemClock() functcion and how the system clock can be used:
Thread	Implementation of a single thread of execution
ThreadPool	Implementation of a thread pool
TypeList	Implementation of a type list.The TypeList class is an implementation of a type list according to the example of Andrei Alexandrescu. The type list merely consists of the two data types Head and Tail. In order to create type lists of more data types, the TypeList class is used recursively:
Length	Calculating the length of a type list.The Length class can be used to obtain the length of a type list (i.e. the number of contained types). In order to obtain the length of a type list, the Length class has to be instantiated for a particular type list. The length of the type list can be obtained using the member enumeration value. The following example gives an impression of the use of the Length class:
TypeAt	Indexing a type list.The TypeAt class can be used to access a type list at a specified position to query the according type. In order to index a type list, the TypeAt class has to be instantiated for a particular type list and an index value. The indexed type is available via the member type definition Result. The following example gives an impression of the use of the TypeAt class:
Contains	Searching a type list.The Contains class can be used to search the type list for a particular type Type. In contrast to the IndexOf class, the Contains class does not evaluate the index of the type but only checks whether or not the type is contained in the type list. Additionally, in contrast to the ContainsRelated class, the Contains class strictly searches for the given type Type and not for a related data type. In case the type is contained in the type list, the value member enumeration is set to 1, else it is set to 0. In order to check whether a type is part of a type list, the Contains class has to be instantiated for a particular type list and another type. The following example gives an impression of the use of the Contains class:
ContainsRelated	Searching a type list.The ContainsRelated class can be used to search the type list for a type related to Type. In contrast to the Contains class, the ContainsRelated class only searches for a type the given data type Type can be converted to. In case a related type is found in the type list, the value member enumeration is set to 1, else it is set to 0. In order to check whether a related type is contained in the type list, the ContainsRelated class has to be instantiated for a particular type list and another type. The following example gives an impression of the use of the ContainsRelated class:
IndexOf	Searching a type list.The IndexOf class can be used to search the type list for a particular type Type. In contrast to the Contains and the ContainsRelated classes, the IndexOf class evaluates the index of the given type in the type list. In case the type is contained in the type list, the value member represents the index of the queried type. Otherwise the value member is set to -1. In order to search for a type, the IndexOf class has to be instantiated for a particular type list and a search type. The following example gives an impression of the use of the IndexOf class:
Append	Appending a type to a type list.The Append class can be used to append the data type Type to a type list TList. In order to append a data type, the Append class has to be instantiated for a particular type list and another type. The following example gives an impression of the use of the Append class:
AddConst	Addition of a top level 'const' qualifier.The AddConst type trait adds a top level 'const' qualifier to the given type T
AddCV	Addition of a top level 'const' and 'volatile' qualifier.The AddCV type trait adds both a top level 'const' and 'volatile' qualifier to the given type T
AddPointer	Addition of a top level pointer.The AddPointer type trait adds a top level pointer to the given type T. It has the same effect as blaze::RemoveReference<T>::Type*
AddReference	Addition of a top level reference.In case the given type T is not a reference type, the AddReference type trait adds a top level reference to the given type T. Else the resulting type Type is T
AddVolatile	Addition of a top level 'volatile' qualifier.The AddVolatile type trait adds a top level 'volatile' qualifier to the given type T
Extent	Compile time check for the size of array bounds.Via this type trait it is possible to query at compile time for the size of a particular array extent. In case the given template argument is an array type with a rank greater than N, the value member enumeration is set to the number of elements of the N'th array dimension. In all other cases, and especially in case the N'th array dimension is incomplete, value is set to 0
HasSize	Compile time size check.This class offers the possibility to test the size of a type at compile time. If the type T is exactly Size bytes large, the value member enumeration is set to 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to 0, Type is FalseType, and the class derives from FalseType
Has1Byte	Compile time size check.This type trait offers the possibility to test whether a given type has a size of exactly one byte. If the type T has one byte, the value member enumeration is set to 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to 0, Type is FalseType, and the class derives from FalseType
Has2Bytes	Compile time size check.This type trait offers the possibility to test whether a given type has a size of exactly two bytes. If the type T has two bytes, the value member enumeration is set to 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to 0, Type is FalseType, and the class derives from FalseType
Has4Bytes	Compile time size check.This type trait offers the possibility to test whether a given type has a size of exactly four bytes. If the type T has four bytes, the value member enumeration is set to 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to 0, Type is FalseType, and the class derives from FalseType
Has8Bytes	Compile time size check.This type trait offers the possibility to test whether a given type has a size of exactly four bytes. If the type T has four bytes, the value member enumeration is set to 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to 0, Type is FalseType, and the class derives from FalseType
HaveSameSize	Compile time size check.This class offers the possibility to test the size of two types at compile time. If an object of type T1 has the same size as an object of type T2, the value member enumeration is set to 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to 0, Type is FalseType, and the class derives from FalseType
IsArithmetic	Compile time check for arithmetic data types.This type trait tests whether or not the given template parameter is a (possibly cv-qualified) arithmetic (integral or floating point) data type. In case the type is an arithmetic type, the value member enumeration is set to 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to 0, Type is FalseType and the class derives from FalseType
IsArray	Compile time type check.The IsArray type trait tests whether or not the given template parameter is an array type. In case the given data type is an array type, the value member enumeration is set to 1, the nested type definition Type is set to TrueType, and the class derives from TrueType. Otherwise value is set to 0, Type is FalseType and the class derives from FalseType
IsBaseOf	Compile time analysis of an inheritance relationship.This type trait tests for an inheritance relationship between the two types Base and Derived. If Derived is a type derived from Base or the same type as Base the value member enumeration is set to 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to 0, Type is FalseType, and the class derives from FalseType
IsBoolean	Compile time check for boolean types.This type trait tests whether or not the given template parameter is of boolean type. In case the type is a boolean (ignoring the cv-qualifiers), the value member enumeration is set to 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to 0, Type is FalseType, and the class derives from FalseType
IsBuiltin	Compile time check for built-in data types.This type trait tests whether or not the given template parameter is a built-in/fundamental data type. In case the type is a built-in type, the value member enumeration is set to 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to 0, Type is FalseType, and the class derives from FalseType
IsCharacter	Compile time check for character types.This type trait tests whether or not the given template parameter is a character type (i.e., either char, signed char, unsigned char, or wchar_t, possibly cv-qualified). In case the type is a character type (ignoring the cv-qualifiers), the value member enumeration is set to 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to 0, Type is FalseType, and the class derives from FalseType
IsClass	Compile time type check.The IsClass type trait tests whether or not the given template parameter is a (possibly cv-qualified) class type. In case the given data type is a class type, the value member enumeration is set to 1, the nested type definition Type is set to TrueType, and the class derives from TrueType. Otherwise value is set to 0, Type is FalseType and the class derives from FalseType
IsComplex	Compile time check for complex types.This type trait tests whether or not the given template parameter is a complex data type. In case the type is a complex data type (ignoring the cv-qualifiers), the value member enumeration is set to 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to 0, Type is FalseType, and the class derives from FalseType
IsConst	Compile time check for constant data types.The IsConst type trait tests whether or not the given template parameter is a (top level) const-qualified data type. In case the given data type is const-qualified, the value member enumeration is set to 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to 0, Type is FalseType, and the class derives from FalseType
IsConvertible	Compile time pointer relationship constraint.This type traits tests whether the first given template argument can be converted to the second template argument via copy construction. If the first argument can be converted to the second argument, the value member enumeration is set to 1, the nested type definition type is TrueType, and the class derives from TrueType. Otherwise value is set to 0, type is FalseType, and the class derives from FalseType
IsDouble	Compile time check for double precision floating point types.This type trait tests whether or not the given template parameter is of double type. In case the type is double (ignoring the cv-qualifiers), the value member enumeration is set to 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to 0, Type is FalseType, and the class derives from FalseType
IsEmpty	Compile time type check.This class tests whether the given template parameter is an empty class type, i.e. a type without member data and virtual functions. If it is an empty class type, the value member enumeration is set to 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to 0, Type is FalseType, and the class derives from FalseType
IsFloat	Compile time check for single precision floating point types.This type trait tests whether or not the given template parameter is of float type. In case the type is float (ignoring the cv-qualifiers), the value member enumeration is set to 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to 0, Type is FalseType, and the class derives from FalseType
IsFloatingPoint	Compile time check for floating point data types.This type trait tests whether or not the given template parameter is a floating point data type (ignoring the cv-qualifiers). In case the type is a floating point data type, the value member enumeration is set to 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to 0, Type is FalseType, and the class derives from FalseType
IsInteger	Compile time check for integer types.This type trait tests whether or not the given template parameter is an integer type (i.e., either (signed) int or unsigned int, possibly cv-qualified). In case the type is an integer type (ignoring the cv-qualifiers), the value member enumeration is set to 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to 0, Type is FalseType, and the class derives from FalseType
IsIntegral	Compile time check for integral data types.This type trait tests whether or not the given template parameter is an integral data type. In case the type is an integral data type, the value member enumeration is set to 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to 0, Type is FalseType, and the class derives from FalseType
IsLong	Compile time check for long integer types.This type trait tests whether or not the given template parameter is a long integer type (i.e., either (signed) long or unsigned long, possibly cv-qualified). In case the type is a long integer type (ignoring the cv-qualifiers), the value member enumeration is set to 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to 0, Type is FalseType, and the class derives from FalseType
IsLongDouble	Compile time check for extended precision floating point types.This type trait tests whether or not the given template parameter is of long double type. In case the type is long double (ignoring the cv-qualifiers), the value member enumeration is set to 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to 0, Type is FalseType, and the class derives from FalseType
IsNumeric	Compile time check for numeric types.This type trait tests whether or not the given template parameter is a numeric data type. Blaze considers all integral (except bool), floating point, and complex data types as numeric data types. In case the type is a numeric type, the value member enumeration is set to 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to 0, Type is FalseType, and the class derives from FalseType
IsObject	Compile time type check.This class tests whether the given template parameter T is an object type. All types are considered object types except references, void, and function types. If T is an object type, the value member enumeration is set to 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to 0, Type is FalseType, and the class derives from FalseType
IsPod	Compile time check for pod data types.This type trait tests whether or not the given template parameter is a POD (Plain Old Data). In case the type is a POD, the value member enumeration is set o 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to 0, Type is FalseType, and the class derives from FalseType
IsPointer	Compile time type check.This class tests whether the given template parameter is a pointer type (including function pointers, but excluding pointers to members) or not. If it is a pointer type, the value member enumeration is set to 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to 0, Type is FalseType, and the class derives from FalseType
IsReference	Compile time type check.This class tests whether the given template parameter T is a reference type (including references to functions). If it is a reference type, the value member enumeration is set to 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to 0, Type is FalseType, and the class derives from FalseType
IsStrictlySame	Compile time type relationship analysis.This class tests if the two data types A and B are equal. For this type comparison, the cv-qualifiers of both data types are not ignored. If A and B are the same data type, then the value member enumeration is set to 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to 0, Type is FalseType, and the class derives from FalseType
IsSame	Type relationship analysis.This class tests if the two data types A and B are equal. For this type comparison, the cv-qualifiers of both data types are ignored. If A and B are the same data type (ignoring the cv-qualifiers), then the value member enumeration is set to 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to 0, Type is FalseType, and the class derives from FalseType
IsShort	Compile time check for short integer types.This type trait tests whether or not the given template parameter is a short integer type (i.e., either (signed) short or unsigned short, possibly cv-qualified). In case the type is a short integer type (ignoring the cv-qualifiers), the value member enumeration is set to 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to 0, Type is FalseType, and the class derives from FalseType
IsSigned	Compile time check for signed data types.This type trait tests whether or not the given template parameter is a signed integral data type. In case the type is a signed (possibly cv-qualified) data type, the value member enumeration is set to 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to 0, Type is FalseType, and the class derives from FalseType
IsUnion	Compile time check for union data types.This type trait tests whether or not the given template parameter is a union data type. In case the type is a union, the value member enumeration is set o 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to 0, Type is FalseType, and the class derives from FalseType
IsUnsigned	Compile time check for unsigned data types.This type trait tests whether or not the given template parameter is an unsigned, integral data type. In case the type is an unsigned (possibly cv-qualified) data type, the value member enumeration is set to 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to 0, Type is FalseType, and the class derives from FalseType
IsVectorizable	Compile time check for vectorizable types.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...), this type trait tests whether or not the given template parameter is a vectorizable type, i.e. a type for which intrinsic vector operations and optimizations can be used. Currently, only signed/unsigned short, signed/unsigned int, signed/unsigned long, float, double, complex<float>, and complex<double> are considered to be vectorizable types. In case the type is vectorizable, the value member enumeration is set to 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to 0, Type is FalseType, and the class derives from FalseType
IsVoid	Compile time check for the void data type.This type trait tests whether or not the given template parameter is of type void (ignoring the cv-qualifiers). In case the type is of type void, the value member enumeration is set to 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to 0, Type is FalseType, and the class derives from FalseType
IsVolatile	Compile time check for volatile data types.The IsVolatile type trait tests whether or not the given template parameter is a (top level) volatile-qualified data type. In case the given data type is volatile, the value member enumeration is set to 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to 0, Type is FalseType, and the class derives from FalseType
Rank	Compile time check for array ranks.This type trait determines the rank of the given template argument. In case the given type is an array type, the nested value member enumeration is set to the number of dimensions of T. Otherwise value is set to 0
RemoveAllExtents	Removal of all array extents.The RemoveAllExtents type trait removes all array extents from the given type T
RemoveConst	Removal of const-qualifiers.The RemoveConst type trait removes all top level 'const' qualifiers from the given type T
RemoveCV	Removal of top level cv-qualifiers.The RemoveCV type trait removes all top level cv-qualifiers from the given type T
RemoveExtent	Removal of the top level array extent.The RemoveExtent type trait removes the top level array extent from the given type T
RemovePointer	Removal of pointer modifiers.The RemoveCV type trait removes any pointer modifiers from the given type T
RemoveReference	Removal of reference modifiers.The RemoveCV type trait removes any reference modifiers from the given type T
RemoveVolatile	Removal of volatile-qualifiers.The RemoveVolatile type trait removes all top level 'volatile' qualifiers from the given type T
UniqueArray	Scope-limited management of dynamically allocated arrays.The UniqueArray class implements a scope-restricted, lightweight smart pointer that manages a dynamically allocated array. In contrast to other smart pointer implementations, UniqueArray is non-copyable and therefore restricted to manage arrays within a single scope, but does so so with a minimum of runtime overhead. The following example demonstrates the application of UniqueArray:
UniquePtr	Scope-limited management of dynamically allocated resourses.The UniquePtr class implements a scope-restricted, lightweight smart pointer that manages a dynamically allocated resource. In contrast to other smart pointer implementations, UniquePtr is non-copyable and therefore restricted to manage resources within a single scope, but does so with a minimum of runtime overhead. The following example demonstrates the application of UniquePtr:
UnsignedValue	Implementation of a wrapper for built-in unsigned integral values.This class wraps a value of built-in unsigned integral type in order to be able to extract non-negative unsigned integral values from an input stream
IsEven	Compile time check whether a compile time constant expression is even.This value trait tests whether the given integral value N is an even value. In case the value is even, the value member enumeration is set to 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to 0, Type is FalseType, and the class derives from FalseType
IsOdd	Compile time check whether a compile time constant expression is odd.This value trait tests whether the given integral value N is an odd value. In case the value is odd, the value member enumeration is set to 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to 0, Type is FalseType, and the class derives from FalseType
IsPowerOf	Compile time check for a power relationship of integral values to a given base.This value trait tests whether the given integral value N is a power of the base B according to the equation , where x is any positive integer in the range . In case the value is a power of B, the value member enumeration is set to 1, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to 0, Type is FalseType, and the class derives from FalseType
sse_int8_t	Intrinsic type for 8-bit integral data values
sse_int16_t	Intrinsic type for 16-bit integral data values
sse_int32_t	Intrinsic type for 32-bit integral data values
sse_int64_t	Intrinsic type for 64-bit integral data values
sse_float_t	Intrinsic type for 32-bit single precision floating point data values
sse_double_t	Intrinsic type for 64-bit double precision floating point data values
sse_cfloat_t	Intrinsic type for 32-bit single precision complex values
sse_cdouble_t	Intrinsic type for 64-bit double precision complex values
complex	Complex data type of the Blaze library
size_t	Size type of the Blaze library
ptrdiff_t	Pointer difference type of the Blaze library
int8_t	8-bit signed integer type of the Blaze library
uint8_t	8-bit unsigned integer type of the Blaze library
int16_t	16-bit signed integer type of the Blaze library
uint16_t	16-bit unsigned integer type of the Blaze library
int32_t	32-bit signed integer type of the Blaze library
uint32_t	32-bit unsigned integer type of the Blaze library
int64_t	64-bit signed integer type of the Blaze library
uint64_t	64-bit unsigned integer type of the Blaze library