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_BINARYMAPEXPR_TYPE(T)   static_assert( ::blaze::IsBinaryMapExpr<T>::value, "Non-binary map expression type detected" )
 Constraint on the data type.In case the given data type T is not a binary map expression (i.e. a type derived from the BinaryMapExpr base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_BINARYMAPEXPR_TYPE(T)   static_assert( !::blaze::IsBinaryMapExpr<T>::value, "Binary map expression type detected" )
 Constraint on the data type.In case the given data type T is a binary map expression (i.e. a type derived from the BinaryMapExpr base class), 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_DECLARATION_TYPE(T)   static_assert( ::blaze::IsDeclaration<T>::value, "Non-declaration type detected" )
 Constraint on the data type.In case the given data type T is not a declaration expression (i.e. a type derived from the Declaration base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_DECLARATION_TYPE(T)   static_assert( !::blaze::IsDeclaration<T>::value, "Declaration type detected" )
 Constraint on the data type.In case the given data type T is a declaration expression (i.e. a type derived from the Declaration base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_BE_DECLDIAGEXPR_TYPE(T)   static_assert( ::blaze::IsDeclDiagExpr<T>::value, "Non-decldiag expression type detected" )
 Constraint on the data type.In case the given data type T is not a decldiag expression (i.e. a type derived from the DeclDiagExpr base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_DECLDIAGEXPR_TYPE(T)   static_assert( !::blaze::IsDeclDiagExpr<T>::value, "Decldiag expression type detected" )
 Constraint on the data type.In case the given data type T is a decldiag expression (i.e. a type derived from the DeclDiagExpr base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_BE_DECLEXPR_TYPE(T)   static_assert( ::blaze::IsDeclExpr<T>::value, "Non-declaration expression type detected" )
 Constraint on the data type.In case the given data type T is not a declaration expression (i.e. a type derived from the DeclExpr base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_DECLEXPR_TYPE(T)   static_assert( !::blaze::IsDeclExpr<T>::value, "Declaration expression type detected" )
 Constraint on the data type.In case the given data type T is a declaration expression (i.e. a type derived from the DeclExpr base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_BE_DECLHERMEXPR_TYPE(T)   static_assert( ::blaze::IsDeclHermExpr<T>::value, "Non-declherm expression type detected" )
 Constraint on the data type.In case the given data type T is not a declherm expression (i.e. a type derived from the DeclHermExpr base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_DECLHERMEXPR_TYPE(T)   static_assert( !::blaze::IsDeclHermExpr<T>::value, "Declherm expression type detected" )
 Constraint on the data type.In case the given data type T is a declherm expression (i.e. a type derived from the DeclHermExpr base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_BE_DECLLOWEXPR_TYPE(T)   static_assert( ::blaze::IsDeclLowExpr<T>::value, "Non-decllow expression type detected" )
 Constraint on the data type.In case the given data type T is not a decllow expression (i.e. a type derived from the DeclLowExpr base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_DECLLOWEXPR_TYPE(T)   static_assert( !::blaze::IsDeclLowExpr<T>::value, "Decllow expression type detected" )
 Constraint on the data type.In case the given data type T is a decllow expression (i.e. a type derived from the DeclLowExpr base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_BE_DECLSYMEXPR_TYPE(T)   static_assert( ::blaze::IsDeclSymExpr<T>::value, "Non-declsym expression type detected" )
 Constraint on the data type.In case the given data type T is not a declsym expression (i.e. a type derived from the DeclSymExpr base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_DECLSYMEXPR_TYPE(T)   static_assert( !::blaze::IsDeclSymExpr<T>::value, "Declsym expression type detected" )
 Constraint on the data type.In case the given data type T is a declsym expression (i.e. a type derived from the DeclSymExpr base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_BE_DECLUPPEXPR_TYPE(T)   static_assert( ::blaze::IsDeclUppExpr<T>::value, "Non-declupp expression type detected" )
 Constraint on the data type.In case the given data type T is not a declupp expression (i.e. a type derived from the DeclUppExpr base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_DECLUPPEXPR_TYPE(T)   static_assert( !::blaze::IsDeclUppExpr<T>::value, "Declupp expression type detected" )
 Constraint on the data type.In case the given data type T is a declupp expression (i.e. a type derived from the DeclUppExpr base class), 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_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_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_MATMAPEXPR_TYPE(T)   static_assert( ::blaze::IsMatMapExpr<T>::value, "Non-unary matrix map expression type detected" )
 Constraint on the data type.In case the given data type T is not a unary matrix map expression (i.e. a type derived from the MatMapExpr base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_MATMAPEXPR_TYPE(T)   static_assert( !::blaze::IsMatMapExpr<T>::value, "Unary matrix map expression type detected" )
 Constraint on the data type.In case the given data type T is a unary matrix map expression (i.e. a type derived from the MatMapExpr 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_BE_MATMATMAPEXPR_TYPE(T)   static_assert( ::blaze::IsMatMatMapExpr<T>::value, "Non-binary matrix map expression type detected" )
 Constraint on the data type.In case the given data type T is not a binary matrix map expression (i.e. a type derived from the MatMatMapExpr base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_MATMATMAPEXPR_TYPE(T)   static_assert( !::blaze::IsMatMatMapExpr<T>::value, "Binary matrix map expression type detected" )
 Constraint on the data type.In case the given data type T is a binary matrix map expression (i.e. a type derived from the MatMatMapExpr base class), a compilation error is created.
 
#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_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_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_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>, "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_OPERATION_TYPE(T)   static_assert( ::blaze::IsOperation<T>::value, "Non-operation type detected" )
 Constraint on the data type.In case the given data type T is not an operational expression (i.e. a type derived from the Operation base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_OPERATION_TYPE(T)   static_assert( !::blaze::IsOperation<T>::value, "Operation type detected" )
 Constraint on the data type.In case the given data type T is an operational expression (i.e. a type derived from the Operation base class), 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_TYPE(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_TYPE(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_SCHUREXPR_TYPE(T)   static_assert( ::blaze::IsSchurExpr<T>::value, "Non-Schur product expression type detected" )
 Constraint on the data type.In case the given data type T is not a Schur product expression (i.e. a type derived from the SchurExpr base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_SCHUREXPR_TYPE(T)   static_assert( !::blaze::IsSchurExpr<T>::value, "Schur product expression type detected" )
 Constraint on the data type.In case the given data type T is a Schur product expression (i.e. a type derived from the SchurExpr base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_FORM_VALID_SCHUREXPR(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_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_SHRINKABLE_TYPE(T)   static_assert( ::blaze::IsShrinkable<T>::value, "Non-shrinkable type detected" )
 Constraint on the data type.In case the given data type T is not shrinkable, i.e. does not have a 'shrinkToFit' member function that could be used to reduce the capacity, a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_SHRINKABLE_TYPE(T)   static_assert( !::blaze::IsShrinkable<T>::value, "Shrinkable type detected" )
 Constraint on the data type.In case the given data type T is shrinkable, i.e. has a 'shrinkToFit' member function that can be used to reduce the capacity, a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_BE_SIMD_COMBINABLE_TYPES(T1, T2)   static_assert( ::blaze::IsSIMDCombinable<T1,T2>::value, "Non-SIMD combinable types detected" )
 Constraint on the data type.In case the given data types T1 and T2 are not SIMD combinable (i.e. do not have a common SIMD interface), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_SIMD_COMBINABLE_TYPES(T1, T2)   static_assert( !::blaze::IsSIMDCombinable<T1,T2>::value, "SIMD combinable types detected" )
 Constraint on the data type.In case the given data types T1 and T2 are SIMD combinable (i.e. do not have a common SIMD interface), 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_MATRIX_TYPE(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_MATRIX_TYPE(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_STATIC_TYPE(T)   static_assert( ::blaze::IsStatic<T>::value, "Non-static type detected" )
 Constraint on the data type.In case the given data type T is not a static data type, i.e. a vector or matrix with dimensions fixed at compile time, a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_STATIC_TYPE(T)   static_assert( !::blaze::IsStatic<T>::value, "Static type dected" )
 Constraint on the data type.In case the given data type T is a static data type, i.e. a vector or matrix with dimensions fixed at compile time, 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_TRANSFORMATION_TYPE(T)   static_assert( ::blaze::IsTransformation<T>::value, "Non-transformation type detected" )
 Constraint on the data type.In case the given data type T is not a transformation expression (i.e. a type derived from the Transformation base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_TRANSFORMATION_TYPE(T)   static_assert( !::blaze::IsTransformation<T>::value, "Transformation type detected" )
 Constraint on the data type.In case the given data type T is a transformation expression (i.e. a type derived from the Transformation 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_BE_UNARYMAPEXPR_TYPE(T)   static_assert( ::blaze::IsUnaryMapExpr<T>::value, "Non-unary map expression type detected" )
 Constraint on the data type.In case the given data type T is not a unary map expression (i.e. a type derived from the UnaryMapExpr base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_UNARYMAPEXPR_TYPE(T)   static_assert( !::blaze::IsUnaryMapExpr<T>::value, "Unary map expression type detected" )
 Constraint on the data type.In case the given data type T is a unary map expression (i.e. a type derived from the UnaryMapExpr base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_BE_UNIFORM_TYPE(T)   static_assert( ::blaze::IsUniform<T>::value, "Non-uniform type detected" )
 Constraint on the data type.In case the given data type T is not a uniform vector or matrix type, a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_UNIFORM_TYPE(T)   static_assert( !::blaze::IsUniform<T>::value, "Uniform type detected" )
 Constraint on the data type.In case the given data type T is a uniform vector or matrix type, a compilation error is created.
 
#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_VECMAPEXPR_TYPE(T)   static_assert( ::blaze::IsVecMapExpr<T>::value, "Non-unary vector map expression type detected" )
 Constraint on the data type.In case the given data type T is not a unary vector map expression (i.e. a type derived from the VecMapExpr base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_VECMAPEXPR_TYPE(T)   static_assert( !::blaze::IsVecMapExpr<T>::value, "Unary vector map expression type detected" )
 Constraint on the data type.In case the given data type T is a unary vector map expression (i.e. a type derived from the VecMapExpr 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_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_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_BE_VECVECMAPEXPR_TYPE(T)   static_assert( ::blaze::IsVecVecMapExpr<T>::value, "Non-binary vector map expression type detected" )
 Constraint on the data type.In case the given data type T is not a binary vector map expression (i.e. a type derived from the VecVecMapExpr base class), a compilation error is created.
 
#define BLAZE_CONSTRAINT_MUST_NOT_BE_VECVECMAPEXPR_TYPE(T)   static_assert( !::blaze::IsVecVecMapExpr<T>::value, "Binary vector map expression type detected" )
 Constraint on the data type.In case the given data type T is a binary vector map expression (i.e. a type derived from the VecVecMapExpr base class), a compilation error is created.
 
#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_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_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

◆ BLAZE_CONSTRAINT_MATRICES_MUST_HAVE_DIFFERENT_STORAGE_ORDER

#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:103
Evaluation of the storage order of a given matrix type.Via this type trait it is possible to evaluate...
Definition: StorageOrder.h:99

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.

◆ BLAZE_CONSTRAINT_MATRICES_MUST_HAVE_SAME_STORAGE_ORDER

#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:103
Evaluation of the storage order of a given matrix type.Via this type trait it is possible to evaluate...
Definition: StorageOrder.h:99

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.

◆ BLAZE_CONSTRAINT_MUST_BE_MATRIX_WITH_STORAGE_ORDER

#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:103
Evaluation of the storage order of a given matrix type.Via this type trait it is possible to evaluate...
Definition: StorageOrder.h:99

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.

◆ BLAZE_CONSTRAINT_MUST_BE_VECTOR_WITH_TRANSPOSE_FLAG

#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:104
Evaluation of the transpose flag of a given matrix type.Via this type trait it is possible to evaluat...
Definition: TransposeFlag.h:99

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.

◆ BLAZE_CONSTRAINT_MUST_FORM_VALID_MATMATADDEXPR

#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 alias declaration compares the two given types using the equal...
Definition: Equal.h:73
Compile time check for matrix types.This type trait tests whether or not the given template parameter...
Definition: IsMatrix.h:103
Compile time logical or evaluation.The Or alias declaration performs at compile time a logical or (&#39;&&&#3...
Definition: Or.h:76
Compile time evaluation of the number of columns of a matrix.The Columns type trait evaluates the num...
Definition: Columns.h:75
Compile time evaluation of the number of rows of a matrix.The Rows type trait evaluates the number of...
Definition: Rows.h:75
Compile time logical and evaluation.The And alias declaration performs at compile time a logical and ...
Definition: And.h:76

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.

◆ BLAZE_CONSTRAINT_MUST_FORM_VALID_MATMATMULTEXPR

#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 alias declaration compares the two given types using the equal...
Definition: Equal.h:73
Compile time check for matrix types.This type trait tests whether or not the given template parameter...
Definition: IsMatrix.h:103
Compile time logical or evaluation.The Or alias declaration performs at compile time a logical or (&#39;&&&#3...
Definition: Or.h:76
Compile time evaluation of the number of columns of a matrix.The Columns type trait evaluates the num...
Definition: Columns.h:75
Compile time evaluation of the number of rows of a matrix.The Rows type trait evaluates the number of...
Definition: Rows.h:75
Compile time logical and evaluation.The And alias declaration performs at compile time a logical and ...
Definition: And.h:76

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.

◆ BLAZE_CONSTRAINT_MUST_FORM_VALID_MATMATSUBEXPR

#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 alias declaration compares the two given types using the equal...
Definition: Equal.h:73
Compile time check for matrix types.This type trait tests whether or not the given template parameter...
Definition: IsMatrix.h:103
Compile time logical or evaluation.The Or alias declaration performs at compile time a logical or (&#39;&&&#3...
Definition: Or.h:76
Compile time evaluation of the number of columns of a matrix.The Columns type trait evaluates the num...
Definition: Columns.h:75
Compile time evaluation of the number of rows of a matrix.The Rows type trait evaluates the number of...
Definition: Rows.h:75
Compile time logical and evaluation.The And alias declaration performs at compile time a logical and ...
Definition: And.h:76

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.

◆ BLAZE_CONSTRAINT_MUST_FORM_VALID_MATVECMULTEXPR

#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 alias declaration compares the two given types using the equal...
Definition: Equal.h:73
Compile time check for matrix types.This type trait tests whether or not the given template parameter...
Definition: IsMatrix.h:103
Compile time check for column vector types.This type trait tests whether or not the given template ar...
Definition: IsColumnVector.h:107
Compile time logical or evaluation.The Or alias declaration performs at compile time a logical or (&#39;&&&#3...
Definition: Or.h:76
Compile time evaluation of the size of a vector.The Size type trait evaluates the size of the given v...
Definition: Size.h:74
Compile time evaluation of the number of columns of a matrix.The Columns type trait evaluates the num...
Definition: Columns.h:75
Compile time logical and evaluation.The And alias declaration performs at compile time a logical and ...
Definition: And.h:76

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.

◆ BLAZE_CONSTRAINT_MUST_FORM_VALID_SCHUREXPR

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

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.

◆ BLAZE_CONSTRAINT_MUST_FORM_VALID_TVECMATMULTEXPR

#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:107
Compile time type comparison.The Equal alias declaration compares the two given types using the equal...
Definition: Equal.h:73
Compile time check for matrix types.This type trait tests whether or not the given template parameter...
Definition: IsMatrix.h:103
Compile time logical or evaluation.The Or alias declaration performs at compile time a logical or (&#39;&&&#3...
Definition: Or.h:76
Compile time evaluation of the size of a vector.The Size type trait evaluates the size of the given v...
Definition: Size.h:74
Compile time evaluation of the number of rows of a matrix.The Rows type trait evaluates the number of...
Definition: Rows.h:75
Compile time logical and evaluation.The And alias declaration performs at compile time a logical and ...
Definition: And.h:76

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.

◆ BLAZE_CONSTRAINT_MUST_FORM_VALID_VECTVECMULTEXPR

#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:107
Compile time check for column vector types.This type trait tests whether or not the given template ar...
Definition: IsColumnVector.h:107
Compile time logical and evaluation.The And alias declaration performs at compile time a logical and ...
Definition: And.h:76

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.

◆ BLAZE_CONSTRAINT_MUST_FORM_VALID_VECVECADDEXPR

#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:107
Compile time type comparison.The Equal alias declaration compares the two given types using the equal...
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:107
Compile time logical or evaluation.The Or alias declaration performs at compile time a logical or (&#39;&&&#3...
Definition: Or.h:76
Compile time evaluation of the size of a vector.The Size type trait evaluates the size of the given v...
Definition: Size.h:74
Compile time logical and evaluation.The And alias declaration performs at compile time a logical and ...
Definition: And.h:76

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.

◆ BLAZE_CONSTRAINT_MUST_FORM_VALID_VECVECDIVEXPR

#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:107
Compile time type comparison.The Equal alias declaration compares the two given types using the equal...
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:107
Compile time logical or evaluation.The Or alias declaration performs at compile time a logical or (&#39;&&&#3...
Definition: Or.h:76
Compile time evaluation of the size of a vector.The Size type trait evaluates the size of the given v...
Definition: Size.h:74
Compile time logical and evaluation.The And alias declaration performs at compile time a logical and ...
Definition: And.h:76

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.

◆ BLAZE_CONSTRAINT_MUST_FORM_VALID_VECVECMULTEXPR

#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:107
Compile time type comparison.The Equal alias declaration compares the two given types using the equal...
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:107
Compile time logical or evaluation.The Or alias declaration performs at compile time a logical or (&#39;&&&#3...
Definition: Or.h:76
Compile time evaluation of the size of a vector.The Size type trait evaluates the size of the given v...
Definition: Size.h:74
Compile time logical and evaluation.The And alias declaration performs at compile time a logical and ...
Definition: And.h:76

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.

◆ BLAZE_CONSTRAINT_MUST_FORM_VALID_VECVECSUBEXPR

#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:107
Compile time type comparison.The Equal alias declaration compares the two given types using the equal...
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:107
Compile time logical or evaluation.The Or alias declaration performs at compile time a logical or (&#39;&&&#3...
Definition: Or.h:76
Compile time evaluation of the size of a vector.The Size type trait evaluates the size of the given v...
Definition: Size.h:74
Compile time logical and evaluation.The And alias declaration performs at compile time a logical and ...
Definition: And.h:76

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.

◆ BLAZE_CONSTRAINT_MUST_HAVE_EQUAL_NUMBER_OF_COLUMNS

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

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.

◆ BLAZE_CONSTRAINT_MUST_HAVE_EQUAL_NUMBER_OF_ROWS

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

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.

◆ BLAZE_CONSTRAINT_MUST_HAVE_EQUAL_SIZE

#define BLAZE_CONSTRAINT_MUST_HAVE_EQUAL_SIZE (   T1,
  T2 
)
Value:
>::value, "Invalid size detected" )
Compile time type comparison.The Equal alias declaration compares the two given types using the equal...
Definition: Equal.h:73
Compile time logical or evaluation.The Or alias declaration performs at compile time a logical or (&#39;&&&#3...
Definition: Or.h:76
Compile time evaluation of the size of a vector.The Size type trait evaluates the size of the given v...
Definition: Size.h:74

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.

◆ BLAZE_CONSTRAINT_MUST_NOT_HAVE_EQUAL_NUMBER_OF_COLUMNS

#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 alias declaration compares the two given types using the equal...
Definition: Equal.h:73
Compile time type negation.The Not alias declaration negates the given compile time condition...
Definition: Not.h:70
Compile time logical or evaluation.The Or alias declaration performs at compile time a logical or (&#39;&&&#3...
Definition: Or.h:76
Compile time evaluation of the number of columns of a matrix.The Columns type trait evaluates the num...
Definition: Columns.h:75

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.

◆ BLAZE_CONSTRAINT_MUST_NOT_HAVE_EQUAL_NUMBER_OF_ROWS

#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 alias declaration compares the two given types using the equal...
Definition: Equal.h:73
Compile time type negation.The Not alias declaration negates the given compile time condition...
Definition: Not.h:70
Compile time logical or evaluation.The Or alias declaration performs at compile time a logical or (&#39;&&&#3...
Definition: Or.h:76
Compile time evaluation of the number of rows of a matrix.The Rows type trait evaluates the number of...
Definition: Rows.h:75

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.

◆ BLAZE_CONSTRAINT_MUST_NOT_HAVE_EQUAL_SIZE

#define BLAZE_CONSTRAINT_MUST_NOT_HAVE_EQUAL_SIZE (   T1,
  T2 
)
Value:
>::value, "Invalid size detected" )
Compile time type comparison.The Equal alias declaration compares the two given types using the equal...
Definition: Equal.h:73
Compile time type negation.The Not alias declaration negates the given compile time condition...
Definition: Not.h:70
Compile time logical or evaluation.The Or alias declaration performs at compile time a logical or (&#39;&&&#3...
Definition: Or.h:76
Compile time evaluation of the size of a vector.The Size type trait evaluates the size of the given v...
Definition: Size.h:74

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.

◆ BLAZE_CONSTRAINT_VECTORS_MUST_HAVE_DIFFERENT_TRANSPOSE_FLAG

#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:104
Evaluation of the transpose flag of a given matrix type.Via this type trait it is possible to evaluat...
Definition: TransposeFlag.h:99

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.

◆ BLAZE_CONSTRAINT_VECTORS_MUST_HAVE_SAME_TRANSPOSE_FLAG

#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:104
Evaluation of the transpose flag of a given matrix type.Via this type trait it is possible to evaluat...
Definition: TransposeFlag.h:99

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.