Macros
Compile time constraints

Macros

#define BLAZE_CONSTRAINT_MUST_BE_ADAPTOR_TYPE(T)   static_assert( ::blaze::IsAdaptor<T>::value, "Non-adaptor type detected" )
 Constraint on the data type.In case the given data type T is not an adaptor type (as for instance a LowerMatrix, UpperMatrix, or SymmetricMatrix) a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_ADAPTOR_TYPE(T)   static_assert( !::blaze::IsAdaptor<T>::value, "Adaptor type detected" )
 Constraint on the data type.In case the given data type T is an adaptor type (as for instance LowerMatrix, UpperMatrix, or SymmetricMatrix) a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_BE_ADDEXPR_TYPE(T)   static_assert( ::blaze::IsAddExpr<T>::value, "Non-addition expression type detected" )
 Constraint on the data type.In case the given data type T is not an addition expression (i.e. a type derived from the AddExpr base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_ADDEXPR_TYPE(T)   static_assert( !::blaze::IsAddExpr<T>::value, "Addition expression type detected" )
 Constraint on the data type.In case the given data type T is an addition expression (i.e. a type derived from the AddExpr base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_BE_ALIGNED_TYPE(T)   static_assert( ::blaze::IsAligned<T>::value, "Non-aligned type detected" )
 Constraint on the data type.In case the given data type T does not provide aligned data values with respect to the requirements of the available instruction set a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_ALIGNED_TYPE(T)   static_assert( !::blaze::IsAligned<T>::value, "Aligned type detected" )
 Constraint on the data type.In case the given data type T does provide aligned data values with respect to the requirements of the available instruction set a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_BE_BLAS_COMPATIBLE_TYPE(T)   static_assert( ::blaze::IsBLASCompatible<T>::value, "Non-BLAS compatible type detected" )
 Constraint on the data type.In case the given data type T is not a BLAS compatible data type (i.e. float, double, complex<float>, or complex<double>), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_BLAS_COMPATIBLE_TYPE(T)   static_assert( !::blaze::IsBLASCompatible<T>::value, "BLAS compatible type detected" )
 Constraint on the data type.In case the given data type T is a BLAS compatible type (i.e. float, double, complex<float>, or complex<double>), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_BE_COLUMN_TYPE(T)   static_assert( ::blaze::IsColumn<T>::value, "Non-column type detected" )
 Constraint on the data type.In case the given data type T is not a column type (i.e. a dense or sparse column), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_COLUMN_TYPE(T)   static_assert( !::blaze::IsColumn<T>::value, "Column type detected" )
 Constraint on the data type.In case the given data type T is a column type (i.e. a dense or sparse column), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_BE_COLUMN_MAJOR_MATRIX_TYPE(T)   static_assert( ::blaze::IsColumnMajorMatrix<T>::value, "Non-column-major matrix type detected" )
 Constraint on the data type.In case the given data type T is not a column-major dense or sparse matrix type (i.e. a matrix type whose storage order is set to true) a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_COLUMN_MAJOR_MATRIX_TYPE(T)   static_assert( !::blaze::IsColumnMajorMatrix<T>::value, "Column-major matrix type detected" )
 Constraint on the data type.In case the given data type T is a column-major dense or sparse matrix type (i.e. a matrix type whose storage order is set to true) a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_HAVE_EQUAL_NUMBER_OF_COLUMNS(T1, T2)
 Constraint on the data type.In case the number of columns of the two given matrix types T1 and T2 can be evaluated at compile time and in case the number of columns is not equal, a compilation error is created. Note that in case the number of columns of either of the two matrix types cannot be determined no compilation error is created. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_HAVE_EQUAL_NUMBER_OF_COLUMNS(T1, T2)
 Constraint on the data type.In case the number of columns of the two given matrix types T1 and T2 can be evaluated at compile time and in case the number of columns is equal, a compilation error is created. Note that in case the number of columns of either of the two matrix types cannot be determined no compilation error is created. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_COLUMN_VECTOR_TYPE(T)   static_assert( ::blaze::IsColumnVector<T>::value, "Non-column vector type detected" )
 Constraint on the data type.In case the given data type T is not a column dense or sparse vector type (i.e. a vector type whose transposition flag is set to blaze::columnVector) a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_COLUMN_VECTOR_TYPE(T)   static_assert( !::blaze::IsColumnVector<T>::value, "Column vector type detected" )
 Constraint on the data type.In case the given data type T is a column dense or sparse vector type (i.e. a vector type whose transposition flag is set to blaze::columnVector) a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_BE_COMPUTATION_TYPE(T)   static_assert( ::blaze::IsComputation<T>::value, "Non-computation type detected" )
 Constraint on the data type.In case the given data type T is not a computational expression (i.e. a type derived from the Computation base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_COMPUTATION_TYPE(T)   static_assert( !::blaze::IsComputation<T>::value, "Computation type detected" )
 Constraint on the data type.In case the given data type T is a computational expression (i.e. a type derived from the Computation base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_HAVE_CONST_DATA_ACCESS(T)   static_assert( ::blaze::HasConstDataAccess<T>::value, "Type without const data access detected" )
 Constraint on the data type.In case the given data type T does not provide low-level data access to constant data, i.e. does not have a const 'data' member function, a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_HAVE_CONST_DATA_ACCESS(T)   static_assert( !::blaze::HasConstDataAccess<T>::value, "Type with const data access detected" )
 Constraint on the data type.In case the given data type T does provide low-level data access to constant data, i.e. does have a const 'data' member function, a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_BE_CROSSEXPR_TYPE(T)   static_assert( ::blaze::IsCrossExpr<T>::value, "Non-cross product expression type detected" )
 Constraint on the data type.In case the given data type T is not a cross product expression (i.e. a type derived from the CrossExpr base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_CROSSEXPR_TYPE(T)   static_assert( !::blaze::IsCrossExpr<T>::value, "Cross product expression type detected" )
 Constraint on the data type.In case the given data type T is a cross product expression (i.e. a type derived from the CrossExpr base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_BE_CUSTOM_TYPE(T)   static_assert( ::blaze::IsCustom<T>::value, "Non-custom type detected" )
 Constraint on the data type.In case the given data type T is not a custom data type, i.e. a custom vector or matrix, a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_CUSTOM_TYPE(T)   static_assert( !::blaze::IsCustom<T>::value, "Custom type dected" )
 Constraint on the data type.In case the given data type T is a custom data type, i.e. a custom vector or matrix, a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_BE_DENSE_MATRIX_TYPE(T)   static_assert( ::blaze::IsDenseMatrix<T>::value, "Non-dense matrix type detected" )
 Constraint on the data type.In case the given data type T is not a dense, N-dimensional matrix type, a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_DENSE_MATRIX_TYPE(T)   static_assert( !::blaze::IsDenseMatrix<T>::value, "Dense matrix type detected" )
 Constraint on the data type.In case the given data type T is a dense, N-dimensional matrix type, a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_BE_DENSE_VECTOR_TYPE(T)   static_assert( ::blaze::IsDenseVector<T>::value, "Non-dense vector type detected" )
 Constraint on the data type.In case the given data type T is not a dense, N-dimensional vector type, a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_DENSE_VECTOR_TYPE(T)   static_assert( !::blaze::IsDenseVector<T>::value, "Dense vector type detected" )
 Constraint on the data type.In case the given data type T is a dense, N-dimensional vector type, a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_BE_DIAGONAL_MATRIX_TYPE(T)   static_assert( ::blaze::IsDiagonal<T>::value, "Non-diagonal matrix type detected" )
 Constraint on the data type.In case the given data type T is not a diagonal matrix type, a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_DIAGONAL_MATRIX_TYPE(T)   static_assert( !::blaze::IsDiagonal<T>::value, "Diagonal matrix type detected" )
 Constraint on the data type.In case the given data type T is a diagonal matrix type, a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_BE_DIVEXPR_TYPE(T)   static_assert( ::blaze::IsDivExpr<T>::value, "Non-division expression type detected" )
 Constraint on the data type.In case the given data type T is not a division expression (i.e. a type derived from the DivExpr base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_DIVEXPR_TYPE(T)   static_assert( !::blaze::IsDivExpr<T>::value, "Division expression type detected" )
 Constraint on the data type.In case the given data type T is a division expression (i.e. a type derived from the DivExpr base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_BE_EVALEXPR_TYPE(T)   static_assert( ::blaze::IsEvalExpr<T>::value, "Non-evaluation expression type detected" )
 Constraint on the data type.In case the given data type T is not an evaluation expression (i.e. a type derived from the EvalExpr base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_EVALEXPR_TYPE(T)   static_assert( !::blaze::IsEvalExpr<T>::value, "Evaluation expression type detected" )
 Constraint on the data type.In case the given data type T is an evaluation expression (i.e. a type derived from the EvalExpr base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_BE_EXPRESSION_TYPE(T)   static_assert( ::blaze::IsExpression<T>::value, "Non-expression type detected" )
 Constraint on the data type.In case the given data type T is not an expression (i.e. a type derived from the Expression base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_EXPRESSION_TYPE(T)   static_assert( !::blaze::IsExpression<T>::value, "Expression type detected" )
 Constraint on the data type.In case the given data type T is an expression (i.e. a type derived from the Expression base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_BE_FOREACHEXPR_TYPE(T)   static_assert( ::blaze::IsForEachExpr<T>::value, "Non-for-each expression type detected" )
 Constraint on the data type.In case the given data type T is not a for-each expression (i.e. a type derived from the ForEachExpr base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_FOREACHEXPR_TYPE(T)   static_assert( !::blaze::IsForEachExpr<T>::value, "For-each expression type detected" )
 Constraint on the data type.In case the given data type T is a for-each expression (i.e. a type derived from the ForEachExpr base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_BE_GENERAL_MATRIX_TYPE(T)   static_assert( ::blaze::IsGeneral<T>::value, "Non-general matrix type detected" )
 Constraint on the data type.In case the given data type T is not a general matrix type, a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_GENERAL_MATRIX_TYPE(T)   static_assert( !::blaze::IsGeneral<T>::value, "General matrix type detected" )
 Constraint on the data type.In case the given data type T is a general matrix type, a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_BE_HERMITIAN_MATRIX_TYPE(T)   static_assert( ::blaze::IsHermitian<T>::value, "Non-Hermitian matrix type detected" )
 Constraint on the data type.In case the given data type T is not an Hermitian matrix type, a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_HERMITIAN_MATRIX_TYPE(T)   static_assert( !::blaze::IsHermitian<T>::value, "Hermitian matrix type detected" )
 Constraint on the data type.In case the given data type T is an Hermitian matrix type, a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_BE_IDENTITY_MATRIX_TYPE(T)   static_assert( ::blaze::IsIdentity<T>::value, "Non-identity matrix type detected" )
 Constraint on the data type.In case the given data type T is not an identity matrix type, a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_IDENTITY_MATRIX_TYPE(T)   static_assert( !::blaze::IsIdentity<T>::value, "Identity matrix type detected" )
 Constraint on the data type.In case the given data type T is an identity matrix type, a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_BE_INVERTIBLE_TYPE(T)   static_assert( ::blaze::IsInvertible<T>::value, "Non-invertible type detected" )
 Constraint on the data type.In case the given data type T is not an invertible data type (i.e. a BLAS compatible type, long double, or any matrix with BLAS compatible element type), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_INVERTIBLE_TYPE(T)   static_assert( !blaze::IsInvertible<T>::value, "Invertible type detected" )
 Constraint on the data type.In case the given data type T is an invertible data type (i.e. a BLAS compatible type, long double, or any matrix with BLAS compatible element type), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_BE_LOWER_MATRIX_TYPE(T)   static_assert( ::blaze::IsLower<T>::value, "Non-lower triangular matrix type detected" )
 Constraint on the data type.In case the given data type T is not a lower triangular matrix type, a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_LOWER_MATRIX_TYPE(T)   static_assert( !::blaze::IsLower<T>::value, "Lower triangular matrix type detected" )
 Constraint on the data type.In case the given data type T is a lower triangular matrix type, a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_BE_MATEVALEXPR_TYPE(T)   static_assert( ::blaze::IsMatEvalExpr<T>::value, "Non-matrix evaluation expression type detected" )
 Constraint on the data type.In case the given data type T is not a matrix evaluation expression (i.e. a type derived from the MatEvalExpr base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_MATEVALEXPR_TYPE(T)   static_assert( !::blaze::IsMatEvalExpr<T>::value, "Matrix evaluation expression type detected" )
 Constraint on the data type.In case the given data type T is a matrix evaluation expression (i.e. a type derived from the MatEvalExpr base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_BE_MATFOREACHEXPR_TYPE(T)   static_assert( ::blaze::IsMatForEachExpr<T>::value, "Non-matrix for-each expression type detected" )
 Constraint on the data type.In case the given data type T is not a matrix for-each expression (i.e. a type derived from the MatForEachExpr base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_MATFOREACHEXPR_TYPE(T)   static_assert( !::blaze::IsMatForEachExpr<T>::value, "Matrix for-each expression type detected" )
 Constraint on the data type.In case the given data type T is a matrix for-each expression (i.e. a type derived from the MatForEachExpr base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_BE_MATINVEXPR_TYPE(T)   static_assert( ::blaze::IsMatInvExpr<T>::value, "Non-matrix inversion expression detected" )
 Constraint on the data type.In case the given data type T is not a matrix inversion expression (i.e. a type derived from the MatInvExpr base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_MATINVEXPR_TYPE(T)   static_assert( !::blaze::IsMatInvExpr<T>::value, "Matrix inversion expression detected" )
 Constraint on the data type.In case the given data type T is a matrix inversion expression (i.e. a type derived from the MatInvExpr base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_BE_MATMATADDEXPR_TYPE(T)   static_assert( ::blaze::IsMatMatAddExpr<T>::value, "Non-matrix/matrix addition expression type detected" )
 Constraint on the data type.In case the given data type T is not a matrix/matrix addition expression (i.e. a type derived from the MatMatAddExpr base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_MATMATADDEXPR_TYPE(T)   static_assert( !::blaze::IsMatMatAddExpr<T>::value, "Matrix/matrix addition expression type detected" )
 Constraint on the data type.In case the given data type T is a matrix/matrix addition expression (i.e. a type derived from the MatMatAddExpr base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_FORM_VALID_MATMATADDEXPR(T1, T2)
 Constraint on the data type.In case the given data types T1 and T2 do not form a valid matrix/matrix addition, a compilation error is created. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_FORM_VALID_MATMATADDEXPR(T1, T2)
 Constraint on the data type.In case the given data types T1 and T2 do form a valid matrix/matrix addition, a compilation error is created. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_MATMATMULTEXPR_TYPE(T)   static_assert( ::blaze::IsMatMatMultExpr<T>::value, "Non-matrix/matrix multiplication expression type detected" )
 Constraint on the data type.In case the given data type T is not a matrix/matrix multiplication expression (i.e. a type derived from the MatMatMultExpr base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_MATMATMULTEXPR_TYPE(T)   static_assert( !::blaze::IsMatMatMultExpr<T>::value, "Matrix/matrix multiplication expression type detected" )
 Constraint on the data type.In case the given data type T is a matrix/matrix multiplication expression (i.e. a type derived from the MatMatMultExpr base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_FORM_VALID_MATMATMULTEXPR(T1, T2)
 Constraint on the data type.In case the given data types T1 and T2 do not form a valid matrix/matrix multiplication, a compilation error is created. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_FORM_VALID_MATMATMULTEXPR(T1, T2)
 Constraint on the data type.In case the given data types T1 and T2 do form a valid matrix/matrix multiplication, a compilation error is created. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_MATMATSUBEXPR_TYPE(T)   static_assert( ::blaze::IsMatMatSubExpr<T>::value, "Non-matrix/matrix subtraction expression type detected" )
 Constraint on the data type.In case the given data type T is not a matrix/matrix subtraction expression (i.e. a type derived from the MatMatSubExpr base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_MATMATSUBEXPR_TYPE(T)   static_assert( !::blaze::IsMatMatSubExpr<T>::value, "Matrix/matrix subtraction expression type detected" )
 Constraint on the data type.In case the given data type T is a matrix/matrix subtraction expression (i.e. a type derived from the MatMatSubExpr base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_FORM_VALID_MATMATSUBEXPR(T1, T2)
 Constraint on the data type.In case the given data types T1 and T2 do not form a valid matrix/matrix subtraction, a compilation error is created. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_FORM_VALID_MATMATSUBEXPR(T1, T2)
 Constraint on the data type.In case the given data types T1 and T2 do form a valid matrix/matrix subtraction, a compilation error is created. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_MATRIX_TYPE(T)   static_assert( ::blaze::IsMatrix<T>::value, "Non-matrix type detected" )
 Constraint on the data type.In case the given data type T is not a N-dimensional matrix type, a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_MATRIX_TYPE(T)   static_assert( !::blaze::IsMatrix<T>::value, "Matrix type detected" )
 Constraint on the data type.In case the given data type T is a N-dimensional matrix type, a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_BE_MATSCALARDIVEXPR_TYPE(T)   static_assert( ::blaze::IsMatScalarDivExpr<T>::value, "Non-matrix/scalar division expression type detected" )
 Constraint on the data type.In case the given data type T is not a matrix/scalar division expression (i.e. a type derived from the MatScalarDivExpr base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_MATSCALARDIVEXPR_TYPE(T)   static_assert( !::blaze::IsMatScalarDivExpr<T>::value, "Matrix/scalar division expression type detected" )
 Constraint on the data type.In case the given data type T is a matrix/scalar division expression (i.e. a type derived from the MatScalarDivExpr base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_BE_MATSCALARMULTEXPR_TYPE(T)   static_assert( ::blaze::IsMatScalarMultExpr<T>::value, "Non-matrix/scalar multiplication expression type detected" )
 Constraint on the data type.In case the given data type T is not a matrix/scalar multiplication expression (i.e. a type derived from the MatScalarMultExpr base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_MATSCALARMULTEXPR_TYPE(T)   static_assert( !::blaze::IsMatScalarMultExpr<T>::value, "Matrix/scalar multiplication expression type detected" )
 Constraint on the data type.In case the given data type T is a matrix/scalar multiplication expression (i.e. a type derived from the MatScalarMultExpr base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_BE_MATSERIALEXPR_TYPE(T)   static_assert( ::blaze::IsMatSerialExpr<T>::value, "Non-matrix serial evaluation expression type detected" )
 Constraint on the data type.In case the given data type T is not a matrix serial evaluation expression (i.e. a type derived from the MatSerialExpr base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_MATSERIALEXPR_TYPE(T)   static_assert( !::blaze::IsMatSerialExpr<T>::value, "Matrix serial evaluation expression type detected" )
 Constraint on the data type.In case the given data type T is a matrix serial evaluation expression (i.e. a type derived from the MatSerialExpr base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_BE_MATTRANSEXPR_TYPE(T)   static_assert( ::blaze::IsMatTransExpr<T>::value, "Non-matrix transposition expression type detected" )
 Constraint on the data type.In case the given data type T is not a matrix transposition expression (i.e. a type derived from the MatTransExpr base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_MATTRANSEXPR_TYPE(T)   static_assert( !::blaze::IsMatTransExpr<T>::value, "Matrix transposition expression type detected" )
 Constraint on the data type.In case the given data type T is a matrix transposition expression (i.e. a type derived from the MatTransExpr base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_BE_MATVECMULTEXPR_TYPE(T)   static_assert( ::blaze::IsMatVecMultExpr<T>::value, "Non-matrix/vector multiplication expression type detected" )
 Constraint on the data type.In case the given data type T is not a matrix/vector multiplication expression (i.e. a type derived from the MatVecMultExpr base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_MATVECMULTEXPR_TYPE(T)   static_assert( !::blaze::IsMatVecMultExpr<T>::value, "Matrix/vector multiplication expression type detected" )
 Constraint on the data type.In case the given data type T is a matrix/vector multiplication expression (i.e. a type derived from the MatVecMultExpr base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_FORM_VALID_MATVECMULTEXPR(T1, T2)
 Constraint on the data type.In case the given data types T1 and T2 do not form a valid matrix/vector multiplication, a compilation error is created. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_FORM_VALID_MATVECMULTEXPR(T1, T2)
 Constraint on the data type.In case the given data types T1 and T2 do form a valid matrix/vector multiplication, a compilation error is created. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_MULTEXPR_TYPE(T)   static_assert( ::blaze::IsMultExpr<T>::value, "Non-multiplication expression detected" )
 Constraint on the data type.In case the given data type T is not a multiplication expression (i.e. a type derived from the MultExpr base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_MULTEXPR_TYPE(T)   static_assert( !::blaze::IsMultExpr<T>::value, "Multiplication expression detected" )
 Constraint on the data type.In case the given data type T is a multiplication expression (i.e. a type derived from the MultExpr base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_HAVE_MUTABLE_DATA_ACCESS(T)   static_assert( ::blaze::HasMutableDataAccess<T>::value, "Type without mutable data access detected" )
 Constraint on the data type.In case the given data type T does not provide low-level data access to mutable data, i.e. does not have a non-const 'data' member function, a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_HAVE_MUTABLE_DATA_ACCESS(T)   static_assert( !::blaze::HasMutableDataAccess<T>::value, "Type with mutable data access detected" )
 Constraint on the data type.In case the given data type T does provide low-level data access to mutable data, i.e. does have a non-const 'data' member function, a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_BE_NUMERIC_MATRIX_TYPE(T)   static_assert( ::blaze::IsNumericMatrix<T>::value, "Non-numeric matrix type detected" )
 Constraint on the data type.In case the given data type T is not a numeric matrix type, a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_NUMERIC_MATRIX_TYPE(T)   static_assert( !::blaze::IsNumericMatrix<T>::value, "Numeric matrix type detected" )
 Constraint on the data type.In case the given data type T is a numeric matrix type, a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_BE_NUMERIC_VECTOR_TYPE(T)   static_assert( ::blaze::IsNumericVector<T>::value, "Non-numeric vector type detected" )
 Constraint on the data type.In case the given data type T is not a numeric vector type, a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_NUMERIC_VECTOR_TYPE(T)   static_assert( !::blaze::IsNumericVector<T>::value, "Numeric vector type detected" )
 Constraint on the data type.In case the given data type T is a numeric vector type, a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_BE_OPPOSED_VIEW(T)   static_assert( ::blaze::IsOpposedView<T>::value, "Non-opposed view detected" )
 Constraint on the data type.In case the given data type T is not an opposed view, i.e. is not a view that is opposed to the natural storage order of its underlying type, a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_OPPOSED_VIEW(T)   static_assert( !::blaze::IsOpposedView<T>::value, "Opposed view detected" )
 Constraint on the data type.In case the given data type T is an opposed view, i.e. is a view that is opposed to the natural storage order of its underlying type, a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_BE_PADDED_TYPE(T)   static_assert( ::blaze::IsPadded<T>::value, "Non-padded type detected" )
 Constraint on the data type.In case the given data type T does not employ or simulate padding (i.e. a special treatment of remainder elements is necessary) a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_PADDED_TYPE(T)   static_assert( !::blaze::IsPadded<T>::value, "Padded type detected" )
 Constraint on the data type.In case the given data type T does employ or simulate padding (i.e. no special treatment of remainder elements is necessary) a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_BE_PROXY_TYPE(T)   static_assert( ::blaze::IsProxy<T>::value, "Non-proxy type detected" )
 Constraint on the data type.In case the given data type T is not a proxy type (i.e. a type derived from the Proxy class template), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_PROXY_TYPE(T)   static_assert( !::blaze::IsProxy<T>::value, "Proxy type detected" )
 Constraint on the data type.In case the given data type T is a proxy type (i.e. a type derived from the Proxy class template), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_REQUIRE_EVALUATION(T)   static_assert( ::blaze::RequiresEvaluation<T>::value, "Type without evaluation requirement detected" )
 Constraint on the data type.In case the given data type T does not require an intermediate evaluation within composite expressions, a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_REQUIRE_EVALUATION(T)   static_assert( !::blaze::RequiresEvaluation<T>::value, "Type with evaluation requirement detected" )
 Constraint on the data type.In case the given data type T requires an intermediate evaluation within composite expressions, a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_BE_RESIZABLE(T)   static_assert( ::blaze::IsResizable<T>::value, "Non-resizable type detected" )
 Constraint on the data type.In case the given data type T is not resizable, i.e. does not have a 'resize' member function that could be used to change the size, a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_RESIZABLE(T)   static_assert( !::blaze::IsResizable<T>::value, "Resizable type detected" )
 Constraint on the data type.In case the given data type T is resizable, i.e. has a 'resize' member function that can be used to change the size, a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_BE_RESTRICTED(T)   static_assert( ::blaze::IsRestricted<T>::value, "Unrestricted type detected" )
 Constraint on the data type.In case the given data type T does not have a restricted data access, i.e. does not restrict specific operations on its data, a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_RESTRICTED(T)   static_assert( !::blaze::IsRestricted<T>::value, "Restricted type detected" )
 Constraint on the data type.In case the given data type T does have a restricted data access, i.e. does not restrict any operation on its data, a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_BE_ROW_TYPE(T)   static_assert( ::blaze::IsRow<T>::value, "Non-row type detected" )
 Constraint on the data type.In case the given data type T is not a row type (i.e. a dense or sparse row), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_ROW_TYPE(T)   static_assert( !::blaze::IsRow<T>::value, "Row type detected" )
 Constraint on the data type.In case the given data type T is a row type (i.e. a dense or sparse row), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_BE_ROW_MAJOR_MATRIX_TYPE(T)   static_assert( ::blaze::IsRowMajorMatrix<T>::value, "Non-row-major matrix type detected" )
 Constraint on the data type.In case the given data type T is not a row-major dense or sparse matrix type (i.e. a matrix type whose storage order is set to false) a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_ROW_MAJOR_MATRIX_TYPE(T)   static_assert( !::blaze::IsRowMajorMatrix<T>::value, "Row-major matrix type detected" )
 Constraint on the data type.In case the given data type T is a row-major dense or sparse matrix type (i.e. a matrix type whose storage order is set to false) a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_HAVE_EQUAL_NUMBER_OF_ROWS(T1, T2)
 Constraint on the data type.In case the number of rows of the two given matrix types T1 and T2 can be evaluated at compile time and in case the number of rows is not equal, a compilation error is created. Note that in case the number of rows of either of the two matrix types cannot be determined no compilation error is created. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_HAVE_EQUAL_NUMBER_OF_ROWS(T1, T2)
 Constraint on the data type.In case the number of rows of the two given matrix types T1 and T2 can be evaluated at compile time and in case the number of rows is equal, a compilation error is created. Note that in case the number of rows of either of the two matrix types cannot be determined no compilation error is created. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_ROW_VECTOR_TYPE(T)   static_assert( ::blaze::IsRowVector<T>::value, "Non-row vector type detected" )
 Constraint on the data type.In case the given data type T is not a row dense or sparse vector type (i.e. a vector type whose transposition flag is set to blaze::rowVector) a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_ROW_VECTOR_TYPE(T)   static_assert( !::blaze::IsRowVector<T>::value, "Row vector type detected" )
 Constraint on the data type.In case the given data type T is a row dense or sparse vector type (i.e. a vector type whose transposition flag is set to blaze::rowVector) a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_BE_SERIALEXPR_TYPE(T)   static_assert( ::blaze::IsSerialExpr<T>::value, "Non-serial evaluation expression type detected" )
 Constraint on the data type.In case the given data type T is not a serial evaluation expression (i.e. a type derived from the SerialExpr base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_SERIALEXPR_TYPE(T)   static_assert( !::blaze::IsSerialExpr<T>::value, "Serial evaluation expression type detected" )
 Constraint on the data type.In case the given data type T is a serial evaluation expression (i.e. a type derived from the SerialExpr base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_BE_SIMD_ENABLED(T)   static_assert( ::blaze::IsSIMDEnabled<T>::value, "Non-SIMD enabled type detected" )
 Constraint on the data type.In case the given data type T is not SIMD-enabled (i.e. does not provide the according SIMD member functions), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_SIMD_ENABLED(T)   static_assert( !::blaze::IsSIMDEnabled<T>::value, "SIMD enabled type detected" )
 Constraint on the data type.In case the given data type T is SIMD-enabled (i.e. does provide the according SIMD member functions), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_BE_SIMD_PACK(T)   static_assert( ::blaze::IsSIMDPack<T>::value, "Non-SIMD pack detected" )
 Constraint on the data type.In case the given data type T is not a SIMD pack, a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_SIMD_PACK(T)   static_assert( !::blaze::IsSIMDPack<T>::value, "SIMD pack detected" )
 Constraint on the data type.In case the given data type T is a SIMD pack, a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_HAVE_EQUAL_SIZE(T1, T2)
 Constraint on the data type.In case the size of the two given vector types T1 and T2 can be evaluated at compile time and in case these sizes are not equal, a compilation error is created. Note that in case the size of either of the two vector types cannot be determined no compilation error is created. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_HAVE_EQUAL_SIZE(T1, T2)
 Constraint on the data type.In case the size of the two given vector types T1 and T2 can be evaluated at compile time and in case these sizes are equal, a compilation error is created. Note that in case the size of either of the two vector types cannot be determined no compilation error is created. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_SMP_ASSIGNABLE(T)   static_assert( ::blaze::IsSMPAssignable<T>::value, "Non-SMP assignable type detected" )
 Constraint on the data type.In case the given data type T is not SMP-assignable (i.e. cannot be assigned by multiple threads), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_SMP_ASSIGNABLE(T)   static_assert( !::blaze::IsSMPAssignable<T>::value, "SMP assignable type detected" )
 Constraint on the data type.In case the given data type T is SMP-assignable (can be assigned by multiple threads), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_BE_SPARSE_ELEMENT_TYPE(T)   static_assert( ::blaze::IsSparseElement<T>::value, "Non-sparse element type detected" )
 Constraint on the data type.In case the given data type T is not a sparse element type (i.e. a type derived from the SparseElement base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_SPARSE_ELEMENT_TYPE(T)   static_assert( !::blaze::IsSparseElement<T>::value, "Sparse element type detected" )
 Constraint on the data type.In case the given data type T is a sparse element type (i.e. a type derived from the SparseElement base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_BE_SPARSE_MATRIX_TYPE(T)   static_assert( ::blaze::IsSparseMatrix<T>::value, "Non-sparse matrix type detected" )
 Constraint on the data type.In case the given data type T is not a sparse, N-dimensional matrix type, a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_SPARSE_MATRIX_TYPE(T)   static_assert( !::blaze::IsSparseMatrix<T>::value, "Sparse matrix type detected" )
 Constraint on the data type.In case the given data type T is a sparse, N-dimensional matrix type, a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_BE_SPARSE_VECTOR_TYPE(T)   static_assert( ::blaze::IsSparseVector<T>::value, "Non-sparse vector type detected" )
 Constraint on the data type.In case the given data type T is not a sparse, N-dimensional vector type, a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_SPARSE_VECTOR_TYPE(T)   static_assert( !::blaze::IsSparseVector<T>::value, "Sparse vector type detected" )
 Constraint on the data type.In case the given data type T is a sparse, N-dimensional vector type, a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_BE_SQUARE(T)   static_assert( ::blaze::IsSquare<T>::value, "Non-square matrix type detected" )
 Constraint on the data type.In case the given data type T is not a square matrix type, a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_SQUARE(T)   static_assert( !::blaze::IsSquare<T>::value, "Square matrix type detected" )
 Constraint on the data type.In case the given data type T is a square matrix type, a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_BE_MATRIX_WITH_STORAGE_ORDER(T, SO)
 Constraint on the data type.In case the given data type T is not a dense or sparse matrix type and in case the storage order of the given dense or sparse vector type T is not set to SO, a compilation error is created. More...
 
#define BLAZE_CONSTRAINT_MATRICES_MUST_HAVE_SAME_STORAGE_ORDER(T1, T2)
 Constraint on the data type.In case either of the two given data types T1 or T2 is not a matrix type and in case the storage order of both matrix types doesn't match, a compilation error is created. More...
 
#define BLAZE_CONSTRAINT_MATRICES_MUST_HAVE_DIFFERENT_STORAGE_ORDER(T1, T2)
 Constraint on the data type.In case either of the two given data types T1 or T2 is not a matrix type and in case the storage order of both matrix types does match, a compilation error is created. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_STRICTLY_LOWER_MATRIX_TYPE(T)   static_assert( ::blaze::IsStrictlyLower<T>::value, "Non-strictly lower triangular matrix type detected" )
 Constraint on the data type.In case the given data type T is not a strictly lower triangular matrix type, a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_STRICTLY_LOWER_MATRIX_TYPE(T)   static_assert( !::blaze::IsStrictlyLower<T>::value, "Strictly lower triangular matrix type detected" )
 Constraint on the data type.In case the given data type T is a strictly lower triangular matrix type, a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_BE_STRICTLY_TRIANGULAR_MATRIX_TYPE(T)   static_assert( ::blaze::IsStrictlyTriangular<T>::value, "Non-strictly triangular matrix type detected" )
 Constraint on the data type.In case the given data type T is not a strictly lower or upper triangular matrix type, a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_STRICTLY_TRIANGULAR_MATRIX_TYPE(T)   static_assert( !::blaze::IsStrictlyTriangular<T>::value, "Strictly triangular matrix type detected" )
 Constraint on the data type.In case the given data type T is a strictly lower or upper triangular matrix type, a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_BE_STRICTLY_UPPER_MATRIX_TYPE(T)   static_assert( ::blaze::IsStrictlyUpper<T>::value, "Non-strictly upper triangular matrix type detected" )
 Constraint on the data type.In case the given data type T is not a strictly upper triangular matrix type, a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_STRICTLY_UPPER_MATRIX_TYPE(T)   static_assert( !::blaze::IsStrictlyUpper<T>::value, "Strictly upper triangular matrix type detected" )
 Constraint on the data type.In case the given data type T is a strictly upper triangular matrix type, a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_BE_SUBEXPR_TYPE(T)   static_assert( ::blaze::IsSubExpr<T>::value, "Non-subtraction expression type detected" )
 Constraint on the data type.In case the given data type T is not a subtraction expression (i.e. a type derived from the SubExpr base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_SUBEXPR_TYPE(T)   static_assert( !::blaze::IsSubExpr<T>::value, "Subtraction expression type detected" )
 Constraint on the data type.In case the given data type T is a subtraction expression (i.e. a type derived from the SubExpr base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_BE_SUBMATRIX_TYPE(T)   static_assert( ::blaze::IsSubmatrix<T>::value, "Non-submatrix type detected" )
 Constraint on the data type.In case the given data type T is not a submatrix type (i.e. a dense or sparse submatrix), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_SUBMATRIX_TYPE(T)   static_assert( !::blaze::IsSubmatrix<T>::value, "Submatrix type detected" )
 Constraint on the data type.In case the given data type T is a submatrix type (i.e. a dense or sparse submatrix), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_BE_SUBVECTOR_TYPE(T)   static_assert( ::blaze::IsSubvector<T>::value, "Non-subvector type detected" )
 Constraint on the data type.In case the given data type T is not a subvector type (i.e. a dense or sparse subvector), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_SUBVECTOR_TYPE(T)   static_assert( !::blaze::IsSubvector<T>::value, "Subvector type detected" )
 Constraint on the data type.In case the given data type T is a subvector type (i.e. a dense or sparse subvector), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_BE_SYMMETRIC_MATRIX_TYPE(T)   static_assert( ::blaze::IsSymmetric<T>::value, "Non-symmetric matrix type detected" )
 Constraint on the data type.In case the given data type T is not a symmetric matrix type, a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_SYMMETRIC_MATRIX_TYPE(T)   static_assert( !::blaze::IsSymmetric<T>::value, "Symmetric matrix type detected" )
 Constraint on the data type.In case the given data type T is a symmetric matrix type, a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_BE_TRANSEXPR_TYPE(T)   static_assert( ::blaze::IsTransExpr<T>::value, "Non-transposition expression type detected" )
 Constraint on the data type.In case the given data type T is not a transposition expression (i.e. a type derived from the TransExpr base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_TRANSEXPR_TYPE(T)   static_assert( !::blaze::IsTransExpr<T>::value, "Transposition expression type detected" )
 Constraint on the data type.In case the given data type T is a transposition expression (i.e. a type derived from the TransExpr base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_BE_VECTOR_WITH_TRANSPOSE_FLAG(T, TF)
 Constraint on the data type.In case the given data type T is not a dense or sparse vector type and in case the transpose flag of the given dense or sparse vector type T is not set to TF, a compilation error is created. More...
 
#define BLAZE_CONSTRAINT_VECTORS_MUST_HAVE_SAME_TRANSPOSE_FLAG(T1, T2)
 Constraint on the data type.In case either of the two given data types T1 or T2 is not a vector type and in case the transpose flags of both vector types don't match, a compilation error is created. More...
 
#define BLAZE_CONSTRAINT_VECTORS_MUST_HAVE_DIFFERENT_TRANSPOSE_FLAG(T1, T2)
 Constraint on the data type.In case either of the two given data types T1 or T2 is not a vector type and in case the transpose flags of both vector types does match, a compilation error is created. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_TRIANGULAR_MATRIX_TYPE(T)   static_assert( ::blaze::IsTriangular<T>::value, "Non-triangular matrix type detected" )
 Constraint on the data type.In case the given data type T is not a lower or upper triangular matrix type, a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_TRIANGULAR_MATRIX_TYPE(T)   static_assert( !::blaze::IsTriangular<T>::value, "Triangular matrix type detected" )
 Constraint on the data type.In case the given data type T is a lower or upper triangular matrix type, a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_BE_TVECMATMULTEXPR_TYPE(T)   static_assert( ::blaze::IsTVecMatMultExpr<T>::value, "Non-vector/matrix multiplication expression type detected" )
 Constraint on the data type.In case the given data type T is not a vector/matrix multiplication expression (i.e. a type derived from the TVecMatMultExpr base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_TVECMATMULTEXPR_TYPE(T)   static_assert( !::blaze::IsTVecMatMultExpr<T>::value, "Vector/matrix multiplication expression type detected" )
 Constraint on the data type.In case the given data type T is a vector/matrix multiplication expression (i.e. a type derived from the TVecMatMultExpr base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_FORM_VALID_TVECMATMULTEXPR(T1, T2)
 Constraint on the data type.In case the given data types T1 and T2 do not form a valid vector/matrix multiplication, a compilation error is created. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_FORM_VALID_TVECMATMULTEXPR(T1, T2)
 Constraint on the data type.In case the given data types T1 and T2 do form a valid vector/matrix multiplication, a compilation error is created. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_UNILOWER_MATRIX_TYPE(T)   static_assert( ::blaze::IsUniLower<T>::value, "Non-lower unitriangular matrix type detected" )
 Constraint on the data type.In case the given data type T is not a lower unitriangular matrix type, a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_UNILOWER_MATRIX_TYPE(T)   static_assert( !::blaze::IsUniLower<T>::value, "Lower unitriangular matrix type detected" )
 Constraint on the data type.In case the given data type T is a lower unitriangular matrix type, a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_BE_UNITRIANGULAR_MATRIX_TYPE(T)   static_assert( ::blaze::IsUniTriangular<T>::value, "Non-unitriangular matrix type detected" )
 Constraint on the data type.In case the given data type T is not a lower or upper unitriangular matrix type, a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_UNITRIANGULAR_MATRIX_TYPE(T)   static_assert( !::blaze::IsUniTriangular<T>::value, "Unitriangular matrix type detected" )
 Constraint on the data type.In case the given data type T is a lower or upper unitriangular matrix type, a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_BE_UNIUPPER_MATRIX_TYPE(T)   static_assert( ::blaze::IsUniUpper<T>::value, "Non-upper unitriangular matrix type detected" )
 Constraint on the data type.In case the given data type T is not a upper unitriangular matrix type, a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_UNIUPPER_MATRIX_TYPE(T)   static_assert( !::blaze::IsUniUpper<T>::value, "Upper unitriangular matrix type detected" )
 Constraint on the data type.In case the given data type T is a upper unitriangular matrix type, a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_BE_UPPER_MATRIX_TYPE(T)   static_assert( ::blaze::IsUpper<T>::value, "Non-upper triangular matrix type detected" )
 Constraint on the data type.In case the given data type T is not a upper triangular matrix type, a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_UPPER_MATRIX_TYPE(T)   static_assert( !::blaze::IsUpper<T>::value, "Upper triangular matrix type detected" )
 Constraint on the data type.In case the given data type T is a upper triangular matrix type, a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_BE_VECEVALEXPR_TYPE(T)   static_assert( ::blaze::IsVecEvalExpr<T>::value, "Non-vector evaluation expression type detected" )
 Constraint on the data type.In case the given data type T is not a vector evaluation expression (i.e. a type derived from the VecEvalExpr base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_VECEVALEXPR_TYPE(T)   static_assert( !::blaze::IsVecEvalExpr<T>::value, "Vector evaluation expression type detected" )
 Constraint on the data type.In case the given data type T is a vector evaluation expression (i.e. a type derived from the VecEvalExpr base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_BE_VECFOREACHEXPR_TYPE(T)   static_assert( ::blaze::IsVecForEachExpr<T>::value, "Non-vector for-each expression type detected" )
 Constraint on the data type.In case the given data type T is not a vector for-each expression (i.e. a type derived from the VecForEachExpr base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_VECFOREACHEXPR_TYPE(T)   static_assert( !::blaze::IsVecForEachExpr<T>::value, "Vector for-each expression type detected" )
 Constraint on the data type.In case the given data type T is a vector for-each expression (i.e. a type derived from the VecForEachExpr base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_BE_VECSCALARDIVEXPR_TYPE(T)   static_assert( ::blaze::IsVecScalarDivExpr<T>::value, "Non-vector/scalar division expression type detected" )
 Constraint on the data type.In case the given data type T is not a vector/scalar division expression (i.e. a type derived from the VecScalarDivExpr base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_VECSCALARDIVEXPR_TYPE(T)   static_assert( !::blaze::IsVecScalarDivExpr<T>::value, "Vector/scalar division expression type detected" )
 Constraint on the data type.In case the given data type T is a vector/scalar division expression (i.e. a type derived from the VecScalarDivExpr base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_BE_VECSCALARMULTEXPR_TYPE(T)   static_assert( ::blaze::IsVecScalarMultExpr<T>::value, "Non-vector/scalar multiplication expression type detected" )
 Constraint on the data type.In case the given data type T is not a vector/scalar multiplication expression (i.e. a type derived from the VecScalarMultExpr base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_VECSCALARMULTEXPR_TYPE(T)   static_assert( !::blaze::IsVecScalarMultExpr<T>::value, "Vector/scalar multiplication expression type detected" )
 Constraint on the data type.In case the given data type T is a vector/scalar multiplication expression (i.e. a type derived from the VecScalarMultExpr base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_BE_VECSERIALEXPR_TYPE(T)   static_assert( ::blaze::IsVecSerialExpr<T>::value, "Non-vector serial evaluation expression type detected" )
 Constraint on the data type.In case the given data type T is not a vector serial evaluation expression (i.e. a type derived from the VecSerialExpr base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_VECSERIALEXPR_TYPE(T)   static_assert( !::blaze::IsVecSerialExpr<T>::value, "Vector serial evaluation expression type detected" )
 Constraint on the data type.In case the given data type T is a vector serial evaluation expression (i.e. a type derived from the VecSerialExpr base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_BE_VECTOR_TYPE(T)   static_assert( ::blaze::IsVector<T>::value, "Non-vector type detected" )
 Constraint on the data type.In case the given data type T is not a N-dimensional vector type, a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_VECTOR_TYPE(T)   static_assert( !::blaze::IsVector<T>::value, "Vector type detected" )
 Constraint on the data type.In case the given data type T is a N-dimensional vector type, a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_BE_VECTRANSEXPR_TYPE(T)   static_assert( ::blaze::IsVecTransExpr<T>::value, "Non-vector transposition expression type detected" )
 Constraint on the data type.In case the given data type T is not a vector transposition expression (i.e. a type derived from the VecTransExpr base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_VECTRANSEXPR_TYPE(T)   static_assert( !::blaze::IsVecTransExpr<T>::value, "Vector transposition expression type detected" )
 Constraint on the data type.In case the given data type T is a vector transposition expression (i.e. a type derived from the VecTransExpr base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_BE_VECTVECMULTEXPR_TYPE(T)   static_assert( ::blaze::IsVecTVecMultExpr<T>::value, "Non-outer product expression type detected" )
 Constraint on the data type.In case the given data type T is not an outer product expression (i.e. a type derived from the VecTVecMultExpr base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_VECTVECMULTEXPR_TYPE(T)   static_assert( !::blaze::IsVecTVecMultExpr<T>::value, "Outer product expression type detected" )
 Constraint on the data type.In case the given data type T is an outer product expression (i.e. a type derived from the VecTVecMultExpr base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_FORM_VALID_VECTVECMULTEXPR(T1, T2)
 Constraint on the data type.In case the given data types T1 and T2 do not form a valid vector/vector multiplication, a compilation error is created. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_FORM_VALID_VECTVECMULTEXPR(T1, T2)
 Constraint on the data type.In case the given data types T1 and T2 do form a valid vector/vector multiplication, a compilation error is created. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_VECVECADDEXPR_TYPE(T)   static_assert( ::blaze::IsVecVecAddExpr<T>::value, "Non-vector/vector addition expression type detected" )
 Constraint on the data type.In case the given data type T is not a vector/vector addition expression (i.e. a type derived from the VecVecAddExpr base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_VECVECADDEXPR_TYPE(T)   static_assert( !::blaze::IsVecVecAddExpr<T>::value, "Vector/vector addition expression type detected" )
 Constraint on the data type.In case the given data type T is a vector/vector addition expression (i.e. a type derived from the VecVecAddExpr base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_FORM_VALID_VECVECADDEXPR(T1, T2)
 Constraint on the data type.In case the given data types T1 and T2 do not form a valid vector/vector addition, a compilation error is created. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_FORM_VALID_VECVECADDEXPR(T1, T2)
 Constraint on the data type.In case the given data types T1 and T2 do form a valid vector/vector addition, a compilation error is created. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_VECVECDIVEXPR_TYPE(T)   static_assert( ::blaze::IsVecVecDivExpr<T>::value, "Non-vector/vector division expression type detected" )
 Constraint on the data type.In case the given data type T is not a vector/vector division expression (i.e. a type derived from the VecVecDivExpr base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_VECVECDIVEXPR_TYPE(T)   static_assert( !::blaze::IsVecVecDivExpr<T>::value, "Vector/vector division expression type detected" )
 Constraint on the data type.In case the given data type T is a vector/vector division expression (i.e. a type derived from the VecVecDivExpr base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_FORM_VALID_VECVECDIVEXPR(T1, T2)
 Constraint on the data type.In case the given data types T1 and T2 do not form a valid vector/vector division, a compilation error is created. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_FORM_VALID_VECVECDIVEXPR(T1, T2)
 Constraint on the data type.In case the given data types T1 and T2 do form a valid vector/vector division, a compilation error is created. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_VECVECMULTEXPR_TYPE(T)   static_assert( ::blaze::IsVecVecMultExpr<T>::value, "Non-vector/vector multiplication expression type detected" )
 Constraint on the data type.In case the given data type T is not a vector/vector multiplication expression (i.e. a type derived from the VecVecMultExpr base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_VECVECMULTEXPR_TYPE(T)   static_assert( !::blaze::IsVecVecMultExpr<T>::value, "Vector/vector multiplication expression type detected" )
 Constraint on the data type.In case the given data type T is a vector/vector multiplication expression (i.e. a type derived from the VecVecMultExpr base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_FORM_VALID_VECVECMULTEXPR(T1, T2)
 Constraint on the data type.In case the given data types T1 and T2 do not form a valid vector/vector multiplication, a compilation error is created. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_FORM_VALID_VECVECMULTEXPR(T1, T2)
 Constraint on the data type.In case the given data types T1 and T2 do form a valid vector/vector multiplication, a compilation error is created. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_VECVECSUBEXPR_TYPE(T)   static_assert( ::blaze::IsVecVecSubExpr<T>::value, "Non-vector/vector subtraction expression type detected" )
 Constraint on the data type.In case the given data type T is not a vector/vector subtraction expression (i.e. a type derived from the VecVecSubExpr base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_VECVECSUBEXPR_TYPE(T)   static_assert( !::blaze::IsVecVecSubExpr<T>::value, "Vector/vector subtraction expression type detected" )
 Constraint on the data type.In case the given data type T is a vector/vector subtraction expression (i.e. a type derived from the VecVecSubExpr base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_FORM_VALID_VECVECSUBEXPR(T1, T2)
 Constraint on the data type.In case the given data types T1 and T2 do not form a valid vector/vector subtraction, a compilation error is created. More...
 
#define BLAZE_CONSTRAINT_MUST_NOT_FORM_VALID_VECVECSUBEXPR(T1, T2)
 Constraint on the data type.In case the given data types T1 and T2 do form a valid vector/vector subtraction, a compilation error is created. More...
 
#define BLAZE_CONSTRAINT_MUST_BE_VIEW_TYPE(T)   static_assert( ::blaze::IsView<T>::value, "Non-view type detected" )
 Constraint on the data type.In case the given data type T is not a view type (i.e. a subvector, submatrix, row, column, ...), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_VIEW_TYPE(T)   static_assert( !::blaze::IsView<T>::value, "View type detected" )
 Constraint on the data type.In case the given data type T is a view type (i.e. a subvector, submatrix, row, column, ...), a compilation error is created.
 

Detailed Description

Macro Definition Documentation

#define BLAZE_CONSTRAINT_MATRICES_MUST_HAVE_DIFFERENT_STORAGE_ORDER (   T1,
  T2 
)
Value:
static_assert( ::blaze::IsMatrix<T1>::value && \
::blaze::StorageOrder<T1>::value != ::blaze::StorageOrder<T2>::value, "Invalid storage order detected" )
Compile time check for matrix types.This type trait tests whether or not the given template parameter...
Definition: IsMatrix.h:78
Evaluation of the storage order of a given matrix type.Via this type trait it is possible to evaluate...
Definition: StorageOrder.h:77

Constraint on the data type.In case either of the two given data types T1 or T2 is not a matrix type and in case the storage order of both matrix types does match, a compilation error is created.

#define BLAZE_CONSTRAINT_MATRICES_MUST_HAVE_SAME_STORAGE_ORDER (   T1,
  T2 
)
Value:
static_assert( ::blaze::IsMatrix<T1>::value && \
::blaze::StorageOrder<T1>::value == ::blaze::StorageOrder<T2>::value, "Invalid storage order failed" )
Compile time check for matrix types.This type trait tests whether or not the given template parameter...
Definition: IsMatrix.h:78
Evaluation of the storage order of a given matrix type.Via this type trait it is possible to evaluate...
Definition: StorageOrder.h:77

Constraint on the data type.In case either of the two given data types T1 or T2 is not a matrix type and in case the storage order of both matrix types doesn't match, a compilation error is created.

#define BLAZE_CONSTRAINT_MUST_BE_MATRIX_WITH_STORAGE_ORDER (   T,
  SO 
)
Value:
static_assert( ::blaze::IsMatrix<T>::value && \
::blaze::StorageOrder<T>::value == SO, "Invalid storage order detected" )
Compile time check for matrix types.This type trait tests whether or not the given template parameter...
Definition: IsMatrix.h:78
Evaluation of the storage order of a given matrix type.Via this type trait it is possible to evaluate...
Definition: StorageOrder.h:77

Constraint on the data type.In case the given data type T is not a dense or sparse matrix type and in case the storage order of the given dense or sparse vector type T is not set to SO, a compilation error is created.

#define BLAZE_CONSTRAINT_MUST_BE_VECTOR_WITH_TRANSPOSE_FLAG (   T,
  TF 
)
Value:
static_assert( ::blaze::IsVector<T>::value && \
::blaze::TransposeFlag<T>::value == TF, "Invalid transpose flag detected" )
Compile time check for vector types.This type trait tests whether or not the given template parameter...
Definition: IsVector.h:78
Evaluation of the transpose flag of a given matrix type.Via this type trait it is possible to evaluat...
Definition: TransposeFlag.h:77

Constraint on the data type.In case the given data type T is not a dense or sparse vector type and in case the transpose flag of the given dense or sparse vector type T is not set to TF, a compilation error is created.

#define BLAZE_CONSTRAINT_MUST_FORM_VALID_MATMATADDEXPR (   T1,
  T2 
)
Value:
static_assert( ::blaze::And< ::blaze::IsMatrix<T1> \
>::value, "Invalid matrix/matrix addition expression detected" )
Compile time type comparison.The Equal class template compares the two given types using the equality...
Definition: Equal.h:73
Compile time check for matrix types.This type trait tests whether or not the given template parameter...
Definition: IsMatrix.h:78
Compile time logical or evaluation.The Or class template performs at compile time a logical or ('&&')...
Definition: Or.h:101
Compile time evaluation of the number of columns of a matrix.The Columns type trait evaluates the num...
Definition: Columns.h:76
Compile time evaluation of the number of rows of a matrix.The Rows type trait evaluates the number of...
Definition: Rows.h:76
Compile time logical and evaluation.The And class template performs at compile time a logical and ('&&...
Definition: And.h:101

Constraint on the data type.In case the given data types T1 and T2 do not form a valid matrix/matrix addition, a compilation error is created.

#define BLAZE_CONSTRAINT_MUST_FORM_VALID_MATMATMULTEXPR (   T1,
  T2 
)
Value:
static_assert( ::blaze::And< ::blaze::IsMatrix<T1> \
>::value, "Invalid matrix/matrix multiplication expression detected" )
Compile time type comparison.The Equal class template compares the two given types using the equality...
Definition: Equal.h:73
Compile time check for matrix types.This type trait tests whether or not the given template parameter...
Definition: IsMatrix.h:78
Compile time logical or evaluation.The Or class template performs at compile time a logical or ('&&')...
Definition: Or.h:101
Compile time evaluation of the number of columns of a matrix.The Columns type trait evaluates the num...
Definition: Columns.h:76
Compile time evaluation of the number of rows of a matrix.The Rows type trait evaluates the number of...
Definition: Rows.h:76
Compile time logical and evaluation.The And class template performs at compile time a logical and ('&&...
Definition: And.h:101

Constraint on the data type.In case the given data types T1 and T2 do not form a valid matrix/matrix multiplication, a compilation error is created.

#define BLAZE_CONSTRAINT_MUST_FORM_VALID_MATMATSUBEXPR (   T1,
  T2 
)
Value:
static_assert( ::blaze::And< ::blaze::IsMatrix<T1> \
>::value, "Invalid matrix/matrix subtraction expression detected" )
Compile time type comparison.The Equal class template compares the two given types using the equality...
Definition: Equal.h:73
Compile time check for matrix types.This type trait tests whether or not the given template parameter...
Definition: IsMatrix.h:78
Compile time logical or evaluation.The Or class template performs at compile time a logical or ('&&')...
Definition: Or.h:101
Compile time evaluation of the number of columns of a matrix.The Columns type trait evaluates the num...
Definition: Columns.h:76
Compile time evaluation of the number of rows of a matrix.The Rows type trait evaluates the number of...
Definition: Rows.h:76
Compile time logical and evaluation.The And class template performs at compile time a logical and ('&&...
Definition: And.h:101

Constraint on the data type.In case the given data types T1 and T2 do not form a valid matrix/matrix subtraction, a compilation error is created.

#define BLAZE_CONSTRAINT_MUST_FORM_VALID_MATVECMULTEXPR (   T1,
  T2 
)
Value:
static_assert( ::blaze::And< ::blaze::IsMatrix<T1> \
>::value, "Invalid matrix/vector multiplication expression detected" )
Compile time type comparison.The Equal class template compares the two given types using the equality...
Definition: Equal.h:73
Compile time check for matrix types.This type trait tests whether or not the given template parameter...
Definition: IsMatrix.h:78
Compile time check for column vector types.This type trait tests whether or not the given template ar...
Definition: IsColumnVector.h:80
Compile time logical or evaluation.The Or class template performs at compile time a logical or ('&&')...
Definition: Or.h:101
Compile time evaluation of the size of a vector.The Size type trait evaluates the size of the given v...
Definition: Size.h:75
Compile time evaluation of the number of columns of a matrix.The Columns type trait evaluates the num...
Definition: Columns.h:76
Compile time logical and evaluation.The And class template performs at compile time a logical and ('&&...
Definition: And.h:101

Constraint on the data type.In case the given data types T1 and T2 do not form a valid matrix/vector multiplication, a compilation error is created.

#define BLAZE_CONSTRAINT_MUST_FORM_VALID_TVECMATMULTEXPR (   T1,
  T2 
)
Value:
static_assert( ::blaze::And< ::blaze::IsRowVector<T1> \
>::value, "Invalid vector/matrix multiplication expression detected" )
Compile time check for row vector types.This type trait tests whether or not the given template argum...
Definition: IsRowVector.h:80
Compile time type comparison.The Equal class template compares the two given types using the equality...
Definition: Equal.h:73
Compile time check for matrix types.This type trait tests whether or not the given template parameter...
Definition: IsMatrix.h:78
Compile time logical or evaluation.The Or class template performs at compile time a logical or ('&&')...
Definition: Or.h:101
Compile time evaluation of the size of a vector.The Size type trait evaluates the size of the given v...
Definition: Size.h:75
Compile time evaluation of the number of rows of a matrix.The Rows type trait evaluates the number of...
Definition: Rows.h:76
Compile time logical and evaluation.The And class template performs at compile time a logical and ('&&...
Definition: And.h:101

Constraint on the data type.In case the given data types T1 and T2 do not form a valid vector/matrix multiplication, a compilation error is created.

#define BLAZE_CONSTRAINT_MUST_FORM_VALID_VECTVECMULTEXPR (   T1,
  T2 
)
Value:
>::value, "Invalid vector/vector multiplication expression detected" )
Compile time check for row vector types.This type trait tests whether or not the given template argum...
Definition: IsRowVector.h:80
Compile time check for column vector types.This type trait tests whether or not the given template ar...
Definition: IsColumnVector.h:80
Compile time logical and evaluation.The And class template performs at compile time a logical and ('&&...
Definition: And.h:101

Constraint on the data type.In case the given data types T1 and T2 do not form a valid vector/vector multiplication, a compilation error is created.

#define BLAZE_CONSTRAINT_MUST_FORM_VALID_VECVECADDEXPR (   T1,
  T2 
)
Value:
>::value, "Invalid vector/vector addition expression detected" )
Compile time check for row vector types.This type trait tests whether or not the given template argum...
Definition: IsRowVector.h:80
Compile time type comparison.The Equal class template compares the two given types using the equality...
Definition: Equal.h:73
Compile time check for column vector types.This type trait tests whether or not the given template ar...
Definition: IsColumnVector.h:80
Compile time logical or evaluation.The Or class template performs at compile time a logical or ('&&')...
Definition: Or.h:101
Compile time evaluation of the size of a vector.The Size type trait evaluates the size of the given v...
Definition: Size.h:75
Compile time logical and evaluation.The And class template performs at compile time a logical and ('&&...
Definition: And.h:101

Constraint on the data type.In case the given data types T1 and T2 do not form a valid vector/vector addition, a compilation error is created.

#define BLAZE_CONSTRAINT_MUST_FORM_VALID_VECVECDIVEXPR (   T1,
  T2 
)
Value:
>::value, "Invalid vector/vector division expression detected" )
Compile time check for row vector types.This type trait tests whether or not the given template argum...
Definition: IsRowVector.h:80
Compile time type comparison.The Equal class template compares the two given types using the equality...
Definition: Equal.h:73
Compile time check for column vector types.This type trait tests whether or not the given template ar...
Definition: IsColumnVector.h:80
Compile time logical or evaluation.The Or class template performs at compile time a logical or ('&&')...
Definition: Or.h:101
Compile time evaluation of the size of a vector.The Size type trait evaluates the size of the given v...
Definition: Size.h:75
Compile time logical and evaluation.The And class template performs at compile time a logical and ('&&...
Definition: And.h:101

Constraint on the data type.In case the given data types T1 and T2 do not form a valid vector/vector division, a compilation error is created.

#define BLAZE_CONSTRAINT_MUST_FORM_VALID_VECVECMULTEXPR (   T1,
  T2 
)
Value:
>::value, "Invalid vector/vector multiplication expression detected" )
Compile time check for row vector types.This type trait tests whether or not the given template argum...
Definition: IsRowVector.h:80
Compile time type comparison.The Equal class template compares the two given types using the equality...
Definition: Equal.h:73
Compile time check for column vector types.This type trait tests whether or not the given template ar...
Definition: IsColumnVector.h:80
Compile time logical or evaluation.The Or class template performs at compile time a logical or ('&&')...
Definition: Or.h:101
Compile time evaluation of the size of a vector.The Size type trait evaluates the size of the given v...
Definition: Size.h:75
Compile time logical and evaluation.The And class template performs at compile time a logical and ('&&...
Definition: And.h:101

Constraint on the data type.In case the given data types T1 and T2 do not form a valid vector/vector multiplication, a compilation error is created.

#define BLAZE_CONSTRAINT_MUST_FORM_VALID_VECVECSUBEXPR (   T1,
  T2 
)
Value:
>::value, "Invalid vector/vector subtraction expression detected" )
Compile time check for row vector types.This type trait tests whether or not the given template argum...
Definition: IsRowVector.h:80
Compile time type comparison.The Equal class template compares the two given types using the equality...
Definition: Equal.h:73
Compile time check for column vector types.This type trait tests whether or not the given template ar...
Definition: IsColumnVector.h:80
Compile time logical or evaluation.The Or class template performs at compile time a logical or ('&&')...
Definition: Or.h:101
Compile time evaluation of the size of a vector.The Size type trait evaluates the size of the given v...
Definition: Size.h:75
Compile time logical and evaluation.The And class template performs at compile time a logical and ('&&...
Definition: And.h:101

Constraint on the data type.In case the given data types T1 and T2 do not form a valid vector/vector subtraction, a compilation error is created.

#define BLAZE_CONSTRAINT_MUST_HAVE_EQUAL_NUMBER_OF_COLUMNS (   T1,
  T2 
)
Value:
>::value, "Invalid number of columns detected" )
Compile time type comparison.The Equal class template compares the two given types using the equality...
Definition: Equal.h:73
Compile time logical or evaluation.The Or class template performs at compile time a logical or ('&&')...
Definition: Or.h:101
Compile time evaluation of the number of columns of a matrix.The Columns type trait evaluates the num...
Definition: Columns.h:76

Constraint on the data type.In case the number of columns of the two given matrix types T1 and T2 can be evaluated at compile time and in case the number of columns is not equal, a compilation error is created. Note that in case the number of columns of either of the two matrix types cannot be determined no compilation error is created.

#define BLAZE_CONSTRAINT_MUST_HAVE_EQUAL_NUMBER_OF_ROWS (   T1,
  T2 
)
Value:
>::value, "Invalid number of rows detected" )
Compile time type comparison.The Equal class template compares the two given types using the equality...
Definition: Equal.h:73
Compile time logical or evaluation.The Or class template performs at compile time a logical or ('&&')...
Definition: Or.h:101
Compile time evaluation of the number of rows of a matrix.The Rows type trait evaluates the number of...
Definition: Rows.h:76

Constraint on the data type.In case the number of rows of the two given matrix types T1 and T2 can be evaluated at compile time and in case the number of rows is not equal, a compilation error is created. Note that in case the number of rows of either of the two matrix types cannot be determined no compilation error is created.

#define BLAZE_CONSTRAINT_MUST_HAVE_EQUAL_SIZE (   T1,
  T2 
)
Value:
>::value, "Invalid size detected" )
Compile time type comparison.The Equal class template compares the two given types using the equality...
Definition: Equal.h:73
Compile time logical or evaluation.The Or class template performs at compile time a logical or ('&&')...
Definition: Or.h:101
Compile time evaluation of the size of a vector.The Size type trait evaluates the size of the given v...
Definition: Size.h:75

Constraint on the data type.In case the size of the two given vector types T1 and T2 can be evaluated at compile time and in case these sizes are not equal, a compilation error is created. Note that in case the size of either of the two vector types cannot be determined no compilation error is created.

#define BLAZE_CONSTRAINT_MUST_NOT_FORM_VALID_MATMATADDEXPR (   T1,
  T2 
)
Value:
static_assert( ::blaze::Not< ::blaze::And< ::blaze::IsMatrix<T1> \
>::value, "Valid matrix/matrix addition expression detected" )
Compile time type comparison.The Equal class template compares the two given types using the equality...
Definition: Equal.h:73
Compile time check for matrix types.This type trait tests whether or not the given template parameter...
Definition: IsMatrix.h:78
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:
Definition: Not.h:70
Compile time logical or evaluation.The Or class template performs at compile time a logical or ('&&')...
Definition: Or.h:101
Compile time evaluation of the number of columns of a matrix.The Columns type trait evaluates the num...
Definition: Columns.h:76
Compile time evaluation of the number of rows of a matrix.The Rows type trait evaluates the number of...
Definition: Rows.h:76
Compile time logical and evaluation.The And class template performs at compile time a logical and ('&&...
Definition: And.h:101

Constraint on the data type.In case the given data types T1 and T2 do form a valid matrix/matrix addition, a compilation error is created.

#define BLAZE_CONSTRAINT_MUST_NOT_FORM_VALID_MATMATMULTEXPR (   T1,
  T2 
)
Value:
static_assert( ::blaze::Not< ::blaze::And< ::blaze::IsMatrix<T1> \
>::value, "Valid matrix/matrix multiplication expression detected" )
Compile time type comparison.The Equal class template compares the two given types using the equality...
Definition: Equal.h:73
Compile time check for matrix types.This type trait tests whether or not the given template parameter...
Definition: IsMatrix.h:78
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:
Definition: Not.h:70
Compile time logical or evaluation.The Or class template performs at compile time a logical or ('&&')...
Definition: Or.h:101
Compile time evaluation of the number of columns of a matrix.The Columns type trait evaluates the num...
Definition: Columns.h:76
Compile time evaluation of the number of rows of a matrix.The Rows type trait evaluates the number of...
Definition: Rows.h:76
Compile time logical and evaluation.The And class template performs at compile time a logical and ('&&...
Definition: And.h:101

Constraint on the data type.In case the given data types T1 and T2 do form a valid matrix/matrix multiplication, a compilation error is created.

#define BLAZE_CONSTRAINT_MUST_NOT_FORM_VALID_MATMATSUBEXPR (   T1,
  T2 
)
Value:
static_assert( ::blaze::Not< ::blaze::And< ::blaze::IsMatrix<T1> \
>::value, "Valid matrix/matrix subtraction expression detected" )
Compile time type comparison.The Equal class template compares the two given types using the equality...
Definition: Equal.h:73
Compile time check for matrix types.This type trait tests whether or not the given template parameter...
Definition: IsMatrix.h:78
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:
Definition: Not.h:70
Compile time logical or evaluation.The Or class template performs at compile time a logical or ('&&')...
Definition: Or.h:101
Compile time evaluation of the number of columns of a matrix.The Columns type trait evaluates the num...
Definition: Columns.h:76
Compile time evaluation of the number of rows of a matrix.The Rows type trait evaluates the number of...
Definition: Rows.h:76
Compile time logical and evaluation.The And class template performs at compile time a logical and ('&&...
Definition: And.h:101

Constraint on the data type.In case the given data types T1 and T2 do form a valid matrix/matrix subtraction, a compilation error is created.

#define BLAZE_CONSTRAINT_MUST_NOT_FORM_VALID_MATVECMULTEXPR (   T1,
  T2 
)
Value:
static_assert( ::blaze::Not< ::blaze::And< ::blaze::IsMatrix<T1> \
>::value, "Valid matrix/vector multiplication expression detected" )
Compile time type comparison.The Equal class template compares the two given types using the equality...
Definition: Equal.h:73
Compile time check for matrix types.This type trait tests whether or not the given template parameter...
Definition: IsMatrix.h:78
Compile time check for column vector types.This type trait tests whether or not the given template ar...
Definition: IsColumnVector.h:80
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:
Definition: Not.h:70
Compile time logical or evaluation.The Or class template performs at compile time a logical or ('&&')...
Definition: Or.h:101
Compile time evaluation of the size of a vector.The Size type trait evaluates the size of the given v...
Definition: Size.h:75
Compile time evaluation of the number of columns of a matrix.The Columns type trait evaluates the num...
Definition: Columns.h:76
Compile time logical and evaluation.The And class template performs at compile time a logical and ('&&...
Definition: And.h:101

Constraint on the data type.In case the given data types T1 and T2 do form a valid matrix/vector multiplication, a compilation error is created.

#define BLAZE_CONSTRAINT_MUST_NOT_FORM_VALID_TVECMATMULTEXPR (   T1,
  T2 
)
Value:
>::value, "Valid vector/matrix multiplication expression detected" )
Compile time check for row vector types.This type trait tests whether or not the given template argum...
Definition: IsRowVector.h:80
Compile time type comparison.The Equal class template compares the two given types using the equality...
Definition: Equal.h:73
Compile time check for matrix types.This type trait tests whether or not the given template parameter...
Definition: IsMatrix.h:78
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:
Definition: Not.h:70
Compile time logical or evaluation.The Or class template performs at compile time a logical or ('&&')...
Definition: Or.h:101
Compile time evaluation of the size of a vector.The Size type trait evaluates the size of the given v...
Definition: Size.h:75
Compile time evaluation of the number of rows of a matrix.The Rows type trait evaluates the number of...
Definition: Rows.h:76
Compile time logical and evaluation.The And class template performs at compile time a logical and ('&&...
Definition: And.h:101

Constraint on the data type.In case the given data types T1 and T2 do form a valid vector/matrix multiplication, a compilation error is created.

#define BLAZE_CONSTRAINT_MUST_NOT_FORM_VALID_VECTVECMULTEXPR (   T1,
  T2 
)
Value:
>::value, "Valid vector/vector multiplication expression detected" )
Compile time check for row vector types.This type trait tests whether or not the given template argum...
Definition: IsRowVector.h:80
Compile time check for column vector types.This type trait tests whether or not the given template ar...
Definition: IsColumnVector.h:80
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:
Definition: Not.h:70
Compile time logical and evaluation.The And class template performs at compile time a logical and ('&&...
Definition: And.h:101

Constraint on the data type.In case the given data types T1 and T2 do form a valid vector/vector multiplication, a compilation error is created.

#define BLAZE_CONSTRAINT_MUST_NOT_FORM_VALID_VECVECADDEXPR (   T1,
  T2 
)
Value:
>::value, "" )
Compile time check for row vector types.This type trait tests whether or not the given template argum...
Definition: IsRowVector.h:80
Compile time type comparison.The Equal class template compares the two given types using the equality...
Definition: Equal.h:73
Compile time check for column vector types.This type trait tests whether or not the given template ar...
Definition: IsColumnVector.h:80
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:
Definition: Not.h:70
Compile time logical or evaluation.The Or class template performs at compile time a logical or ('&&')...
Definition: Or.h:101
Compile time evaluation of the size of a vector.The Size type trait evaluates the size of the given v...
Definition: Size.h:75
Compile time logical and evaluation.The And class template performs at compile time a logical and ('&&...
Definition: And.h:101

Constraint on the data type.In case the given data types T1 and T2 do form a valid vector/vector addition, a compilation error is created.

#define BLAZE_CONSTRAINT_MUST_NOT_FORM_VALID_VECVECDIVEXPR (   T1,
  T2 
)
Value:
>::value, "Valid vector/vector division expression detected" )
Compile time check for row vector types.This type trait tests whether or not the given template argum...
Definition: IsRowVector.h:80
Compile time type comparison.The Equal class template compares the two given types using the equality...
Definition: Equal.h:73
Compile time check for column vector types.This type trait tests whether or not the given template ar...
Definition: IsColumnVector.h:80
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:
Definition: Not.h:70
Compile time logical or evaluation.The Or class template performs at compile time a logical or ('&&')...
Definition: Or.h:101
Compile time evaluation of the size of a vector.The Size type trait evaluates the size of the given v...
Definition: Size.h:75
Compile time logical and evaluation.The And class template performs at compile time a logical and ('&&...
Definition: And.h:101

Constraint on the data type.In case the given data types T1 and T2 do form a valid vector/vector division, a compilation error is created.

#define BLAZE_CONSTRAINT_MUST_NOT_FORM_VALID_VECVECMULTEXPR (   T1,
  T2 
)
Value:
>::value, "Valid vector/vector multiplication expression detected" )
Compile time check for row vector types.This type trait tests whether or not the given template argum...
Definition: IsRowVector.h:80
Compile time type comparison.The Equal class template compares the two given types using the equality...
Definition: Equal.h:73
Compile time check for column vector types.This type trait tests whether or not the given template ar...
Definition: IsColumnVector.h:80
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:
Definition: Not.h:70
Compile time logical or evaluation.The Or class template performs at compile time a logical or ('&&')...
Definition: Or.h:101
Compile time evaluation of the size of a vector.The Size type trait evaluates the size of the given v...
Definition: Size.h:75
Compile time logical and evaluation.The And class template performs at compile time a logical and ('&&...
Definition: And.h:101

Constraint on the data type.In case the given data types T1 and T2 do form a valid vector/vector multiplication, a compilation error is created.

#define BLAZE_CONSTRAINT_MUST_NOT_FORM_VALID_VECVECSUBEXPR (   T1,
  T2 
)
Value:
>::value, "Valid vector/vector subtraction expression detected" )
Compile time check for row vector types.This type trait tests whether or not the given template argum...
Definition: IsRowVector.h:80
Compile time type comparison.The Equal class template compares the two given types using the equality...
Definition: Equal.h:73
Compile time check for column vector types.This type trait tests whether or not the given template ar...
Definition: IsColumnVector.h:80
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:
Definition: Not.h:70
Compile time logical or evaluation.The Or class template performs at compile time a logical or ('&&')...
Definition: Or.h:101
Compile time evaluation of the size of a vector.The Size type trait evaluates the size of the given v...
Definition: Size.h:75
Compile time logical and evaluation.The And class template performs at compile time a logical and ('&&...
Definition: And.h:101

Constraint on the data type.In case the given data types T1 and T2 do form a valid vector/vector subtraction, a compilation error is created.

#define BLAZE_CONSTRAINT_MUST_NOT_HAVE_EQUAL_NUMBER_OF_COLUMNS (   T1,
  T2 
)
Value:
>::value, "Invalid number of columns detected" )
Compile time type comparison.The Equal class template compares the two given types using the equality...
Definition: Equal.h:73
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:
Definition: Not.h:70
Compile time logical or evaluation.The Or class template performs at compile time a logical or ('&&')...
Definition: Or.h:101
Compile time evaluation of the number of columns of a matrix.The Columns type trait evaluates the num...
Definition: Columns.h:76

Constraint on the data type.In case the number of columns of the two given matrix types T1 and T2 can be evaluated at compile time and in case the number of columns is equal, a compilation error is created. Note that in case the number of columns of either of the two matrix types cannot be determined no compilation error is created.

#define BLAZE_CONSTRAINT_MUST_NOT_HAVE_EQUAL_NUMBER_OF_ROWS (   T1,
  T2 
)
Value:
>::value, "Invalid number of rows detected" )
Compile time type comparison.The Equal class template compares the two given types using the equality...
Definition: Equal.h:73
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:
Definition: Not.h:70
Compile time logical or evaluation.The Or class template performs at compile time a logical or ('&&')...
Definition: Or.h:101
Compile time evaluation of the number of rows of a matrix.The Rows type trait evaluates the number of...
Definition: Rows.h:76

Constraint on the data type.In case the number of rows of the two given matrix types T1 and T2 can be evaluated at compile time and in case the number of rows is equal, a compilation error is created. Note that in case the number of rows of either of the two matrix types cannot be determined no compilation error is created.

#define BLAZE_CONSTRAINT_MUST_NOT_HAVE_EQUAL_SIZE (   T1,
  T2 
)
Value:
>::value, "Invalid size detected" )
Compile time type comparison.The Equal class template compares the two given types using the equality...
Definition: Equal.h:73
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:
Definition: Not.h:70
Compile time logical or evaluation.The Or class template performs at compile time a logical or ('&&')...
Definition: Or.h:101
Compile time evaluation of the size of a vector.The Size type trait evaluates the size of the given v...
Definition: Size.h:75

Constraint on the data type.In case the size of the two given vector types T1 and T2 can be evaluated at compile time and in case these sizes are equal, a compilation error is created. Note that in case the size of either of the two vector types cannot be determined no compilation error is created.

#define BLAZE_CONSTRAINT_VECTORS_MUST_HAVE_DIFFERENT_TRANSPOSE_FLAG (   T1,
  T2 
)
Value:
static_assert( ::blaze::IsVector<T1>::value && \
::blaze::TransposeFlag<T1>::value != ::blaze::TransposeFlag<T2>::value, "Invalid transpose flag detected" )
Compile time check for vector types.This type trait tests whether or not the given template parameter...
Definition: IsVector.h:78
Evaluation of the transpose flag of a given matrix type.Via this type trait it is possible to evaluat...
Definition: TransposeFlag.h:77

Constraint on the data type.In case either of the two given data types T1 or T2 is not a vector type and in case the transpose flags of both vector types does match, a compilation error is created.

#define BLAZE_CONSTRAINT_VECTORS_MUST_HAVE_SAME_TRANSPOSE_FLAG (   T1,
  T2 
)
Value:
static_assert( ::blaze::IsVector<T1>::value && \
::blaze::TransposeFlag<T1>::value == ::blaze::TransposeFlag<T2>::value, "Invalid transpose flag detected" )
Compile time check for vector types.This type trait tests whether or not the given template parameter...
Definition: IsVector.h:78
Evaluation of the transpose flag of a given matrix type.Via this type trait it is possible to evaluat...
Definition: TransposeFlag.h:77

Constraint on the data type.In case either of the two given data types T1 or T2 is not a vector type and in case the transpose flags of both vector types don't match, a compilation error is created.